Question

你好c ++程序员。我遇到了一些我无法理解的问题。出于可读性的原因，我已经删除了以下程序，并留下了我遇到的问题。我试图重载+和=运算符，但使用动态创建的数组。 +和=运算符方法本身就产生了正确的结果。但是，当我尝试将+运算符的结果赋给* poly3时，我从编译器得到“* poly3需要初始化”。如果我做初始化它没有任何东西被赋予它（我的意思是+的结果）。我的问题是，做到这一点的正确方法是什么。我需要结果poly3是动态数组或指针，所以我可以使用它后者。

非常感谢您的帮助。

class Polynomial
{
    private:
        int *poly;
        int size;
    public:
        Polynomial();
        Polynomial(int);
        Polynomial(string,int);
        ~Polynomial();
        void setPoly(string);
        int *getPoly() const;
        Polynomial operator+(Polynomial&);
        void operator=(const Polynomial&);
};

Polynomial::Polynomial(string polyInput, int s) 
{
    size = s+1;

     poly = new int[size];
    //set all coef position to 0
    for(int i = 0; i < size; i++){
        *(poly + i) = 0;
    }
    setPoly(polyInput);
}

Polynomial Polynomial::operator+(Polynomial &polyRight)
{
    Polynomial *result = new Polynomial(size);

    for(int i = 0; i < size; i++)
        result->poly[i] = poly[i] + polyRight.poly[i];
    return *result;
}

void Polynomial::operator=(const Polynomial &polyRight)
{
    size = polyRight.size;
    for(int i = 0; i < size; i++){
        *(poly + i) = polyRight.poly[i];
    }
}

int main()
{
    int highestExp = 4;
    Polynomial *poly1;
    Polynomial *poly2;
    Polynomial *poly3;// = new Polynomial(highestExp); // for the result
    string input1,input2;



    ifstream inputFile("data.txt");

    getline(inputFile, input1);
    getline(inputFile, input2);

    poly1 = new Polynomial(input1,highestExp);
    poly2 = new Polynomial(input2,highestExp);

    *poly3 = *poly1 + *poly2;

    system("pause");
    return 0;
}

Answer 1

赋值运算符必须返回对分配给：

的实例的引用

Polynomial& operator=(const Polynomial&);

在实施中，您应该return *this;。您还必须确保实现对于分配不同大小的多项式是可靠的。目前情况似乎并非如此。

然后，在main中，poly3未初始化。只需删除指针并将所有poly实例化为自动存储，main()中的局部变量：

Polynomial poly1(input1,highestExp);
Polynomial poly2(input2,highestExp);
Polynimial poly3 = poly1 + poly2;

顺便说一句，你的operator+有内存泄漏。你不应该使用new int。创建一个本地Polynomial并将其返回。

此外，没有析构函数负责释放资源，因此Polynomial的每个实例化都会导致内存泄漏。你的课有太多的责任：管理资源和多项式。您应该让其他班级负责内存管理。使用std::vector<int>，或者，如果这是一个练习，请编写自己的动态数组类，并在Polynomial内使用。

Answer 2

首先：

                                             // allow adding const
const Polynomial Polynomial::operator+(const Polynomial &polyRight) const
{
    Polynomial result(size); // don't use a pointer

    for(int i = 0; i < size; i++)
        result.poly[i] = poly[i] + polyRight.poly[i];
    return result;
}

制作返回const以避免(A+B)=C;

的愚蠢

Polynomial&  Polynomial::operator=(const Polynomial &polyRight) // return a reference
{
    size = polyRight.size;
    for(int i = 0; i < size; i++){
        *(poly + i) = polyRight.poly[i];
    }
    return *this; // allow chaining
}

请注意，一旦你修补了它，你需要在operator =()中防范A = A：

if (this == &rhs)
{
     // do stuff
}
return *this;

Answer 3

指针指向显式分配给它的内存位置。

Ptr* pt = new Ptr();//pt points to a valid address in memory

Ptr* pt;//pt has not yet been initialized

即。它没有指向任何有效的地址。使用pt可能会导致意外行为。默认情况下，指针应指向NULL并且应该检查它们！NULL然后使用。

在上面的代码中Polynomial * poly3;没有指向任何位置，当我们这样做 * pol3我们实际上是取消引用一个从未创建的位置。

当你做多项式* poly3 = new Polynomial（highestExp）;时，你将poly3指向某个有效位置，因此* pol3 = * poly1 + * pol2是有意义的。但要注意当你为poly3做一个新的时，你要再创建一个堆存储，所以你必须确保释放堆上分配的所有内存。

更好的解决方案是让你的opertor +返回一个有效的指针并将它映射到poly3，如下所示：

Polynomial* Polynomial::operator+(Polynomial &polyRight)
{
  Polynomial *result = new Polynomial(size);

  for(int i = 0; i < size; i++)
    result->poly[i] = poly[i] + polyRight.poly[i];
  return result;
}

//并在主

中

poly3 = (*poly1 + *poly2);

Answer 4

这是一个非常简洁，功能略有不同，内存管理更好。由于我不知道输入文件的格式，因此我跳过了文件部分的读取，只使用了Polynomial(countOfExponents, x0, x1, x2, x3, ... , xn)

形式的新构造函数。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdarg>

using namespace std;


class Polynomial
{
    private:
        int *poly;
        int size;
    public:
        Polynomial() : size(0), poly(NULL) {}
        Polynomial(int size, ... );
        ~Polynomial() { delete[](poly); }

        void allocate(int size) { 
            if (NULL!=poly) {
                delete[](poly);
            }
            Polynomial::size = size; 
            poly=new int[size]; 
        }
        Polynomial operator+(const Polynomial&) const;
        Polynomial &operator=(const Polynomial&);
        int exponent(int p) const {
            return (p<size) ? poly[p] : 0;
        }
        string str() const;
};

Polynomial::Polynomial(int size, ...) : size(size) {
    va_list varargs;
    va_start(varargs, size);
    poly = new int[size];
    for (int i=0; i<size; i++) {
        poly[i] = va_arg(varargs, int);
    }
    va_end(varargs);
}

Polynomial Polynomial::operator+(const Polynomial &polyRight) const
{
    int newSize = max(size, polyRight.size);
    Polynomial result;
    result.allocate(newSize);

    for(int i = 0; i < newSize; i++)
        result.poly[i] = exponent(i) + polyRight.exponent(i);
    return result;
}

Polynomial &Polynomial::operator=(const Polynomial &polyRight)
{
    allocate(polyRight.size);
    memcpy(poly, polyRight.poly, sizeof(int) * size);
    return *this;
}

string Polynomial::str() const {
    stringstream out;
    for (int i=size-1; i>=0; i--) {
        out << poly[i];
        if (0<i) {
            out << "  ";
        }
    }
    return out.str();
}

int main()
{
    Polynomial one(3, 1, 2, 3);
    Polynomial two(3, 2, 3, 4);
    cout << one.str() << endl;
    cout << two.str() << endl;
    Polynomial three = one + two;
    cout << three.str() << endl;
    return 0;
}

请注意，在处理不同大小的多项式时，我也要注意不要解决可能不存在的内存。在少于n个指数的多项式上访问poly [n]会导致麻烦。相反，使用指数（n）函数，该函数将为多于多项式内的所有指数返回0。

运算符重载指针

4 个答案: