Question

I am trying to solve my question regarding using push_back in more than one level. From the comments/answers it is clear that I have to:

1. Create a copy operator which takes a const argument
2. Modify all my operators to const

But because this header file is given to me there is an operator what I cannot make into const. It is a simple:

float & operator [] (int i) {
    return _item[i];
}

In the given program, this operator is used to get and set data.

My problem is that because I need to have this operator in the header file, I cannot turn all the other operators to const, what means I cannot insert a copy operator.

How can I make all my operators into const, while preserving the functionality of the already written program?

Here is the full declaration of the class:

class Vector3f {

    float _item[3];

    public:

    float & operator [] (int i) {
        return _item[i];
        }

    Vector3f(float x, float y, float z) 
    {  _item[0] = x ; _item[1] = y ; _item[2] = z; };

    Vector3f() {};

    Vector3f & operator = ( const Vector3f& obj) 
    {
        _item[0] = obj[0];
        _item[1] = obj[1];
        _item[2] = obj[2];

        return *this;
    };

    Vector3f & operator += ( const Vector3f & obj) 
    {
        _item[0] += obj[0];
        _item[1] += obj[1];
        _item[2] += obj[2];

        return *this;
    };

    bool operator ==( const Vector3f & obj) {
        bool x = (_item[0] == obj[0]) && (_item[1] == obj[1]) && (_item[2] == obj[2]);
        return x;
    }


    // my copy operator
    Vector3f(const Vector3f& obj) {
        _item[0] += obj[0];
        _item[1] += obj[1];
        _item[2] += obj[2];

        return this;
    }

};

Answer 1

I did not really understand what you’re trying to do, but I noticed that this code can’t possibly compile. The reason is that copy is handled by a copy constructor, not operator. Which means that, like any constructor, it doesn’t return anything. Remove the return statement from your constructor, like so:

Vector3f(const Vector3f& obj) {
    _item[0] += obj[0];
    _item[1] += obj[1];
    _item[2] += obj[2];
}

As for making your operator const, you can simply overload it and offer two versions of the same method. The first one will be non-const and will return a reference (allowing modifications), while the second will be const and return a copy (ideally you should return a const reference, but since floats are primitive types, just return by value).

float & operator [] (int i) 
{
    return _item[i];
}
float operator [] (int i) const 
{
    return _item[i];
}