C++ 重载运算符[]以用作多项式类的setter

我已经创建了一个多项式类，但我想重载索引运算符以用作setter，例如，myPolyObject[0]=2.5，但在尝试重载它时，它给了我一个错误

class Polynomial
{
public:
    Polynomial();
    Polynomial(Polynomial&);
    Polynomial(double* coefficient, int size);
    ~Polynomial() { delete [] polynomial ; }
    double operator [] (int exponent) const;
    friend ostream& operator << ( ostream& , const Polynomial&);
    Polynomial& operator = (const Polynomial&);
    double evaluate(double x) const;
    int getSize() const;
    double operator [] (int exponent, double coefficient);
    Polynomial& operator + ( Polynomial& );
    Polynomial& operator + ( double x );
    Polynomial& operator - (Polynomial&);
    Polynomial& operator - (double x);
    Polynomial& operator * (Polynomial&);
    Polynomial& operator * (double x);
private:
    double* polynomial;
};

类多项式
{
公众：
多项式（）；
多项式（多项式&）；
多项式（双*系数，整数大小）；
~polymone（）{delete[]多项式；}
双运算符[]（整数指数）常数；
friend ostream&operator您的问题似乎需要两件不同的事情，第一点在评论中得到回答，返回一个参考。下面是一个完整性示例

struct example
{
    double value_[10];
    double& operator [] (int index) {
       return value_[index];
    }
};

int main() {
    example e;
    e[0] = 2.2;
    std::cout << e.value_[0] << std::endl;
}


或者，如果确实需要逗号，可以为指数创建自己的类型并重载逗号运算符

struct exponent
{
    int exp_;
    double coeff_;
    exponent(int value) : exp_(value),coeff_(0){}

    operator std::pair<int,double>() {
        return std::make_pair(exp_,coeff_);
    }

    exponent& operator,(double coeff) {
        coeff_ = coeff;
        return *this;
    }
};

struct example
{
    double operator [] (const std::pair<int,double>& values) {
        return 2.0;
    }
};

int main() {
    example e;
    e[exponent(1), 3.3];
}

结构指数
{
国际经验；
双系数；
指数（int值）：exp_u0（值），coeff_0{}
运算符std:：pair（）{
返回std：：make_pair（exp_u，coeff_u）；
}
指数和运算符（双系数）{
系数=系数；
归还*这个；
}
};
结构示例
{
双运算符[]（常量标准：：对和值）{
回报率2.0；
}
};
int main（）{
示例e；
e[指数（1），3.3]；
}

---

我个人会选择第一个选项，或者重载

操作符（）

。

您的问题似乎需要两个不同的东西，第一个部分在注释中回答，返回一个引用。下面是一个完整性示例

struct example
{
    double value_[10];
    double& operator [] (int index) {
       return value_[index];
    }
};

int main() {
    example e;
    e[0] = 2.2;
    std::cout << e.value_[0] << std::endl;
}

或者，如果确实需要逗号，可以为指数创建自己的类型并重载逗号运算符

struct exponent
{
    int exp_;
    double coeff_;
    exponent(int value) : exp_(value),coeff_(0){}

    operator std::pair<int,double>() {
        return std::make_pair(exp_,coeff_);
    }

    exponent& operator,(double coeff) {
        coeff_ = coeff;
        return *this;
    }
};

struct example
{
    double operator [] (const std::pair<int,double>& values) {
        return 2.0;
    }
};

int main() {
    example e;
    e[exponent(1), 3.3];
}

结构指数 { 国际经验； 双系数； 指数（int值）：exp_u0（值），coeff_0{} 运算符std:：pair（）{ 返回std：：make_pair（exp_u，coeff_u）； } 指数和运算符（双系数）{ 系数=系数； 归还*这个； } }; 结构示例 { 双运算符[]（常量标准：：对和值）{ 回报率2.0； } }; int main（）{ 示例e； e[指数（1），3.3]； }

---

我个人喜欢第一个选项，或者重载

operator（）

。

double&operator[]（int-exponent）

。你必须安排操作符返回一个引用到一个可以存储系数的

double

值。但是我该如何设置指数和值呢？如果你像Igor所说的那样返回一个引用，你只需获取该引用并将其设置为值。听起来很混乱，因此：将其重写为

double&operator[]（int-exponent）；

并简单地像

多项式[5]=7那样；

就像您可能想要的那样。

双精度&运算符[]（int-exponent）

。你必须安排操作符返回一个引用到一个可以存储系数的

double

值。但是我该如何设置指数和值呢？如果你像Igor所说的那样返回一个引用，你只需获取该引用并将其设置为值。听起来很混乱，因此：将其重写为

double&operator[]（int-exponent）；

然后简单地像

多项式[5]=7一样；

就像你可能想要的那样。“你不能让运算符[]有多个参数”你不能这样做：

运算符[]（arg1，arg2）

虽然丑陋而且挑剔。不过，答案很好。@doug不，你不能定义一个重载的

运算符[]

首先接受两个参数。

运算符[]

必须是只接受一个参数的成员函数。是的，你是对的。很抱歉你的评论很愚蠢。回答很好，顺便说一句。“你不能让运算符[]有多个参数”你不能这样做：

运算符[]（arg1，arg2）

虽然丑陋而且挑剔。但是，答案很好。@doug不，你不能定义一个重载的

运算符[]

首先使用两个参数。

运算符[]

必须是一个只使用一个参数的成员函数。是的，你是对的。很抱歉你的评论很愚蠢。回答很好，顺便说一句。