C++ - значения массива в функции члена класса спонтанно меняются

Question

У меня возникли проблемы с перегрузкой оператора * = в моем классе полиномов. Я включил все, что я считал релевантным для решения проблемы ниже. Прошу прощения за длину кода.

Вот частички моего заголовка класса, которые, я думаю, актуальны.

#ifndef POL_H 
#define POL_H 
#include <string> 
#include <iostream> 
#include <vector> 
#include <cmath> 

using namespace std; 

class Pol 
{ 
    // private data members 

    string polname; // polynomial name 
    int degree;  // polynomial degree 
    int *coef;  // array with polynomial coefficients 

public: 

    // constructors 

    Pol(string, int, int*);   // with input name, degree 
            // and array of coefficients 
    // operator overloading 

    Pol operator *= (Pol); 

    // other methods 

    void PrintPol(); 

Это мой файл .C с перегрузкой * =. Я решил не включать метод PrintPol, поскольку он очень длинный, и я почти на 100% уверен, что проблема не в этом.

#include "Pol.h" 

Pol::Pol (string s, int d, int *c) 
{ 
    degree = d; 
    polname = s; 
    coef = new int [degree + 1]; 
    coef = c; 

    // initializes polynomial of degree d with c coefficients 
    // named s 
} 

Pol Pol::operator *= (Pol p1) 
{ 
    int *cp = this->coef; // If I print the values stored in cp at this point 
         // everything is alright 

    for (int i = p1.degree; i >= 0; --i) 
    { 
     for (int j = this->degree; j >= 0; --j) 
    { 
     this->coef[i + j] += p1.coef[i] * cp[j]; 
     cout << cp[j] << endl; // When I print the values here, they've changed! 
    } 
    } 

    this->degree += p1.degree; 

    return *this; 
} 

Моя первая мысль была, что, возможно, я был переступая границы массива, но размер массива сП я создаю это this-> степень, а также самое высокое значение, что «J» предполагает, поэтому я думаю, что этого не может быть.

Вот только моя основная функция. Я сомневаюсь, что проблема здесь, но я все равно включил ее, чтобы вы могли видеть, как я использую методы, которые я объявил.

#include "Pol.h" 
#include <iostream> 

using namespace std; 

int main() 
{ 
    int a [9] = {0, 0, 2, 4, 0, 0, 5, 0, 1}; 
    int b [5] = {4, -2, 0, 0, 1}; 

    Pol P2 ("P2", 4, b); 
    Pol P4 ("P4", 8, a); 

    P4*= P2; 
    P4.PrintPol(); 

    return 0; 
} 

Это, наверное, действительно очевидно, и я просто сделать осел из себя, но я смотрел на коде в течение нескольких часов, и я не могу понять это. Заранее спасибо.

Answer 1

Вы спрашиваете о перегрузке *=, но проблема не имеет ничего общего с *=. Вы говорите, что ваши значения массива меняются «спонтанно», но вы явно меняете их сами, прямо там, в коде.

int *cp = this->coef; // "If I print the values stored in cp at this point 
         // everything is alright" 

for (int i = p1.degree; i >= 0; --i) { 
    for (int j = this->degree; j >= 0; --j) { 
     this->coef[i + j] += p1.coef[i] * cp[j]; // <-- Well, you changed them here mate 
     cout << cp[j] << endl; // "When I print the values here, they've changed!" 
    } 
} 

От того, как вы прокомментировали coef «S заявление:

int *coef;  // array with polynomial coefficients 

это, кажется, как вы думаете coef массив; это не. Вам также кажется, что назначение coef другому int* скопирует базовые данные, на которые он указывает; Я не буду.

coef является указателем, и присвоение его другому указателю просто копирует указатель.

Попробуйте использовать std::vector, как и все остальные, чтобы вам было обеспечено владение данными и срок службы и чтобы вы могли использовать основные операции присваивания.