Why is the assignment operator implicitly defined?

Default Constructor, Copy Constructor and Destructor are very important and I understand why C++ implicitly defined them. Just think about function arguments that should be copied, local variables that should be destructed and objects that should be construct-able even if you don't say how to construct.

But why do we need the copy assignment operator implicitly defined? Is it really a must to be able to do a = b? It is not game changing, right? Any strong reason I don't know?

... why do we need the copy assignment operator?

Simply, to support assignment semantics. These are not the same as copy construction semantics.

Foo f1;
Foo f2(f1); // copy...
Foo f3;
f3 = f1; // assignment...

They are similar, and often implemented in terms of one another, but not the same.

Why would they all be implicitly defined?

To support and mimic the C-style value semantics. So that user defined types can support the same semantics as the built in types.

Side note; IIRC, there has been some deprecation of rules here with the onset of move semantics...

Why did the assignment operator's absence allow me to modify a Ruby constant without warning the compiler?

In the following two examples I do the same thing, creating a constant String and using the concat method to modify it. Because it's a constant, I expect a compiler warning but only receive one in the second example when I use the assignment operator

Why does the assignment operator need to return a const reference / reference?

In C++, the concept of returning reference from the copy assignment operator is unclear to me. Why can't the copy assignment operator return a copy of the new object? In addition, if I have class A, and the following: A a1(param); A a2 = a1; A a3; a3

Why does the assignment operator return something to start?

I know that the "+" operator has to return something, and that makes sense to me. But what I don't understand is why we return an object when overloading the "=" operator. For example look at the following: const Scene& Scene::oper

Why is the copy constructor used instead of the assignment operator

This is how MyClass is defined: class MyClass { double x, y; public: MyClass (double a = 0., double b = 0.) { x = a; y = b; cout << "Using the default constructor" << endl; } MyClass (const MyClass& p) { x = p.x; y = p.y; cout &l

Why do we use the reference return in the overhead of the assignment operator and not the plus-minus operations?

As I read in books and in the web, in C++ we can overload the "plus" or "minus" operators with these prototypes (as member functions of a class Money): const Money operator +(const Money& m2) const; const Money operator -(const Mon

Why can not a non-member function be used for overloading the assignment operator?

The assignment operator can be overloaded using a member function but not a non-member friend function: class Test { int a; public: Test(int x) :a(x) {} friend Test& operator=(Test &obj1, Test &obj2); }; Test& operator=(Test &obj1, Tes

Why does the expression remove_if (& hellip ;, lambda) require the assignment operator?

I have this code (simplified) : std::vector<Session> sessions; // ... std::remove_if( sessions.begin(), sessions.end(), [] (const Session& s) { return false; } ); When I compile it (in Visual Studio 2013 Update 1) I get the following error: algo

Why does RVO not reach the assignment operator? (C ++)

Example: A myfunction() { return A(); } A a = myfunction(); // default ctor only (return value optimization) a = myfunction(); // default ctor and operator= Why can't the compiler just write the new object into the existing object? I believe all inst

Define an object equal to another object with the assignment operator in Javascript

I'm coming to javascript from C background. In javascript, when I use the assignment operator to assign one object to another, does it copy the values from one to the another, or do they both now point to the same data?. Or does the assignment operat

Why the memory leak occurs only in case of overload of the assignment operator, but not in the copy constructor and how the resolution and exchange of idioms resolve it

P.S: I am new to programming so please answer my doubts in simpler terms. I have found a couple of answers but could not understand them. Below is the copy constructor and assignment operator overload. template <class T> Mystack<T>::Mystack(co

Related Articles