复制构造函数的问题

Question

Dont pay attention to the actual code, just read the question. I have a function that takes 2 parameters of type Polynomial:

FiniteFieldElement(int l, Polynomial p, Polynomial irr)
{
    this->l = l;
    this->p = p;
    this->irr = irr;
}

My understanding is that Polynomial's copy constructor will be called when p and irr are being passed.

The copy constructor is working properly, as I can verify by a breakpoint at the end.

Polynomial(const Polynomial& p)
{
    degree = p.degree;
    modulo = p.modulo;
    if (polynomial != p.polynomial)
    {
        polynomial = new int[degree + 1];
        for (int i = 0; i <= degree; i++)
        {
            polynomial[i] = p.polynomial[i];
        }
    }
}

But why am I getting wrong (uninitialized) values for the actual parameters p and irr. What could be coming in between the result of the copy constructor and the actual parameters? If I change the parameter to a reference parameter, it works fine. (Note: Polynomial has no destructor, if that helps).

EDIT: If I declare a polynomial using the copy constructor Polynomial p1(p2) , p1 gets initialized correctly. In the class FiniteFieldElement, I'm getting wrong Polynomial parameters. I'm completely stumped.

Answer 1

My understanding is that Polynomial's copy constructor will be called when p and irr are being passed.

That only partially correct. A copy is possibly made since the Polinomials are passed by value (but copy elision could mean no copy is made at all), but inside FiniteFieldElement(int l, Polynomial p, Polynomial irr) , Polynomial 's copy assignment operator will be called, assuming this->p and this->irr are of type Polynomial . So your class' fields are the result of an assignment, not a copy.

So you should be looking at the implementation of your copy assignment operator.

Answer 2

Are you actually initializing the polynomial? Doing new int[degree_ + 1]; will not construct an initialized array, its values are garbage.

Edit : Unless there is another very good reason why you need a int* you are better off using a std::vector as your polynomial coefficients container. It will simplify object construction, destruction and assignment.

This works well (which means the problem is in the part of the code which you are not showing us: the class defintions and assignment operators)

class Polynomial
{
public:

    Polynomial();
    Polynomial( const Polynomial& p );
    template <int N> Polynomial(int (&Poly)[N] );

    Polynomial& operator=( const Polynomial& Rhs);

    void Print();

    ~Polynomial();
private:
    int* poly_;
    int degree_;
};

class FiniteFieldElement
{
public:
    FiniteFieldElement( Polynomial P );

    void Print();
private:
    Polynomial p_;
};

and the implementations:

Polynomial::Polynomial()
{
    degree_ = 0;
    poly_ = new int[degree_ + 1];

    poly_[0] = 1;
}

// excessive, you don't really need this
template <int N> Polynomial::Polynomial(int (&Poly)[N] )
{
    degree_ = N - 1;
    poly_ = new int[degree_ + 1];

    for (int i = 0; i <= degree_; i++)
    {
        poly_[i] = Poly[i];
    }
}

Polynomial& Polynomial::operator=( const Polynomial& Rhs)
{        
    if ( this != &Rhs )
    {
        degree_= Rhs.degree_;

        delete[] poly_;

        poly_ = new int[degree_ + 1];

        for (int i = 0; i <= degree_; i++)
        {
            poly_[i] = Rhs.poly_[i];
        }
    }

    return *this;
}


void Polynomial::Print()
{
    std::cout<< "Degree = " << degree_ << "\n Polynomial = ";
    for (int i = 0; i <= degree_; i++)
    {
        std::cout<< poly_[i] << " ";
    }
    std::cout<<"\n";
}

Polynomial::~Polynomial()
{
    delete[] poly_;
}

Polynomial::Polynomial(const Polynomial& p)
{
    degree_ = p.degree_;
    poly_ = new int[degree_ + 1];

    for (int i = 0; i <= degree_; i++)
    {
        poly_[i] = p.poly_[i];
    }
}

and

FiniteFieldElement::FiniteFieldElement( Polynomial P )
{
    p_ = P;
}

void FiniteFieldElement::Print()
{
    p_.Print();
}

main is just:

int main(int argc, _TCHAR* argv[])
{
    int myPoly[] = { 1, 2, 3 };

    Polynomial foo(myPoly);

    FiniteFieldElement bar( foo );

    std::cout<< "Foo:\n";
    foo.Print();
    std::cout<< "Bar:\n";
    bar.Print();

    return 0;
}

If it works on your machine see how it differs from your implementation, both in code and in behavior.

Answer 3

Thanks to everyone it turns out the Eclipse CDT debugger was giving me wrong values. The same breakpoint in Visual studio (or just printing the values [see modulo below]) gives me the correct answers. Maybe I'm not using it correctly, but when you enter a watch expression in the debugger you expect to get the right value.