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:
- Create a copy operator which takes a const argument
- 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;
}
};
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: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 beconst
and return a copy (ideally you should return aconst
reference, but sincefloat
s are primitive types, just return by value).This is quite normal -- you make an operator which provides both at regular value by reference as well as a const value by reference;
This pattern works for both atomic types such as float,int, etc.., as well as more complex struct and class types.