C++多项式类operator+重载后x^8项输出异常垃圾值问题求助

你遇到的无意义大数值是数组越界访问野内存导致的，代码存在以下多处错误：

• 加法运算符重载逻辑错误：创建临时对象tp时默认只申请了长度为5的int数组，仅修改tp.capacity的值为两个多项式的最大容量，没有为tp的degree数组重新申请对应长度的内存，循环访问下标≥5的位置时属于数组越界，访问到未初始化的野内存就会输出随机值。
• 加法运算符的边界判断错误：数组下标有效范围是[0, capacity-1]，原判断条件写的i <= capacity会触发越界访问。
• 拷贝构造函数逻辑错误：原代码this -> degree[i] = degree[i];是将刚申请的未初始化数组的值赋值给自己，正确应该是赋值为参数对象p的对应系数。
• 赋值运算符重载存在内存泄漏：未先释放当前对象原本持有的degree数组内存，直接申请新内存会导致旧内存泄漏。
• 减法运算符重载存在和加法完全相同的数组越界问题，临时对象tp的degree数组未扩容。

#include <iostream>
#include <algorithm>
using namespace std ;

class polynomial {
    int* degree ;
    int capacity ;
public:
    polynomial () {
        degree = new int[5];
        for ( int i = 0 ; i < 5 ; i ++){
            degree[i] = 0 ;
        }
        capacity = 5 ;
    }

    // 修复拷贝构造函数
    polynomial (const polynomial&  p){
        this -> degree = new int[p.capacity];
        for( int i = 0 ; i < p.capacity ; i++){
            this -> degree[i] = p.degree[i];
        }
        this -> capacity = p.capacity;
    }

    // 修复赋值运算符重载，先释放旧内存
    void operator=(polynomial const &p){
        delete [] this->degree;
        this -> degree = new int[p.capacity];
        for( int i = 0 ; i < p.capacity ; i++){
            this -> degree[i] = p.degree[i];
        }
        this -> capacity = p.capacity;
    }

    void print(){
        for ( int i = 0 ; i < capacity ; i ++ ){
            if( degree[i] >= 0)
                cout << "+"<< degree[i] <<"x^" <<i<<" ";
            else 
                cout<< degree[i] <<"x^" <<i << " ";
        }
        cout << endl;
    }

    void setCoefficient( int de , int num ){
        if( de < capacity ){
            degree[de] =  num ;
        }
        else {
            int ic = capacity ;
            capacity = capacity+(de-capacity+1) ;
            int* ne = new int[capacity];
            for( int i = 0 ; i < capacity ; i ++){
                ne[i] = 0 ;
            }
            for( int i = 0 ; i < ic; i ++){
                ne[i] = degree[i];
            }
            delete [] degree;
            degree = ne;
            degree[de] = num ;
        }
    }

    // 修复加法运算符重载
    polynomial operator+( polynomial const &p){
        polynomial tp ;
        int max_cap = max(capacity, p.capacity);
        // 为临时对象扩容到足够大小
        delete [] tp.degree;
        tp.degree = new int[max_cap];
        for(int i=0; i<max_cap; i++){
            tp.degree[i] = 0;
        }
        tp.capacity = max_cap;

        for(int i = 0; i < max_cap; i ++){
            if(i < capacity && i < p.capacity) {
                tp.degree[i] = degree[i] + p.degree[i];
            }else if (i < p.capacity) {
                tp.degree[i] = p.degree[i];
            }else {
                tp.degree[i] = degree[i];
            }
        }
        return tp;
    }

    // 修复减法运算符重载
    polynomial operator-( polynomial const &p){
        polynomial tp ;
        int max_cap = max(capacity, p.capacity);
        // 为临时对象扩容到足够大小
        delete [] tp.degree;
        tp.degree = new int[max_cap];
        for(int i=0; i<max_cap; i++){
            tp.degree[i] = 0;
        }
        tp.capacity = max_cap;

        for(int i = 0; i < max_cap; i ++){
            if(i < capacity && i < p.capacity) {
                tp.degree[i] = degree[i] - p.degree[i];
            }else if (i < p.capacity) {
                tp.degree[i] = 0 - p.degree[i];
            }else {
                tp.degree[i] = degree[i];
            }
        }
        return tp;
    }

    // 补充析构函数释放内存，避免整体内存泄漏
    ~polynomial(){
        delete [] degree;
    }
};

int main (){
    polynomial p1 , p2 ;
    p1.setCoefficient(4, -5);
    p1.setCoefficient(0,+2);
    p1.print();
    p2.setCoefficient(8,-9);
    p2.setCoefficient(4,+6);
    p2.print();
    polynomial p3 = p1 + p2;
    p3.print();
    return 0;
}

内容的提问来源于stack exchange，提问作者Amit khurrana