c++ - 如何创建一个不同大小的数组作为私有(private)类变量？

Question

我正在尝试创建一个程序，它从用户那里获取多项式函数，计算它拥有的项数，创建一个足够大的数组来存储所有项，然后将项存储在那里。问题是我不太确定在程序确定函数有多大之后如何添加一个私有(private)类变量(或更具体地说，一个字符串数组)。我需要将此字符串数组作为私有(private)类变量，因为我希望能够通过其他类方法访问其内容以执行诸如计算每个函数项之类的操作。

主要.cpp:

#include <iostream>
#include <string>
#include "Function.h"
using namespace std;

int main()
{
    Function func1;
    func1.coutFuncTerms();
    func1.coutFunc();
    return 0;
}

函数.h:

#ifndef FUNCTION_H
#define FUNCTION_H

#include <iostream>
#include <string>
#include "Function.h"
using namespace std;

class Function
{
    public:
        Function();
        ~Function();
        void removePlus(string*);
        void removeWhitespace(string*);
        void setFuncTerms();
        void splitTerms();
        void coutFuncTerms();
        void coutFunc();
        void coutTerms(string);
    protected:
    private:
        string func;
        int funcTerms;
};

#endif

函数.cpp:

#include <iostream>
#include <string>
#include "Function.h"
using namespace std;

// Function Constructor
//
// Stores a function inputted by the user
// Adds a null character ('\0') to the end of a string
// Erases a redundant '+' sign at the beginning of a string if there's one there
// Erases any whitespace characters in a string
// Stores the number of terms in the function
Function::Function()
{
    getline(cin, func);
    setFuncTerms();
    //splitTerms();
}

Function::~Function()
{

}

// removePlus Function
//
// Erases a redundant '+' sign at the beginning of a string if there's one there
void Function::removePlus(string* func)
{
    if(func->at(0) == '+')
    {
        func->erase(0, 1);
    }
}

// removeWhitespace Function
//
// Erases any whitespace characters in a string
void Function::removeWhitespace(string* func)
{
    for(int x = 0; unsigned(x) < func->length() - 1; x++)
    {
        while(func->at(x) == ' ' || func->at(x) == '\t')
        {
            func->erase(x, 1);
        }
    }
}

// setFuncLength Function
//
// Finds the number of terms in a Function object's 'func' variable
// Assigns this number to the object's 'funcLength' variable
void Function::setFuncTerms()
{
    funcTerms = 0;
    for(int funcTerm = 0; unsigned(funcTerm) < func.length(); funcTerm += 1)
    {
        bool isAPotentialTerm = false;
        bool isATrueTerm = false;
        if(func.at(funcTerm) == '+' || func.at(funcTerm) == '-')
        {
            isAPotentialTerm = true;
        }
        if(isAPotentialTerm == true)
        {
            for(int newFuncTerm = funcTerm + 1; unsigned(newFuncTerm) < func.length(); newFuncTerm += 1)
            {
                if(func.at(newFuncTerm) == '+' || func.at(newFuncTerm) == '-')
                {
                    break;
                }
                if(func.at(newFuncTerm) != ' ' && func.at(newFuncTerm) != '\t')
                {
                    isATrueTerm = true;
                    break;
                }
            }
        }
        if(isATrueTerm)
        {
            funcTerms++;
        }
    }
}

// splitTerms Function
//
// Calls the splitTerm function for each term in 'func' according to the function array 'funcArray'
void Function::splitTerms()
{
    string funcArray[funcTerms];
    int tempFuncLength = 0;
    for(int funcTerm = 0; unsigned(funcTerm) < func.length(); funcTerm += 1)
    {
        bool isAPotentialTerm = false;
        bool isATrueTerm = false;
        if(func.at(funcTerm) == '+' || func.at(funcTerm) == '-')
        {
            isAPotentialTerm = true;
        }
        if(isAPotentialTerm == true)
        {
            for(int newFuncTerm = funcTerm + 1; unsigned(newFuncTerm) < func.length(); newFuncTerm += 1)
            {
                if(func.at(newFuncTerm) == '+' || func.at(newFuncTerm) == '-')
                {
                    break;
                }
                if(func.at(newFuncTerm) != ' ' && func.at(newFuncTerm) != '\t')
                {
                    isATrueTerm = true;
                    break;
                }
            }
        }
        if(isATrueTerm)
        {
            string temp;
            for(; unsigned(funcTerm) < func.length() && func.at(funcTerm) != '+' && func.at(funcTerm) != '-'; funcTerm += 1)
            {
                funcArray[tempFuncLength].append(1, func.at(funcTerm));
            }
            tempFuncLength++;
        }
    }
    for(int x = 0; x < funcTerms; x++)
    {
        cout << "Term " << x + 1 << " is: " << funcArray[x] << endl;
    }
}

void Function::coutFuncTerms()
{
    cout << "Terms: " << funcTerms << endl;
}

void Function::coutFunc()
{
    cout << "Function: " << func << endl;
}

void Function::coutTerms(string funcArrayTerm)
{
    /*for(int x = 0; x < funcLength; x++)
    {
        cout << "Term " << x << " is: " << funcArray[x] << endl;
    }*/
    //cout << funcArray[0] << endl;
}

Answer 1

我强烈建议您更改设计。

函数 是术语 的容器。那么让我们定义一个术语:

一个项至少有一个系数和一个指数:

struct Fundamental_Term
{
  double coefficient;
  int    exponent;
};

如果您的函数仅根据一个变量，您所需要的只是Fundamental_Term。否则，您需要具有基本变量名称:

struct Term_With_Base
: public Fundamental_Term
{
  std::string variable_name;
};

注意:如果不能使用继承，将Fundamental_Term的成员变量复制到Term_With_Base中。

请记住，函数 是术语的集合或容器。假设一个函数有多个基数，我们可以声明:

struct Function
{
  std::vector<Term_With_Base> terms;
};

条款评估
要评估函数 f(x)，必须评估所有项并将其结果相加。这分解为两个要求:1)术语必须具有评估方法； 2)函数类必须有求和项的求值方法。

因此，我们向基类添加一个评估函数:

struct Fundamental_Term
{
  double coefficient;
  int exponent;
  double evaluate(double value)
  {
    return coefficient * pow(value, exponent);
  }
};

struct Function
{
  std::vector<Term_With_Base> terms;
  double evauate(double value)
  {
    const unsigned int quantity = terms.size();
    double result = 0.0;
    for (unsigned int i = 0; i < quantity; ++i)
    {
      result = result + terms[i].evaluate(value);
    }
    return result;
   }
};

从字符串创建函数时，首选是创建一个接受字符串参数的 Fundamental_Term 的构造函数。术语对象应该读取它的系数、变量名和指数，而不是函数容器。

有关更多示例，请在 StackOverflow 中搜索“c++ parse term evaluation”。

编辑 1:插入术语
插入术语的一种方法是在术语数据结构中有一个方法从字符串加载术语:

bool
Fundamental_Term ::
load_from string(const std::string& input,
                 unsigned int &     start_position)
{
  bool term_is_valid = false;
  // Parse the string and load appropriate fields.
  // Set the start position to the first position after the valid term.
  // Set term_is_valid to true if the term has valid syntax.
  return term_is_valid;
}

Function 对象将有一个成员来从字符串中加载术语。

bool
Function ::
load_terms_from_string(const std::string& input)
{
  Term_With_Base term;
  unsigned int   position_in_string = 0;
  bool           term_is_valid = true;
  while (term_is_valid && (position_in_string < input.size()))
  {
    term_is_valid = term.load_from_string(input, position_in_string);
    if (term_is_valid)
    {
      terms.push_back(term);
    }
  }
}

用于包含术语的 std::vector 将根据需要随着解析的每个附加术语进行扩展。当字符串被解析或存在无效术语时，循环将终止。