assignment constructor c example

• 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

Learn C++ practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c++ interactively, introduction to c++.

• Getting Started With C++
• Your First C++ Program
• C++ Comments

C++ Fundamentals

• C++ Keywords and Identifiers
• C++ Variables, Literals and Constants
• C++ Data Types
• C++ Type Modifiers
• C++ Constants
• C++ Basic Input/Output
• C++ Operators

Flow Control

• C++ Relational and Logical Operators
• C++ if, if...else and Nested if...else
• C++ for Loop
• C++ while and do...while Loop
• C++ break Statement
• C++ continue Statement
• C++ goto Statement
• C++ switch..case Statement
• C++ Ternary Operator
• C++ Functions
• C++ Programming Default Arguments
• C++ Function Overloading
• C++ Inline Functions
• C++ Recursion

Arrays and Strings

• C++ Array to Function
• C++ Multidimensional Arrays
• C++ String Class

Pointers and References

• C++ Pointers
• C++ Pointers and Arrays
• C++ References: Using Pointers
• C++ Call by Reference: Using pointers
• C++ Memory Management: new and delete

Structures and Enumerations

• C++ Structures
• C++ Structure and Function
• C++ Pointers to Structure
• C++ Enumeration

Object Oriented Programming

C++ Classes and Objects

C++ Constructors

C++ Constructor Overloading

C++ Destructors

• C++ Access Modifiers
• C++ Encapsulation
• C++ friend Function and friend Classes

Inheritance & Polymorphism

• C++ Inheritance
• C++ Public, Protected and Private Inheritance
• C++ Multiple, Multilevel and Hierarchical Inheritance
• C++ Function Overriding
• C++ Virtual Functions
• C++ Abstract Class and Pure Virtual Function

STL - Vector, Queue & Stack

• C++ Standard Template Library
• C++ STL Containers
• C++ std::array
• C++ Vectors
• C++ Forward List
• C++ Priority Queue

STL - Map & Set

• C++ Multimap
• C++ Multiset
• C++ Unordered Map
• C++ Unordered Set
• C++ Unordered Multiset
• C++ Unordered Multimap

STL - Iterators & Algorithms

• C++ Iterators
• C++ Algorithm
• C++ Functor

Additional Topics

• C++ Exceptions Handling
• C++ File Handling
• C++ Ranged for Loop
• C++ Nested Loop
• C++ Function Template

C++ Class Templates

• C++ Type Conversion
• C++ Type Conversion Operators
• C++ Operator Overloading

Advanced Topics

• C++ Namespaces
• C++ Preprocessors and Macros
• C++ Storage Class
• C++ Bitwise Operators
• C++ Buffers
• C++ istream
• C++ ostream

C++ Tutorials

• C++ clock()
• How to pass and return object from C++ Functions?

A constructor is a special member function that is called automatically when an object is created.

In C++, a constructor has the same name as that of the class , and it does not have a return type. For example,

Here, the function Wall() is a constructor of the class Wall . Notice that the constructor

• has the same name as the class,
• does not have a return type, and
• C++ Default Constructor

A constructor with no parameters is known as a default constructor . For example,

Here, when the wall1 object is created, the Wall() constructor is called. length{5.5} is invoked when the constructor is called, and sets the length variable of the object to 5.5 .

Note: If we have not defined any constructor, copy constructor, or move constructor in our class, then the C++ compiler will automatically create a default constructor with no parameters and empty body.

Defaulted Constructor

When we have to rely on default constructor to initialize the member variables of a class, we should explicitly mark the constructor as default in the following way:

If we want to set a default value, then we should use value initialization. That is, we include the default value inside braces in the declaration of member variables in the follwing way.

Let's see an example:

• C++ Parameterized Constructor

In C++, a constructor with parameters is known as a parameterized constructor. This is the preferred method to initialize member data. For example,

Here, we have defined a parameterized constructor Wall() that has two parameters: double len and double hgt . The values contained in these parameters are used to initialize the member variables length and height .

: length{len}, height{hgt} is the member initializer list.

• length{len} initializes the member variable length with the value of the parameter len
• height{hgt} initializes the member variable height with the value of the parameter hgt .

When we create an object of the Wall class, we pass the values for the member variables as arguments. The code for this is:

With the member variables thus initialized, we can now calculate the area of the wall with the calculateArea() method.

Note : A constructor is primarily used to initialize objects. They are also used to run a default code when an object is created.

• C++ Member Initializer List

Consider the constructor:

is member initializer list.

The member initializer list is used to initialize the member variables of a class.

The order or initialization of the member variables is according to the order of their declaration in the class rather than their declaration in the member initializer list.

Since the member variables are declared in the class in the following order:

The length variable will be initialized first even if we define our constructor as following:

• C++ Copy Constructor

The copy constructor in C++ is used to copy data from one object to another. For example,

In this program, we have used a copy constructor to copy the contents of one object of the Wall class to another. The code of the copy constructor is:

Notice that the parameter of this constructor has the address of an object of the Wall class.

We then assign the values of the variables of the obj object to the corresponding variables of the object, calling the copy constructor. This is how the contents of the object are copied.

In main() , we then create two objects wall1 and wall2 and then copy the contents of wall1 to wall2 :

Here, the wall2 object calls its copy constructor by passing the reference of the wall1 object as its argument.

• C++ Default Copy Constructor

If we don't define any copy constructor, move constructor, or move assignment in our class, then the C++ compiler will automatically create a default copy constructor that does memberwise copy assignment. It suffices in most cases. For example,

In this program, we have not defined a copy constructor. The compiler used the default copy constructor to copy the contents of one object of the Wall class to another.

• C++ Friend Function and Classes

Table of Contents

• Introduction

Sorry about that.

Related Tutorials

C++ Tutorial

This browser is no longer supported.

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

Move Constructors and Move Assignment Operators (C++)

• 9 contributors

This topic describes how to write a move constructor and a move assignment operator for a C++ class. A move constructor enables the resources owned by an rvalue object to be moved into an lvalue without copying. For more information about move semantics, see Rvalue Reference Declarator: && .

This topic builds upon the following C++ class, MemoryBlock , which manages a memory buffer.

The following procedures describe how to write a move constructor and a move assignment operator for the example C++ class.

To create a move constructor for a C++ class

Define an empty constructor method that takes an rvalue reference to the class type as its parameter, as demonstrated in the following example:

In the move constructor, assign the class data members from the source object to the object that is being constructed:

Assign the data members of the source object to default values. This prevents the destructor from freeing resources (such as memory) multiple times:

To create a move assignment operator for a C++ class

Define an empty assignment operator that takes an rvalue reference to the class type as its parameter and returns a reference to the class type, as demonstrated in the following example:

In the move assignment operator, add a conditional statement that performs no operation if you try to assign the object to itself.

In the conditional statement, free any resources (such as memory) from the object that is being assigned to.

The following example frees the _data member from the object that is being assigned to:

Follow steps 2 and 3 in the first procedure to transfer the data members from the source object to the object that is being constructed:

Return a reference to the current object, as shown in the following example:

Example: Complete move constructor and assignment operator

The following example shows the complete move constructor and move assignment operator for the MemoryBlock class:

Example Use move semantics to improve performance

The following example shows how move semantics can improve the performance of your applications. The example adds two elements to a vector object and then inserts a new element between the two existing elements. The vector class uses move semantics to perform the insertion operation efficiently by moving the elements of the vector instead of copying them.

This example produces the following output:

Before Visual Studio 2010, this example produced the following output:

The version of this example that uses move semantics is more efficient than the version that does not use move semantics because it performs fewer copy, memory allocation, and memory deallocation operations.

Robust Programming

To prevent resource leaks, always free resources (such as memory, file handles, and sockets) in the move assignment operator.

To prevent the unrecoverable destruction of resources, properly handle self-assignment in the move assignment operator.

If you provide both a move constructor and a move assignment operator for your class, you can eliminate redundant code by writing the move constructor to call the move assignment operator. The following example shows a revised version of the move constructor that calls the move assignment operator:

The std::move function converts the lvalue other to an rvalue.

Rvalue Reference Declarator: && std::move

Was this page helpful?

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback .

Submit and view feedback for

Additional resources

• Getting started with C++
• Awesome Book
• Awesome Community
• Awesome Course
• Awesome Tutorial
• Awesome YouTube
• Argument Dependent Name Lookup
• Arithmitic Metaprogramming
• Atomic Types
• Basic input/output in c++
• Basic Type Keywords
• Bit Manipulation
• Bit Operators
• Build Systems
• C incompatibilities
• C++ Containers
• C++ Debugging and Debug-prevention Tools & Techniques
• C++ function "call by value" vs. "call by reference"
• C++ Streams
• C++11 Memory Model
• Callable Objects
• Classes/Structures
• Client server examples
• Common compile/linker errors (GCC)
• Compiling and Building
• Concurrency With OpenMP
• Const Correctness
• const keyword
• Constant class member functions
• Copy Elision
• Copying vs Assignment
• Assignment Operator
• Copy Constructor
• Copy Constructor Vs Assignment Constructor
• Curiously Recurring Template Pattern (CRTP)
• Data Structures in C++
• Date and time using header
• Design pattern implementation in C++
• Digit separators
• Enumeration
• Explicit type conversions
• Expression templates
• Floating Point Arithmetic
• Flow Control
• Fold Expressions
• Friend keyword
• Function Overloading
• Function Template Overloading
• Futures and Promises
• Header Files
• Implementation-defined behavior
• Inline functions
• Inline variables
• Internationalization in C++
• Layout of object types
• Linkage specifications
• Memory management
• Metaprogramming
• More undefined behaviors in C++
• Move Semantics
• mutable keyword
• Non-Static Member Functions
• One Definition Rule (ODR)
• Operator Overloading
• operator precedence
• Optimization
• Optimization in C++
• Overload resolution
• Parameter packs
• Perfect Forwarding
• Pimpl Idiom
• Pointers to members
• Polymorphism
• Preprocessor
• RAII: Resource Acquisition Is Initialization
• Random number generation
• Recursion in C++
• Recursive Mutex
• Refactoring Techniques
• Regular expressions
• Resource Management
• Return Type Covariance
• Returning several values from a function
• RTTI: Run-Time Type Information
• SFINAE (Substitution Failure Is Not An Error)
• Side by Side Comparisons of classic C++ examples solved via C++ vs C++11 vs C++14 vs C++17
• Singleton Design Pattern
• Smart Pointers
• Special Member Functions
• Standard Library Algorithms
• static_assert
• std::atomics
• std::forward_list
• std::function: To wrap any element that is callable
• std::integer_sequence
• std::iomanip
• std::optional
• std::set and std::multiset
• std::string
• std::variant
• std::vector
• Storage class specifiers
• Stream manipulators
• The ISO C++ Standard
• The Rule of Three, Five, And Zero
• The This Pointer
• Thread synchronization structures
• Trailing return type
• type deduction
• Type Erasure
• Type Inference
• Type Keywords
• Type Traits
• Typedef and type aliases
• Undefined Behavior
• Unit Testing in C++
• Unnamed types
• Unspecified behavior
• User-Defined Literals
• Using declaration
• Using std::unordered_map
• Value and Reference Semantics
• Value Categories
• Variable Declaration Keywords
• Virtual Member Functions

C++ Copying vs Assignment Copy Constructor Vs Assignment Constructor

Fastest entity framework extensions.

Ok we have briefly looked over what the copy constructor and assignment constructor are above and gave examples of each now let's see both of them in the same code. This code will be similar as above two. Let's take this :

Here you can see we first call the copy constructor by executing the line Foo foo2 = foo; . Since we didn't initialize it previously. And then next we call the assignment operator on foo3 since it was already initialized foo3=foo ;

Got any C++ Question?

• Advertise with us
• Cookie Policy
• Privacy Policy

Get monthly updates about new articles, cheatsheets, and tricks.

21.12 — Overloading the assignment operator

The copy assignment operator (operator=) is used to copy values from one object to another already existing object .

Related content

As of C++11, C++ also supports “Move assignment”. We discuss move assignment in lesson 22.3 -- Move constructors and move assignment .

Copy assignment vs Copy constructor

The purpose of the copy constructor and the copy assignment operator are almost equivalent -- both copy one object to another. However, the copy constructor initializes new objects, whereas the assignment operator replaces the contents of existing objects.

The difference between the copy constructor and the copy assignment operator causes a lot of confusion for new programmers, but it’s really not all that difficult. Summarizing:

• If a new object has to be created before the copying can occur, the copy constructor is used (note: this includes passing or returning objects by value).
• If a new object does not have to be created before the copying can occur, the assignment operator is used.

Overloading the assignment operator

Overloading the copy assignment operator (operator=) is fairly straightforward, with one specific caveat that we’ll get to. The copy assignment operator must be overloaded as a member function.

This prints:

This should all be pretty straightforward by now. Our overloaded operator= returns *this, so that we can chain multiple assignments together:

Issues due to self-assignment

Here’s where things start to get a little more interesting. C++ allows self-assignment:

This will call f1.operator=(f1), and under the simplistic implementation above, all of the members will be assigned to themselves. In this particular example, the self-assignment causes each member to be assigned to itself, which has no overall impact, other than wasting time. In most cases, a self-assignment doesn’t need to do anything at all!

However, in cases where an assignment operator needs to dynamically assign memory, self-assignment can actually be dangerous:

First, run the program as it is. You’ll see that the program prints “Alex” as it should.

Now run the following program:

You’ll probably get garbage output. What happened?

Consider what happens in the overloaded operator= when the implicit object AND the passed in parameter (str) are both variable alex. In this case, m_data is the same as str.m_data. The first thing that happens is that the function checks to see if the implicit object already has a string. If so, it needs to delete it, so we don’t end up with a memory leak. In this case, m_data is allocated, so the function deletes m_data. But because str is the same as *this, the string that we wanted to copy has been deleted and m_data (and str.m_data) are dangling.

Later on, we allocate new memory to m_data (and str.m_data). So when we subsequently copy the data from str.m_data into m_data, we’re copying garbage, because str.m_data was never initialized.

Detecting and handling self-assignment

Fortunately, we can detect when self-assignment occurs. Here’s an updated implementation of our overloaded operator= for the MyString class:

By checking if the address of our implicit object is the same as the address of the object being passed in as a parameter, we can have our assignment operator just return immediately without doing any other work.

Because this is just a pointer comparison, it should be fast, and does not require operator== to be overloaded.

When not to handle self-assignment

Typically the self-assignment check is skipped for copy constructors. Because the object being copy constructed is newly created, the only case where the newly created object can be equal to the object being copied is when you try to initialize a newly defined object with itself:

In such cases, your compiler should warn you that c is an uninitialized variable.

Second, the self-assignment check may be omitted in classes that can naturally handle self-assignment. Consider this Fraction class assignment operator that has a self-assignment guard:

If the self-assignment guard did not exist, this function would still operate correctly during a self-assignment (because all of the operations done by the function can handle self-assignment properly).

Because self-assignment is a rare event, some prominent C++ gurus recommend omitting the self-assignment guard even in classes that would benefit from it. We do not recommend this, as we believe it’s a better practice to code defensively and then selectively optimize later.

The copy and swap idiom

A better way to handle self-assignment issues is via what’s called the copy and swap idiom. There’s a great writeup of how this idiom works on Stack Overflow .

The implicit copy assignment operator

Unlike other operators, the compiler will provide an implicit public copy assignment operator for your class if you do not provide a user-defined one. This assignment operator does memberwise assignment (which is essentially the same as the memberwise initialization that default copy constructors do).

Just like other constructors and operators, you can prevent assignments from being made by making your copy assignment operator private or using the delete keyword:

Note that if your class has const members, the compiler will instead define the implicit operator= as deleted. This is because const members can’t be assigned, so the compiler will assume your class should not be assignable.

If you want a class with const members to be assignable (for all members that aren’t const), you will need to explicitly overload operator= and manually assign each non-const member.

cppreference.com

Move assignment operator.

A move 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, possibly mutating the argument.

[ edit ] Syntax

For the formal move assignment operator syntax, see function declaration . The syntax list below only demonstrates a subset of all valid move assignment operator syntaxes.

[ edit ] Explanation

The move assignment operator is called whenever it is selected by overload resolution , e.g. when an object appears on the left-hand side of an assignment expression, where the right-hand side is an rvalue of the same or implicitly convertible type.

Move assignment operators typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc.), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, move-assigning from a std::string or from a std::vector may result in the argument being left empty. This is not, however, a guarantee. A move assignment is less, not more restrictively defined than ordinary assignment; where ordinary assignment must leave two copies of data at completion, move assignment is required to leave only one.

[ edit ] Implicitly-declared move assignment operator

If no user-defined move assignment operators are provided for a class type, and all of the following is true:

• there are no user-declared copy constructors ;
• there are no user-declared move constructors ;
• there are no user-declared copy assignment operators ;
• there is no user-declared destructor ,

then the compiler will declare a move assignment operator as an inline public member of its class with the signature T & T :: operator = ( T && ) .

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

The implicitly-declared (or defaulted on its first declaration) move assignment operator has an exception specification as described in dynamic exception specification (until C++17) noexcept specification (since C++17) .

Because some assignment operator (move or copy) 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 ] Implicitly-defined move assignment operator

If the implicitly-declared move 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 or needed for constant evaluation (since C++14) .

For union types, the implicitly-defined move assignment operator copies the object representation (as by std::memmove ).

For non-union class types, the move assignment operator performs full member-wise move assignment of the object's direct bases and immediate non-static members, in their declaration order, using built-in assignment for the scalars, memberwise move-assignment for arrays, and move assignment operator for class types (called non-virtually).

As with copy assignment, 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 move assignment operator:

[ edit ] Deleted move assignment operator

The implicitly-declared or defaulted move assignment operator for class T is defined as deleted if any of the following conditions is satisfied:

• T has a non-static data member of a const-qualified non-class type (or possibly multi-dimensional array thereof).
• T has a non-static data member of a reference type.
• T has a potentially constructed subobject of class type M (or possibly multi-dimensional array thereof) such that the overload resolution as applied to find M 's move assignment operator
• does not result in a usable candidate, or
• in the case of the subobject being a variant member , selects a non-trivial function.

A deleted implicitly-declared move assignment operator is ignored by overload resolution .

[ edit ] Trivial move assignment operator

The move 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);
• T has no virtual member functions;
• T has no virtual base classes;
• the move assignment operator selected for every direct base of T is trivial;
• the move assignment operator selected for every non-static class type (or array of class type) member of T is trivial.

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

[ edit ] Eligible move assignment operator

Triviality of eligible move assignment operators determines whether the class is a trivially copyable type .

[ edit ] Notes

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either a prvalue such as a nameless temporary or an xvalue such as the result of std::move ), and selects the copy assignment if the argument is an 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 move assignment operator (same applies to copy assignment ).

See assignment operator overloading for additional detail on the expected behavior of a user-defined move-assignment operator.

[ edit ] Example

[ edit ] defect reports.

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[ edit ] See also

• constructor
• converting constructor
• copy assignment
• copy constructor
• default constructor
• aggregate initialization
• constant initialization
• copy initialization
• default initialization
• direct initialization
• list initialization
• reference initialization
• value initialization
• zero initialization
• move constructor
• 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 11 January 2024, at 19:29.
• This page has been accessed 755,943 times.
• Privacy policy
• About cppreference.com
• Disclaimers

• C++ Classes and Objects
• C++ Polymorphism
• C++ Inheritance
• C++ Abstraction
• C++ Encapsulation
• C++ OOPs Interview Questions
• C++ OOPs MCQ
• C++ Interview Questions
• C++ Function Overloading
• C++ Programs
• C++ Preprocessor
• C++ Templates

Move Constructors in C++ with Examples

• Dynamic Constructor in C++ with Examples
• How to Define the Default Constructor in C++?
• Constructor Delegation in C++
• Constructor Overloading in C++
• Constructors in C++
• Copy Constructor in C++
• std::is_move_constructible in C++ with Examples
• std::is_copy_constructible in C++ with Examples
• std::is_nothrow_move_constructible in C++ with Example
• std::is_constructible template in C++ with Examples
• std::is_trivially_move_constructible in C++ with Examples
• std::is_trivially_constructible in C++ with Examples
• std::is_nothrow_copy_constructible in C++ with Examples
• std::is_default_constructible in C++ with Examples
• Default Methods in C++ with Examples
• std::allocator() in C++ with Examples
• Constructors in Objective-C
• How to create a List with Constructor in C++ STL
• What is conversion constructor in C++?

Prerequisites: l-value and r-value references in C++ , Copy Constructor in C++ .

What is a Move Constructor?  

The copy constructors in C++ work with the l-value references and copy semantics(copy semantics means copying the actual data of the object to another object rather than making another object to point the already existing object in the heap). While move constructors work on the r-value references and move semantics(move semantics involves pointing to the already existing object in the memory).

On declaring the new object and assigning it with the r-value, firstly a temporary object is created, and then that temporary object is used to assign the values to the object. Due to this the copy constructor is called several times and increases the overhead and decreases the computational power of the code. To avoid this overhead and make the code more efficient we use move constructors.

Why Move Constructors are used?

Move constructor moves the resources in the heap, i.e., unlike copy constructors which copy the data of the existing object and assigning it to the new object move constructor just makes the pointer of the declared object to point to the data of temporary object and nulls out the pointer of the temporary objects. Thus, move constructor prevents unnecessarily copying data in the memory.  

Work of move constructor looks a bit like default member-wise copy constructor but in this case, it nulls out the pointer of the temporary object preventing more than one object to point to same memory location.

Below is the program without declaring the move constructor:

Explanation:   The above program shows the unnecessarily calling copy constructor and inefficiently using the memory by copying the same data several times as it new object upon each call to copy constructor.

Syntax of the Move Constructor:

This unnecessary use of the memory can be avoided by using move constructor. Below is the program declaring the move constructor:

Explanation:   The unnecessary call to the copy constructor is avoided by making the call to the move constructor. Thus making the code more memory efficient and decreasing the overhead of calling the move constructor.

Please Login to comment...

Similar reads.

• C++-Constructors
• Constructors
• cpp-constructor
• school-programming

Improve your Coding Skills with Practice

What kind of Experience do you want to share?