Re: overloading +, * and = for complex objects
silversurfer2025 wrote:
I tried adding const to the copy-constructor, but it does not work
either (although there is another error message now:
myVector.cpp: In copy constructor `myVector::myVector(const
myVector&)':
myVector.cpp:34: error: passing `const myVector' as `this' argument of
`int myVector::size()' discards qualifiers
I guess this is because I am using an instance-method of the
to-be-copied-object in the copy constructor...
Well, not exactly. It's because you're using a non-const member function on
a const object. You have to look up how to do const correct programming.
size() probably doesn't change the object, but unless you make it const,
the compiler doesn't know that, and so it assumes you are trying to modify
a constant object, which is of course not allowed. Try to declare your
size() function like:
class myVector
{
public:
int size() const;
};
This tells the compiler that size() doesn't change the object.
Probably you are trying to copy a constant object, but by your
declaration, you told the compiler that the original object gets modified
by your copy constructor.
It is true that I would like change the original object by this method.
Are you really sure about this? A copy constructor should usually not modify
the original object. Only in very rare cases, it's ok. Why do you think you
need it?
But this should be no mistake as such shouldn't it?
Well, it is possible, if you can live with the consequences, like that you
can't copy constant objects or temporaries, and that you can't use your
class with any standard container.
Strings can do exactly the same.
Well, they could, but they don't.
Thus, what I need should also be implemented in the std::string class
because you can say:
string s1("ladida");
string s2("testing"); and then
s1 = s1 + s2;
In this code, there is no need for a copy constructor to modify the original
object. I guess you are referring to the third line.
s1 = s1 + s2;
What happens here that s1.operator+(s2) is called. That one returns a new
string that contains the result of the concatenation. That string is then
copied on return into a temporary, which is then copied using operator=
into s1. Btw: it would be better to use += here, which does modify its left
hand operand instead of returning a new object.