class copy assignment operator c

Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
OverflowAI GenAI features for Teams
OverflowAPI Train & fine-tune LLMs
Labs The future of collective knowledge sharing
About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Class Assignment Operators

I made the following operator overloading test:

The assignment operator behaves as-expected, outputting the address of the other instance.

Now, how would I actually assign something from the other instance? For example, something like this:

operator-overloading
assignment-operator

You don't need either, but it still looks odd that you have an assignment operator and a destructor, but no copy constructor. As per the Rule of Three, if you need either, you'll likely need all three. – sbi Commented Dec 22, 2010 at 14:54
@sbi Of course. This is just some test code, though. – Maxpm Commented Dec 22, 2010 at 15:24
Still, reflexes kick in when I see that. I also noted that you pass a std::string object per copy instead of const reference. You might want to read this . – sbi Commented Dec 22, 2010 at 15:32

5 Answers 5

The code you've shown would do it. No one would consider it to be a particularly good implementation, though.

This conforms to what is expected of an assignment operator:

BTW, you talk about "other class", but you have only one class, and multiple instances of that class.

Ben, actually it would be better to provide a swap() member function and call that. Nevertheless, this is better than assigning. – sbi Commented Dec 22, 2010 at 14:21

The traditional canonical form of the assignment operator looks like this:

(you don't want to invoke the copy constructor for assignment, too) and it returns a reference to *this .

A naive implementation would assign each data member individually:

(Note that this is exactly what the compiler-generated assignment operator would do, so it's pretty useless to overload it. I take it that this is for exercising, though.)

A better approach would be to employ the Copy-And-Swap idiom . (If you find GMan's answer too overwhelming, try mine , which is less exhaustive. :) ) Note that C&S employs the copy constructor and destructor to do assignment and therefore requires the object to be passed per copy, as you had in your question:

I know you know about copy-and-swap, why did you declare the parameter as a reference? – Ben Voigt Commented Dec 22, 2010 at 13:51
@Ben: Thanks. I've added a note that, using c&s, the object should be copied. Old habits die hard, I guess. (Oh, and I'm not sure what's a "ninja edit", BTW.) – sbi Commented Dec 22, 2010 at 13:56
In this case, it was a ninja edit because you made the changes Ben was suggesting as he was suggesting them. – Bill Commented Dec 22, 2010 at 18:00

almost all said, a few notes:

check for self-assignment, i.e. if (&other != this) // assign
look here for an excellent guide on operator overloading

1 If your assignment operator needs a check for self-assignment, chances are there's a better implementation. Good implementations (like Copy-And-Swap) don't need that test (which puts the burden of checking for the rare case on every assignment). – sbi Commented Dec 22, 2010 at 14:06
2 <shameless_plug> We also have an operator overloading FAQ here on SO now: stackoverflow.com/questions/4421706/operator-overloading . </shameless_plug> – sbi Commented Dec 22, 2010 at 14:06
@sbi: thanks for the ref, I'll read it one day ;). The one I mention is short and easy for beginners, giving just bare essentials. I'll also read up the C&S one day, but as for self-test overhead - seems that C&S has an overhead of copying and in many cases memory allocation (if your class contains strings, vectors etc.), so it should have a "handle with care" label, isn't it? – davka Commented Dec 22, 2010 at 14:21
1 @davka: The one you linked to is questionable, though. Also, C&S has no overhead. I have explained why it doesn't. . In short: assignment is tearing down old state, and building up new state by copying data from another object. That's exactly what copy-constructor and destructor do, and C&S manages to employ them in the right order to be exception-safe. – sbi Commented Dec 22, 2010 at 14:26
1 @davka: When swapping, you allocate for the new data, copy the new data, swap old and new data, and deallocate the old data. When assigning, you deallocate the old data, allocate for the new data, and copy the data (and you pray allocation won't fail and catch you with your pants down). But swapping is supposed to be O(1) and non-throwing, so it doesn't factor into the runtime. (For example, with std::vector swapping will swap two pointers. Comparing to the O(N) of copying and the O(VeryLooong) of allocation, this is neglectable.) – sbi Commented Dec 22, 2010 at 16:30

Traditionnaly the assignment operator and the copy constructor are defined passing a const reference, and not with a copy by value mechanism.

EDIT: I corrected because I had put code that didnt return the TestClass& (c.f. @sbi 's answer)

1 The new common practice actually does pass the RHS by value. It's called the copy-and-swap idiom . – Ben Voigt Commented Dec 22, 2010 at 13:50
And just an instictive automatic repulsion about RHS by value... ( without having looked a single second at the thourough SO subject about copy and swap idiom)... RHS by value while using polymorphism has meant such a hundred of bugs in my career... it will take me hours to be convinced to using RHS by value ;-) – Stephane Rolland Commented Dec 22, 2010 at 14:12

You are correct about how to copy the contents from the other class. Simple objects can just be assigned using operator= .

However, be wary of cases where TestClass contains pointer members -- if you just assign the pointer using operator= , then both objects will have pointers pointing to the same memory, which may not be what you want. You may instead need to make sure you allocate some new memory and copy the pointed-to data into it so both objects have their own copy of the data. Remember you also need to properly deallocate the memory already pointed to by the assigned-to object before allocating a new block for the copied data.

By the way, you should probably declare your operator= like this:

This is the general convention used when overloading operator= . The return statement allows chaining of assignments (like a = b = c ) and passing the parameter by const reference avoids copying Other on its way into the function call.

1 The new common practice actually does pass the RHS by value. It's called the copy-and-swap idiom . – Ben Voigt Commented Dec 22, 2010 at 13:51

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c++ class operators operator-overloading assignment-operator or ask your own question .

The Overflow Blog
Where does Postgres fit in a world of GenAI and vector databases?
Featured on Meta
We've made changes to our Terms of Service & Privacy Policy - July 2024
Bringing clarity to status tag usage on meta sites
What does a new user need in a homepage experience on Stack Overflow?
Feedback requested: How do you use tag hover descriptions for curating and do...
Staging Ground Reviewer Motivation

Hot Network Questions

Are quantum states like the W, Bell, GHZ, and Dicke state actually used in quantum computing research?
Historical U.S. political party "realignments"?
Why does Jesus give an action of Yahweh as an example of evil?
How does the summoned monster know who is my enemy?
How could I contact the Betriebsrat (Workers' Union) of my employer behind his back?
Planning to rebuild detached storage room (in the US)
Why is "on " the optimal preposition in this case?
Which hash algorithms support binary input of arbitrary bit length?
A very interesting food chain
I overstayed 90 days in Switzerland. I have EU residency and never got any stamps in passport. Can I exit/enter at airport without trouble?
Expected number of numbers that stay at their place after k swaps
How much missing data is too much (part 2)? statistical power, effective sample size
Is it possible to calculate FPS (frames per second) of video using statistical data?
Is it possible to have a planet that's gaslike in some areas and rocky in others?
Is there a phrase for someone who's really bad at cooking?
What are the 270 mitzvot relevant today?
Searching for an illustrated children's book with anthropomorphic animals, a sled, and a train
What unique phenomena would be observed in a system around a hypervelocity star?
Why does flow separation cause an increase in pressure drag?
How can moral disagreements be resolved when the conflicting parties are guided by fundamentally different value systems?
Using "no" at the end of a statement instead of "isn't it"?
Encode a VarInt
How can I prove the existence of multiplicative inverses for the complex number system
about flag changes in 16-bit calculations on the MC6800

C Data Types
C Operators
C Input and Output
C Control Flow
C Functions
C Preprocessors
C File Handling
C Cheatsheet
C Interview Questions

Assignment Operators in C

Assignment operators are used for assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of the variable on the left side otherwise the compiler will raise an error.

Different types of assignment operators are shown below:

1. “=”: This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left. Example:

2. “+=” : This operator is combination of ‘+’ and ‘=’ operators. This operator first adds the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a += 6) = 11.

3. “-=” This operator is combination of ‘-‘ and ‘=’ operators. This operator first subtracts the value on the right from the current value of the variable on left and then assigns the result to the variable on the left. Example:

If initially value stored in a is 8. Then (a -= 6) = 2.

4. “*=” This operator is combination of ‘*’ and ‘=’ operators. This operator first multiplies the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a *= 6) = 30.

5. “/=” This operator is combination of ‘/’ and ‘=’ operators. This operator first divides the current value of the variable on left by the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 6. Then (a /= 2) = 3.

Below example illustrates the various Assignment Operators:

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

Copy constructors and copy assignment operators (C++)

8 contributors

Starting in C++11, two kinds of assignment are supported in the language: copy assignment and move assignment . In this article "assignment" means copy assignment unless explicitly stated otherwise. For information about move assignment, see Move Constructors and Move Assignment Operators (C++) .

Both the assignment operation and the initialization operation cause objects to be copied.

Assignment : When one object's value is assigned to another object, the first object is copied to the second object. So, this code copies the value of b into a :

Initialization : Initialization occurs when you declare a new object, when you pass function arguments by value, or when you return by value from a function.

You can define the semantics of "copy" for objects of class type. For example, consider this code:

The preceding code could mean "copy the contents of FILE1.DAT to FILE2.DAT" or it could mean "ignore FILE2.DAT and make b a second handle to FILE1.DAT." You must attach appropriate copying semantics to each class, as follows:

Use an assignment operator operator= that returns a reference to the class type and takes one parameter that's passed by const reference—for example ClassName& operator=(const ClassName& x); .

Use the copy constructor.

If you don't declare a copy constructor, the compiler generates a member-wise copy constructor for you. Similarly, if you don't declare a copy assignment operator, the compiler generates a member-wise copy assignment operator for you. Declaring a copy constructor doesn't suppress the compiler-generated copy assignment operator, and vice-versa. If you implement either one, we recommend that you implement the other one, too. When you implement both, the meaning of the code is clear.

The copy constructor takes an argument of type ClassName& , where ClassName is the name of the class. For example:

Make the type of the copy constructor's argument const ClassName& whenever possible. This prevents the copy constructor from accidentally changing the copied object. It also lets you copy from const objects.

Compiler generated copy constructors

Compiler-generated copy constructors, like user-defined copy constructors, have a single argument of type "reference to class-name ." An exception is when all base classes and member classes have copy constructors declared as taking a single argument of type const class-name & . In such a case, the compiler-generated copy constructor's argument is also const .

When the argument type to the copy constructor isn't const , initialization by copying a const object generates an error. The reverse isn't true: If the argument is const , you can initialize by copying an object that's not const .

Compiler-generated assignment operators follow the same pattern for const . They take a single argument of type ClassName& unless the assignment operators in all base and member classes take arguments of type const ClassName& . In this case, the generated assignment operator for the class takes a const argument.

When virtual base classes are initialized by copy constructors, whether compiler-generated or user-defined, they're initialized only once: at the point when they are constructed.

The implications are similar to the copy constructor. When the argument type isn't const , assignment from a const object generates an error. The reverse isn't true: If a const value is assigned to a value that's not const , the assignment succeeds.

For more information about overloaded assignment operators, see Assignment .

Was this page helpful?

Additional resources

Copy assignment operator












(C++11)
(C++11)
(C++11)

General topics

statement

loop
loop (C++11)

loop
loop

statement
statement


(C++11)

Literals


(C++11)
(C++11)

expression


pointer

(C++11)



(C++11)


(C++11)

A copy assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T , T & , const T & , volatile T & , or const volatile T & . A type with a public copy assignment operator is CopyAssignable .

Syntax Explanation Implicitly-declared copy assignment operator Deleted implicitly-declared copy assignment operator Trivial copy assignment operator Implicitly-defined copy assignment operator Notes Copy and swap Example

[ edit ] Syntax


class_name class_name ( class_name )	(1)	(since C++11)

class_name class_name ( const class_name )	(2)	(since C++11)

class_name class_name ( const class_name ) = default;	(3)	(since C++11)

class_name class_name ( const class_name ) = delete;	(4)	(since C++11)

[ edit ] Explanation

Typical declaration of a copy assignment operator when copy-and-swap idiom can be used
Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used
Forcing a copy assignment operator to be generated by the compiler
Avoiding implicit copy assignment

The copy assignment operator is called whenever selected by overload resolution , e.g. when an object appears on the left side of an assignment expression.

[ edit ] Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type ( struct , class , or union ), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T & T :: operator = ( const T & ) if all of the following is true:

each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B &
each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M &

Otherwise the implicitly-declared copy assignment operator is declared as T & T :: operator = ( T & ) . (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument)

A class can have multiple copy assignment operators, e.g. both T & T :: operator = ( const T & ) and T & T :: operator = ( T ) . If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword default .

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

[ edit ] Deleted implicitly-declared copy assignment operator

The implicitly-declared or defaulted copy assignment operator for class T is defined as deleted in any of the following is true:

T has a non-static data member that is const
T has a non-static data member of a reference type.
T has a non-static data member that cannot be copy-assigned (has deleted, inaccessible, or ambiguous copy assignment operator)
T has direct or virtual base class that cannot be copy-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
T has a user-declared move constructor
T has a user-declared move assignment operator

[ edit ] Trivial copy assignment operator

The implicitly-declared copy assignment operator for class T is trivial if all of the following is true:

T has no virtual member functions
T has no virtual base classes
The copy assignment operator selected for every direct base of T is trivial
The copy assignment operator selected for every non-static class type (or array of class type) memeber of T is trivial

A trivial copy assignment operator makes a copy of the object representation as if by std:: memmove . All data types compatible with the C language (POD types) are trivially copy-assignable.

[ edit ] Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined copy assignment copies the object representation (as by std:: memmove ). For non-union class types ( class and struct ), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated (since C++11) if T has a user-declared destructor or user-declared copy constructor.

[ edit ] Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std:: move ), and selects the copy assignment if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

[ edit ] Copy and swap

Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:

T & T :: operator = ( T arg ) { // copy/move constructor is called to construct arg swap ( arg ) ; // resources exchanged between *this and arg return * this ; } // destructor is called to release the resources formerly held by *this

[ edit ] Example

cppreference.com

Copy assignment operator












(C++11)
(C++11)
(C++11)

General



Members


pointer







(C++11)
specifier
specifier

Special member functions


(C++11)

(C++11)

Inheritance


(C++11)
(C++11)

A copy assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T , T & , const T & , volatile T & , or const volatile T & . For a type to be CopyAssignable , it must have a public copy assignment operator.

[ edit ] Syntax


class_name class_name ( class_name )	(1)

class_name class_name ( const class_name )	(2)

class_name class_name ( const class_name ) = default;	(3)	(since C++11)

class_name class_name ( const class_name ) = delete;	(4)	(since C++11)

[ edit ] Explanation

Typical declaration of a copy assignment operator when copy-and-swap idiom can be used
Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used (non-swappable type or degraded performance)
Forcing a copy assignment operator to be generated by the compiler
Avoiding implicit copy assignment

The copy assignment operator is called whenever selected by overload resolution , e.g. when an object appears on the left side of an assignment expression.

[ edit ] Implicitly-declared copy assignment operator

each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B &
each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M &

[ edit ] Deleted implicitly-declared copy assignment operator

A implicitly-declared copy assignment operator for class T is defined as deleted if any of the following is true:

T has a user-declared move constructor
T has a user-declared move assignment operator

Otherwise, it is defined as defaulted.

A defaulted copy assignment operator for class T is defined as deleted if any of the following is true:

T has a non-static data member of non-class type (or array thereof) that is const
T has a non-static data member of a reference type.
T has a non-static data member or a direct or virtual base class that cannot be copy-assigned (overload resolution for the copy assignment fails, or selects a deleted or inaccessible function)
T is a union-like class , and has a variant member whose corresponding assignment operator is non-trivial.

[ edit ] Trivial copy assignment operator

The copy assignment operator for class T is trivial if all of the following is true:

It is not user-provided (meaning, it is implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined
T has no virtual member functions
T has no virtual base classes
The copy assignment operator selected for every direct base of T is trivial
The copy assignment operator selected for every non-static class type (or array of class type) member of T is trivial

has no non-static data members of -qualified type

(since C++14)

A trivial copy assignment operator makes a copy of the object representation as if by std::memmove . All data types compatible with the C language (POD types) are trivially copy-assignable.

[ edit ] Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used . For union types, the implicitly-defined copy assignment copies the object representation (as by std::memmove ). For non-union class types ( class and struct ), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated (since C++11) if T has a user-declared destructor or user-declared copy constructor.

[ edit ] Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std::move ), and selects the copy assignment if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

It is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined copy assignment operator (same applies to move assignment ).

[ edit ] Copy and swap

Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:

For non-throwing swap(), this form provides strong exception guarantee . For rvalue arguments, this form automatically invokes the move constructor, and is sometimes referred to as "unifying assignment operator" (as in, both copy and move). However, this approach is not always advisable due to potentially significant overhead: see assignment operator overloading for details.

[ edit ] Example

Recent changes
Offline version
What links here
Related changes
Upload file
Special pages
Printable version
Permanent link
Page information
In other languages
This page was last modified on 30 November 2015, at 07:24.
This page has been accessed 110,155 times.
Privacy policy
About cppreference.com
Disclaimers

Graphics and multimedia
Language Features
Unix/Linux programming
Source Code
Standard Library
Tips and Tricks
Tools and Libraries
Windows API
Copy constructors, assignment operators,

Copy constructors, assignment operators, and exception safe assignment

MyClass& other ); MyClass( MyClass& other ); MyClass( MyClass& other ); MyClass( MyClass& other );

MyClass* other );

MyClass { x; c; std::string s; };

MyClass& other ) : x( other.x ), c( other.c ), s( other.s ) {}

);

print_me_bad( std::string& s ) { std::cout << s << std::endl; } print_me_good( std::string& s ) { std::cout << s << std::endl; } std::string hello( ); print_me_bad( hello ); print_me_bad( std::string( ) ); print_me_bad( ); print_me_good( hello ); print_me_good( std::string( ) ); print_me_good( );

, );

=( MyClass& other ) { x = other.x; c = other.c; s = other.s; * ; }

< T > MyArray { size_t numElements; T* pElements; : size_t count() { numElements; } MyArray& =( MyArray& rhs ); };

<> MyArray<T>:: =( MyArray& rhs ) { ( != &rhs ) { [] pElements; pElements = T[ rhs.numElements ]; ( size_t i = 0; i < rhs.numElements; ++i ) pElements[ i ] = rhs.pElements[ i ]; numElements = rhs.numElements; } * ; }

<> MyArray<T>:: =( MyArray& rhs ) { MyArray tmp( rhs ); std::swap( numElements, tmp.numElements ); std::swap( pElements, tmp.pElements ); * ; }

< T > swap( T& one, T& two ) { T tmp( one ); one = two; two = tmp; }

<> MyArray<T>:: =( MyArray tmp ) { std::swap( numElements, tmp.numElements ); std::swap( pElements, tmp.pElements ); * ; }

21.12 — Overloading the assignment operator

IMAGES

What is assignment operator in C with example?
Assignment Operator in C
Assignment Operators in C/C++
C programming +=
Assignment Operators in C++
Difference between copy constructor and assignment operator in c++

VIDEO

Assignment Operator in C Programming
Augmented assignment operators in C
Assignment Operator in C Programming
Assignment Operator│C programming│Part# 15│Learn CSE Malayalam
Assignment Operator Overloading In C++
#7 Operators and its Types in C Language (Part 1) with Notes

COMMENTS

Copy assignment operator - cppreference.com
A copy assignment operator is a non-template non-static member function with the name operator= that can be called with an argument of the same class type and copies the content of the argument without mutating the argument. Syntax. For the formal copy assignment operator syntax, see function declaration.
c++ - Class Assignment Operators - Stack Overflow
The traditional canonical form of the assignment operator looks like this: TestClass& operator=(const TestClass& Other); (you don't want to invoke the copy constructor for assignment, too) and it returns a reference to *this. A naive implementation would assign each data member individually:
Copy Constructor vs Assignment Operator in C++ - GeeksforGeeks
C++ compiler implicitly provides a copy constructor, if no copy constructor is defined in the class. A bitwise copy gets created, if the Assignment operator is not overloaded. Syntax: className (const className &obj) {. // body. } Syntax: className obj1, obj2; obj2 = obj1;
Assignment Operators in C - GeeksforGeeks
If a class doesn't contain pointers, then there is no need to write assignment operator and copy constructor. The compiler creates a default copy constructor and assignment operators for every class. The compiler created copy constructor and assignment operator may not be sufficient when we have pointers or a
Copy constructors and copy assignment operators (C++ ...
Use an assignment operator operator= that returns a reference to the class type and takes one parameter that's passed by const reference—for example ClassName& operator=(const ClassName& x);. Use the copy constructor.
Copy assignment operator - cppreference.com
Copy assignment operator. A copy assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T, T&, const T&, volatile T&, or const volatile T&. A type with a public copy assignment operator is CopyAssignable .
Copy Constructors and Assignment Operators - Stanford University
C++ handles object copying and assignment through two functions called copy constructors and assignment operators. While C++ will automatically provide these functions if you don't explicitly define them, in many cases you'll need to manually control how your objects are duplicated.
Copy assignment operator - cppreference.com
A copy assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T, T&, const T&, volatile T&, or const volatile T&. For a type to be CopyAssignable, it must have a public copy assignment operator. Syntax. Explanation.
Copy constructors, assignment operators, - C++ Articles">Copy constructors, assignment operators, - C++ Articles
What is a copy constructor? A copy constructor is a special constructor for a class/struct that is used to make a copy of an existing instance. According to the C++ standard, the copy constructor for MyClass must have one of the following signatures:
Overloading the assignment operator – Learn C++">21.12 — Overloading the assignment operator – Learn C++
The copy assignment operator (operator=) is used to copy values from one object to another already existing object. As of C++11, C++ also supports “Move assignment”. We discuss move assignment in lesson 22.3 -- Move constructors and move assignment .