the copy assignment operator

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?

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

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 & . For a type to be CopyAssignable , it must have a public copy assignment operator.

[ edit ] Syntax

[ 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

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 . (since C++11)

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

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

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 (until C++14) ;
• 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;

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 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 copy assignment operator (same applies to move assignment ).

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

[ edit ] Example

[ edit ] defect reports.

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

• Pages with unreviewed CWG DR marker
• 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 9 January 2019, at 07:16.
• This page has been accessed 570,566 times.
• Privacy policy
• About cppreference.com
• Disclaimers

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 & . For a type to be CopyAssignable , it must have a public copy assignment operator.

[ edit ] Syntax

[ 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

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 . (since C++11)

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

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

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:

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

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

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 (that isn't an explicit object 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.

Explanation

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.

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=(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 . (since C++11) .

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

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.

Deleted implicitly-declared copy assignment operator

An 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 a const-qualified non-class type (or array thereof);
• T has a non-static data member of a reference type;
• T has a non-static data member or a direct 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.

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);
• 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.

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.

Eligible copy assignment operator

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

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

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 copy assignment operator (same applies to move assignment ).

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

Defect reports

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

• converting constructor
• copy constructor
• copy elision
• default constructor
• aggregate initialization
• constant initialization
• copy initialization
• default initialization
• direct initialization
• initializer list
• list initialization
• reference initialization
• value initialization
• zero initialization
• move assignment
• move constructor

© cppreference.com Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0. https://en.cppreference.com/w/cpp/language/as_operator

• 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

22.3 — Move constructors and move assignment

Related content

You now have enough context to understand the key insight behind move semantics.

Automatic l-values returned by value may be moved instead of copied

• 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

• C++ Programming Language

C++ Overview

• Introduction to C++ Programming Language
• Features of C++
• History of C++
• Interesting Facts about C++
• Setting up C++ Development Environment
• Difference between C and C++
• Writing First C++ Program - Hello World Example
• C++ Basic Syntax
• C++ Comments
• Tokens in C
• C++ Keywords
• Difference between Keyword and Identifier in C

C++ Variables and Constants

• C++ Variables
• Constants in C
• Scope of Variables in C++
• Storage Classes in C++ with Examples
• Static Keyword in C++

C++ Data Types and Literals

• C++ Data Types
• Literals in C
• Derived Data Types in C++
• User Defined Data Types in C++
• Data Type Ranges and their macros in C++
• C++ Type Modifiers
• Type Conversion in C++
• Casting Operators in C++

C++ Operators

• Operators in C++
• C++ Arithmetic Operators
• Unary operators in C
• Bitwise Operators in C
• Assignment Operators in C
• C++ sizeof Operator
• Scope resolution operator in C++

C++ Input/Output

• Basic Input / Output in C++
• cout in C++
• cerr - Standard Error Stream Object in C++
• Manipulators in C++ with Examples

C++ Control Statements

• Decision Making in C (if , if..else, Nested if, if-else-if )
• C++ if Statement
• C++ if else Statement
• C++ if else if Ladder
• Switch Statement in C++
• Jump statements in C++
• for Loop in C++
• Range-based for loop in C++
• C++ While Loop
• C++ Do/While Loop

C++ Functions

• Functions in C++
• return statement in C++ with Examples
• Parameter Passing Techniques in C
• Difference Between Call by Value and Call by Reference in C
• Default Arguments in C++
• Inline Functions in C++
• Lambda expression in C++

C++ Pointers and References

• Pointers and References in C++
• C++ Pointers
• Dangling, Void , Null and Wild Pointers in C
• Applications of Pointers in C
• Understanding nullptr in C++
• References in C++
• Can References Refer to Invalid Location in C++?
• Pointers vs References in C++
• Passing By Pointer vs Passing By Reference in C++
• When do we pass arguments by pointer?
• Variable Length Arrays (VLAs) in C
• Pointer to an Array | Array Pointer
• How to print size of array parameter in C++?
• Pass Array to Functions in C
• What is Array Decay in C++? How can it be prevented?

C++ Strings

• Strings in C++
• std::string class in C++
• Array of Strings in C++ - 5 Different Ways to Create
• String Concatenation in C++
• Tokenizing a string in C++
• Substring in C++

C++ Structures and Unions

• Structures, Unions and Enumerations in C++
• Structures in C++
• C++ - Pointer to Structure
• Self Referential Structures
• Difference Between C Structures and C++ Structures
• Enumeration in C++
• typedef in C++
• Array of Structures vs Array within a Structure in C

C++ Dynamic Memory Management

• Dynamic Memory Allocation in C using malloc(), calloc(), free() and realloc()
• new and delete Operators in C++ For Dynamic Memory
• new vs malloc() and free() vs delete in C++
• What is Memory Leak? How can we avoid?
• Difference between Static and Dynamic Memory Allocation in C

C++ Object-Oriented Programming

• Object Oriented Programming in C++
• Access Modifiers in C++
• Friend Class and Function in C++
• Constructors in C++
• Default Constructors in C++

Copy Constructor in C++

• Destructors in C++
• Private Destructor in C++
• When is a Copy Constructor Called in C++?
• Shallow Copy and Deep Copy in C++
• When Should We Write Our Own Copy Constructor in C++?
• Does C++ compiler create default constructor when we write our own?
• C++ Static Data Members
• Static Member Function in C++
• 'this' pointer in C++
• Scope Resolution Operator vs this pointer in C++
• Local Classes in C++
• Nested Classes in C++
• Enum Classes in C++ and Their Advantage over Enum DataType
• Difference Between Structure and Class in C++
• Why C++ is partially Object Oriented Language?

C++ Encapsulation and Abstraction

• Encapsulation in C++
• Abstraction in C++
• Difference between Abstraction and Encapsulation in C++
• Function Overriding in C++
• Virtual Functions and Runtime Polymorphism in C++
• Difference between Inheritance and Polymorphism
• Function Overloading in C++
• Constructor Overloading in C++
• Functions that cannot be overloaded in C++
• Function overloading and const keyword
• Function Overloading and Return Type in C++
• Function Overloading and float in C++
• C++ Function Overloading and Default Arguments
• Can main() be overloaded in C++?
• Function Overloading vs Function Overriding in C++
• Advantages and Disadvantages of Function Overloading in C++

C++ Operator Overloading

• Operator Overloading in C++
• Types of Operator Overloading in C++
• Functors in C++
• What are the Operators that Can be and Cannot be Overloaded in C++?
• Inheritance in C++
• C++ Inheritance Access
• Multiple Inheritance in C++
• C++ Hierarchical Inheritance
• C++ Multilevel Inheritance
• Constructor in Multiple Inheritance in C++
• Inheritance and Friendship in C++
• Does overloading work with Inheritance?

C++ Virtual Functions

• Virtual Function in C++
• Virtual Functions in Derived Classes in C++
• Default Arguments and Virtual Function in C++
• Can Virtual Functions be Inlined in C++?
• Virtual Destructor
• Advanced C++ | Virtual Constructor
• Advanced C++ | Virtual Copy Constructor
• Pure Virtual Functions and Abstract Classes in C++
• Pure Virtual Destructor in C++
• Can Static Functions Be Virtual in C++?
• RTTI (Run-Time Type Information) in C++
• Can Virtual Functions be Private in C++?

C++ Exception Handling

• Exception Handling in C++
• Exception Handling using classes in C++
• Stack Unwinding in C++
• User-defined Custom Exception with class in C++

C++ Files and Streams

• File Handling through C++ Classes
• I/O Redirection in C++
• Templates in C++ with Examples
• Template Specialization in C++
• Using Keyword in C++ STL

C++ Standard Template Library (STL)

• The C++ Standard Template Library (STL)
• Containers in C++ STL (Standard Template Library)
• Introduction to Iterators in C++
• Algorithm Library | C++ Magicians STL Algorithm

C++ Preprocessors

• C Preprocessors
• C Preprocessor Directives
• #include in C
• Difference between Preprocessor Directives and Function Templates in C++

C++ Namespace

• Namespace in C++ | Set 1 (Introduction)
• namespace in C++ | Set 2 (Extending namespace and Unnamed namespace)
• Namespace in C++ | Set 3 (Accessing, creating header, nesting and aliasing)
• C++ Inline Namespaces and Usage of the "using" Directive Inside Namespaces

Advanced C++

• Multithreading in C++
• Smart Pointers in C++
• auto_ptr vs unique_ptr vs shared_ptr vs weak_ptr in C++
• Type of 'this' Pointer in C++
• "delete this" in C++
• Passing a Function as a Parameter in C++
• Signal Handling in C++
• Generics in C++
• Difference between C++ and Objective C
• Write a C program that won't compile in C++
• Write a program that produces different results in C and C++
• How does 'void*' differ in C and C++?
• Type Difference of Character Literals in C and C++
• Cin-Cout vs Scanf-Printf

C++ vs Java

• Similarities and Difference between Java and C++
• Comparison of Inheritance in C++ and Java
• How Does Default Virtual Behavior Differ in C++ and Java?
• Comparison of Exception Handling in C++ and Java
• Foreach in C++ and Java
• Templates in C++ vs Generics in Java
• Floating Point Operations & Associativity in C, C++ and Java

Competitive Programming in C++

• Competitive Programming - A Complete Guide
• C++ tricks for competitive programming (for C++ 11)
• Writing C/C++ code efficiently in Competitive programming
• Why C++ is best for Competitive Programming?
• Test Case Generation | Set 1 (Random Numbers, Arrays and Matrices)
• Fast I/O for Competitive Programming
• Setting up Sublime Text for C++ Competitive Programming Environment
• How to setup Competitive Programming in Visual Studio Code for C++
• Which C++ libraries are useful for competitive programming?
• Common mistakes to be avoided in Competitive Programming in C++ | Beginners
• C++ Interview Questions and Answers (2024)
• Top C++ STL Interview Questions and Answers
• 30 OOPs Interview Questions and Answers (2024)
• Top C++ Exception Handling Interview Questions and Answers
• C++ Programming Examples

Pre-requisite: Constructor in C++ 

A copy constructor is a member function that initializes an object using another object of the same class. In simple terms, a constructor which creates an object by initializing it with an object of the same class, which has been created previously is known as a copy constructor .  

Copy constructor is used to initialize the members of a newly created object by copying the members of an already existing object.

Copy constructor takes a reference to an object of the same class as an argument.

The process of initializing members of an object through a copy constructor is known as copy initialization.

It is also called member-wise initialization because the copy constructor initializes one object with the existing object, both belonging to the same class on a member by member copy basis.

The copy constructor can be defined explicitly by the programmer. If the programmer does not define the copy constructor, the compiler does it for us.  

Syntax of Copy Constructor

Characteristics of Copy Constructor

1. The copy constructor is used to initialize the members of a newly created object by copying the members of an already existing object.

2. Copy constructor takes a reference to an object of the same class as an argument. If you pass the object by value in the copy constructor, it would result in a recursive call to the copy constructor itself. This happens because passing by value involves making a copy, and making a copy involves calling the copy constructor, leading to an infinite loop. Using a reference avoids this recursion. So we use reference of Objects to avoid infinite calls.

3. The process of initializing members of an object through a copy constructor is known as copy initialization.

4 . It is also called member-wise initialization because the copy constructor initializes one object with the existing object, both belonging to the same class on a member-by-member copy basis.

5. The copy constructor can be defined explicitly by the programmer. If the programmer does not define the copy constructor, the compiler does it for us.

Types of Copy Constructors

1. default copy constructor.

An implicitly defined copy constructor will copy the bases and members of an object in the same order that a constructor would initialize the bases and members of the object.

2. User Defined Copy Constructor 

A user-defined copy constructor is generally needed when an object owns pointers or non-shareable references, such as to a file, in which case a destructor and an assignment operator should also be written

When is the copy constructor called? 

In C++, a Copy Constructor may be called in the following cases: 

• When an object of the class is returned by value. 
• When an object of the class is passed (to a function) by value as an argument. 
• When an object is constructed based on another object of the same class. 
• When the compiler generates a temporary object.

It is, however, not guaranteed that a copy constructor will be called in all these cases, because the C++ Standard allows the compiler to optimize the copy away in certain cases, one example is the return value optimization (sometimes referred to as RVO).

Copy Elision

In copy elision , the compiler prevents the making of extra copies which results in saving space and better the program complexity(both time and space); Hence making the code more optimized.  

Now it is on the compiler to decide what it wants to print, it could either print the above output or it could print case 1 or case 2 below, and this is what Return Value Optimization is. In simple words, RVO is a technique that gives the compiler some additional power to terminate the temporary object created which results in changing the observable behavior/characteristics of the final program.

When is a user-defined copy constructor needed? 

If we don’t define our own copy constructor, the C++ compiler creates a default copy constructor for each class which does a member-wise copy between objects. The compiler-created copy constructor works fine in general. We need to define our own copy constructor only if an object has pointers or any runtime allocation of the resource like a file handle , a network connection, etc.  

The default constructor does only shallow copy.  

Deep copy is possible only with a user-defined copy constructor. In a user-defined copy constructor, we make sure that pointers (or references) of copied objects point to new memory locations.  

Copy constructor vs Assignment Operator 

The main difference between Copy Constructor and Assignment Operator is that the Copy constructor makes a new memory storage every time it is called while the assignment operator does not make new memory storage.

Which of the following two statements calls the copy constructor and which one calls the assignment operator? 

A copy constructor is called when a new object is created from an existing object, as a copy of the existing object. The assignment operator is called when an already initialized object is assigned a new value from another existing object. In the above example (1) calls the copy constructor and (2) calls the assignment operator. See this for more details.

Example – Class Where a Copy Constructor is Required 

Following is a complete C++ program to demonstrate the use of the Copy constructor. In the following String class, we must write a copy constructor. 

What would be the problem if we remove the copy constructor from the above code? 

If we remove the copy constructor from the above program, we don’t get the expected output. The changes made to str2 reflect in str1 as well which is never expected.   

Can we make the copy constructor private?  

Yes, a copy constructor can be made private. When we make a copy constructor private in a class, objects of that class become non-copyable. This is particularly useful when our class has pointers or dynamically allocated resources. In such situations, we can either write our own copy constructor like the above String example or make a private copy constructor so that users get compiler errors rather than surprises at runtime.

Why argument to a copy constructor must be passed as a reference?  

A copy constructor is called when an object is passed by value. Copy constructor itself is a function. So if we pass an argument by value in a copy constructor, a call to the copy constructor would be made to call the copy constructor which becomes a non-terminating chain of calls. Therefore compiler doesn’t allow parameters to be passed by value.

Why argument to a copy constructor should be const?

One reason for passing const reference is, that we should use const in C++ wherever possible so that objects are not accidentally modified. This is one good reason for passing reference as const , but there is more to it than ‘ Why argument to a copy constructor should be const?’

Please Login to comment...

Similar reads.

• cpp-constructor

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• 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.

What is std::move(), and when should it be used?

• What is it?
• What does it do?
• When should it be used?

Good links are appreciated.

• move-semantics

• 64 Bjarne Stroustrup explains move in A Brief Introduction to Rvalue References –  DumbCoder Commented Aug 5, 2010 at 9:49
• 2 Move semantics –  Basilevs Commented Sep 11, 2014 at 4:12
• 23 This question is referring to std::move(T && t) ; there also exists a std::move(InputIt first, InputIt last, OutputIt d_first) which is an algorithm related to std::copy . I point it out so others aren't as confused as I was when first confronted with a std::move taking three arguments. en.cppreference.com/w/cpp/algorithm/move –  josaphatv Commented Oct 17, 2016 at 22:48
• 2 Recommend reading this if you don't have much of an idea what lvalue and rvalue references mean internalpointers.com/post/… –  Karan Singh Commented Jun 25, 2020 at 15:22
• 2 To clarify, this question is about the std::move from <utility> , not the std::move from <algorithm> . –  Adrian McCarthy Commented Apr 18, 2022 at 13:43

9 Answers 9

1. "what is it".

While std::move() is technically a function - I would say it isn't really a function . It's sort of a converter between ways the compiler considers an expression's value.

2. "What does it do?"

The first thing to note is that std::move() doesn't actually move anything . It changes an expression from being an lvalue (such as a named variable) to being an xvalue . An xvalue tells the compiler:

You can plunder me, move anything I'm holding and use it elsewhere (since I'm going to be destroyed soon anyway)".

in other words, when you use std::move(x) , you're allowing the compiler to cannibalize x . Thus if x has, say, its own buffer in memory - after std::move() ing the compiler can have another object own it instead.

You can also move from a prvalue (such as a temporary you're passing around), but this is rarely useful.

3. "When should it be used?"

Another way to ask this question is "What would I cannibalize an existing object's resources for?" well, if you're writing application code, you would probably not be messing around a lot with temporary objects created by the compiler. So mainly you would do this in places like constructors, operator methods, standard-library-algorithm-like functions etc. where objects get created and destroyed automagically a lot. Of course, that's just a rule of thumb.

A typical use is 'moving' resources from one object to another instead of copying. @Guillaume links to this page which has a straightforward short example: swapping two objects with less copying.

using move allows you to swap the resources instead of copying them around:

Think of what happens when T is, say, vector<int> of size n. In the first version you read and write 3*n elements, in the second version you basically read and write just the 3 pointers to the vectors' buffers, plus the 3 buffers' sizes. Of course, class T needs to know how to do the moving; your class should have a move-assignment operator and a move-constructor for class T for this to work.

• 23 For a long time I've heard of these move semantics, I never looked into them. From this description you've given it just seems like it's a shallow copy instead of a deep copy. –  Zebrafish Commented Dec 30, 2016 at 10:52
• 50 @TitoneMaurice: Except that it's not a copy - as the original value is no longer usable. –  einpoklum Commented Dec 30, 2016 at 11:52
• 15 @Zebrafish you couldn't be more wrong. A shallow copy leaves the original in the exact same state, a move usually results in the original being empty or in an otherwise valid state. –  rubenvb Commented Jan 10, 2018 at 22:38
• 94 @rubenvb Zebra isn't entirely wrong. While it's true that the original cannabilised object is usually deliberately sabotaged to avoid confusing errors (e.g. set its pointers to nullptr to signal that it no longer owns the pointees), the fact that the whole move is implemented by simply copying a pointer from the source to the destination (and deliberately avoiding doing anything with the pointee) is indeed reminiscent of a shallow copy. In fact, I would go so far as to say that a move is a shallow copy, followed optionally by a partial self-destruct of the source. (cont.) –  Lightness Races in Orbit Commented Nov 1, 2018 at 18:54
• 29 (cont.) If we permit this definition (and I rather like it), then @Zebrafish's observation isn't wrong, just slightly incomplete. –  Lightness Races in Orbit Commented Nov 1, 2018 at 18:55

Wikipedia Page on C++11 R-value references and move constructors

• In C++11, in addition to copy constructors, objects can have move constructors. (And in addition to copy assignment operators, they have move assignment operators.)
• The move constructor is used instead of the copy constructor, if the object has type "rvalue-reference" ( Type && ).
• std::move() is a cast that produces an rvalue-reference to an object, to enable moving from it.

It's a new C++ way to avoid copies. For example, using a move constructor, a std::vector could just copy its internal pointer to data to the new object, leaving the moved object in an moved from state, therefore not copying all the data. This would be C++-valid.

Try googling for move semantics, rvalue, perfect forwarding.

• 47 Move-semantics require the moved object remain valid , which is not an incorrect state. (Rationale: It still has to destruct, make it work.) –  GManNickG Commented Aug 5, 2010 at 16:37
• 19 @GMan: well, it has to be in a state that is safe to destruct, but, AFAIK, it does not have to be usable for anything else. –  Zan Lynx Commented Oct 4, 2011 at 19:15
• 9 @ZanLynx: Right. Note that the standard library additionally requires moved objects be assignable, but this is only for objects used in the stdlib, not a general requirement. –  GManNickG Commented Oct 4, 2011 at 19:44
• 34 -1 "std::move() is the C++11 way to use move semantics" Please fix that. std::move() is not the way to use move semantics, move semantics are performed transparently to the programmer. move its only a cast to pass a value from one point to another where the original lvalue will no longer be used. –  Manu343726 Commented Jul 3, 2014 at 19:35
• 31 I'd go further. std::move itself does "nothing" - it has zero side effects. It just signals to the compiler that the programmer doesn't care what happens to that object any more. i.e. it gives permission to other parts of the software to move from the object, but it doesn't require that it be moved. In fact, the recipient of an rvalue reference doesn't have to make any promises about what it will or will not do with the data. –  Aaron McDaid Commented Aug 20, 2015 at 14:17

You can use move when you need to "transfer" the content of an object somewhere else, without doing a copy (i.e. the content is not duplicated, that's why it could be used on some non-copyable objects, like a unique_ptr). It's also possible for an object to take the content of a temporary object without doing a copy (and save a lot of time), with std::move.

This link really helped me out :

http://thbecker.net/articles/rvalue_references/section_01.html

I'm sorry if my answer is coming too late, but I was also looking for a good link for the std::move, and I found the links above a little bit "austere".

This puts the emphasis on r-value reference, in which context you should use them, and I think it's more detailed, that's why I wanted to share this link here.

• 31 Nice link. I always found the wikipedia article, and other links that I stumbled across rather confusing since they just throw facts at you, leaving it to you to figure out what the actual meaning/rationale is. While "move semantics" in a constructor is rather obvious, all those details about passing &&-values around are not... so the tutorial-style description was very nice. –  Christian Stieber Commented Jul 15, 2012 at 12:12

Q: What is std::move ?

A: std::move() is a function from the C++ Standard Library for casting to a rvalue reference.

Simplisticly std::move(t) is equivalent to:

An rvalue is a temporary that does not persist beyond the expression that defines it, such as an intermediate function result which is never stored in a variable.

An implementation for std::move() is given in N2027: "A Brief Introduction to Rvalue References" as follows:

As you can see, std::move returns T&& no matter if called with a value ( T ), reference type ( T& ), or rvalue reference ( T&& ).

Q: What does it do?

A: As a cast, it does not do anything during runtime. It is only relevant at compile time to tell the compiler that you would like to continue considering the reference as an rvalue.

What it does not do:

• Make a copy of the argument
• Call the copy constructor
• Change the argument object

Q: When should it be used?

A: You should use std::move if you want to call functions that support move semantics with an argument which is not an rvalue (temporary expression).

This begs the following follow-up questions for me:

What is move semantics? Move semantics in contrast to copy semantics is a programming technique in which the members of an object are initialized by 'taking over' instead of copying another object's members. Such 'take over' makes only sense with pointers and resource handles, which can be cheaply transferred by copying the pointer or integer handle rather than the underlying data.

What kind of classes and objects support move semantics? It is up to you as a developer to implement move semantics in your own classes if these would benefit from transferring their members instead of copying them. Once you implement move semantics, you will directly benefit from work from many library programmers who have added support for handling classes with move semantics efficiently.

Why can't the compiler figure it out on its own? The compiler cannot just call another overload of a function unless you say so. You must help the compiler choose whether the regular or move version of the function should be called.

In which situations would I want to tell the compiler that it should treat a variable as an rvalue? This will most likely happen in template or library functions, where you know that an intermediate result could be salvaged (rather than allocating a new instance).

• 16 Big +1 for code examples with semantics in comments. The other top answers define std::move using "move" itself - doesn't really clarify anything! --- I believe it's worth mentioning that not making a copy of the argument means that the original value cannot be reliably used. –  llf Commented Jun 7, 2018 at 18:48

std::move itself doesn't really do much. I thought that it called the moved constructor for an object, but it really just performs a type cast (casting an lvalue variable to an rvalue so that the said variable can be passed as an argument to a move constructor or assignment operator).

So std::move is just used as a precursor to using move semantics. Move semantics is essentially an efficient way for dealing with temporary objects.

Consider Object A = B + (C + (D + (E + F)));

This is nice looking code, but E + F produces a temporary object. Then D + temp produces another temporary object and so on. In each normal "+" operator of a class, deep copies occur.

For example

The creation of the temporary object in this function is useless - these temporary objects will be deleted at the end of the line anyway as they go out of scope.

We can rather use move semantics to "plunder" the temporary objects and do something like

This avoids needless deep copies being made. With reference to the example, the only part where deep copying occurs is now E + F. The rest uses move semantics. The move constructor or assignment operator also needs to be implemented to assign the result to A.

• 3 you spoke about move semantics . you should add to your answer as how std::move can be used because the question asks about that. –  Koushik Shetty Commented Jun 5, 2013 at 8:01
• 2 @Koushik std::move doesnt do much - but is used to implement move semantics. If you don't know about std::move, you probably dont know move semantics either –  user929404 Commented Jun 5, 2013 at 8:56
• 2 "doesnt do much"(yes just a static_cast to to a rvalue reference). what actually does it do and y it does is what the OP asked. you need not know how std::move works but you got to know what move semantics does. furthermore, "but is used to implement move semantics" its the otherway around. know move semantics and you'l understand std::move otherwise no. move just helps in movement and itself uses move semantics. std::move does nothing but convert its argument to rvalue reference, which is what move semantics require. –  Koushik Shetty Commented Jun 5, 2013 at 9:08
• 11 "but E + F produces a temporary object" - Operator + goes left to right, not right to left. Hence B+C would be first! –  Ajay Commented Oct 15, 2015 at 7:20
• only your answer explained it to me –  Ulterior Commented Nov 10, 2020 at 11:53

"What is it?" and "What does it do?" has been explained above.

I will give a example of "when it should be used".

For example, we have a class with lots of resource like big array in it.

output as below:

We can see that std::move with move constructor makes transform resource easily.

Where else is std::move useful?

std::move can also be useful when sorting an array of elements. Many sorting algorithms (such as selection sort and bubble sort) work by swapping pairs of elements. Previously, we’ve had to resort to copy-semantics to do the swapping. Now we can use move semantics, which is more efficient.

It can also be useful if we want to move the contents managed by one smart pointer to another.

• https://www.learncpp.com/cpp-tutorial/15-4-stdmove/

std::move itself does nothing rather than a static_cast . According to cppreference.com

It is exactly equivalent to a static_cast to an rvalue reference type.

Thus, it depends on the type of the variable you assign to after the move , if the type has constructors or assign operators that takes a rvalue parameter, it may or may not steal the content of the original variable, so, it may leave the original variable to be in an unspecified state :

Unless otherwise specified, all standard library objects that have been moved from being placed in a valid but unspecified state.

Because there is no special move constructor or move assign operator for built-in literal types such as integers and raw pointers, so, it will be just a simple copy for these types.

std::move simply casts a variable to an rvalue reference. This rvalue reference is notated with &&. Let's say you have a class Foo and you instantiate an object like this

If you then write

that's the same thing as If I wrote

std::move replaces this cast to an rvalue reference. The reason why you would want to write either of the previous 2 lines of code is that if you write

The copy constructor will be called. Let's say Foo instances have a pointer to some data on the heap which they own. In Foo's destructor that data on the heap gets deleted. If you want to distinghuish between copying the data from the heap and taking ownership of that data, you can write a constructor which takes in const Foo& and that constructor can perform the deep copy. Then you can write a constructor which takes in an rvalue reference (Foo&&) and this constructor can simply rewire the pointers. This constructor which takes in Foo&& will be called when you write

and when you write

• I think it could be misleading using the C-style cast " (Foo&&) ", since it provides little compile-time guarantee in contrast to using static_cast as already suggested by @ChristopherOezbeck. More info here . Otherwise this answer doesn't add much which hasn't already been covered. –  alexpanter Commented Feb 21, 2023 at 14:51

Here is a full example, using std::move for a (simple) custom vector

Expected output:

Compile as:

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++ c++11 move-semantics c++-faq stdmove or ask your own question .

• The Overflow Blog
• Community Products Roadmap Update, July 2024
• Featured on Meta
• We spent a sprint addressing your requests — here’s how it went
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network...
• Policy: Generative AI (e.g., ChatGPT) is banned
• The [lib] tag is being burninated
• What makes a homepage useful for logged-in users

Hot Network Questions

• Would this telescope be capable to detect Middle Ages Civilization?
• Do you always experience the gravitational influence of other mass as you see them in your frame?
• How close would a quasar have to be to be seen with the naked eye?
• Hourly pay rate calculation between Recruiting and Payroll Systems
• Explain why "Calf" is the answer to "Ice mass broken off a little lower?"
• Don't make noise. OR Don't make a noise
• Family reunion crossword: The case of the missing letters
• Raid 0+1 Failure Cases VS. Raid 1+0
• Has the Supreme Court given any examples where presumptive immunity would be overcome?
• Can player build dungeons in D&D? I thought that was just a job for the DM
• As an advisor, how can I help students with time management and procrastination?
• Can I improve my code to extract permutation cycles from a (n,2) matrix?
• pdfgrep How to locate the pages that contain multiple strings and print the page numbers?
• Any alternative to lockdown browser?
• Read an article about connecting a hot tub to a heat pump, looking for details
• Are directed graphs with out-degree exactly 2 strongly connected with probability 1?
• Seeing edges where there are no edges
• Confusion on defining uniform distribution on hypersphere and its sampling problem
• How do I drill a 60cm hole in a tree stump, 4.4 cm wide?
• A check given by castling: is it a discovered check or a special case?
• Confused about the output of `CosIntegral`
• What makes Python better suited to quant finance than Matlab / Octave, Julia, R and others?
• My lemon tree was in a hail storm
• Why does independent research from people without formal academic qualifications generally turn out to be a complete waste of time?