copy constructor vs assignment operator cpp

• 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

• Trending Categories

• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Copy constructor vs assignment operator in C++

The Copy constructor and the assignment operators are used to initializing one object to another object. The main difference between them is that the copy constructor creates a separate memory block for the new object. But the assignment operator does not make new memory space. It uses the reference variable to point to the previous memory block.

Copy Constructor (Syntax)

Assignment operator (syntax).

Let us see the detailed differences between Copy constructor and Assignment Operator.

• Related Articles
• Difference Between Copy Constructor and Assignment Operator in C++
• What's the difference between assignment operator and copy constructor in C++?
• Virtual Copy Constructor in C++
• How to use an assignment operator in C#?
• When is copy constructor called in C++?
• What is a copy constructor in C#?
• When should we write our own assignment operator in C++?
• What is Multiplication Assignment Operator (*=) in JavaScript?
• What is Addition Assignment Operator (+=) in JavaScript?
• When should we write our own assignment operator in C++ programming?
• Explain the concept of logical and assignment operator in C language
• Ternary operator ?: vs if…else in C/C++
• What is Bitwise OR Assignment Operator (|=) in JavaScript?
• What is Bitwise XOR Assignment Operator (^=) in JavaScript?
• Why do we need a copy constructor and when should we use a copy constructor in Java?

Kickstart Your Career

Get certified by completing the course

Table of Contents

When is a user-defined copy constructor needed, copy constructor vs assignment operator, how to make the copy constructor private, why does an argument to a copy constructor must be passed as a reference, why should the copy constructor argument be const in c++, understanding c++ copy constructor with example code.

When a new object is generated from an existing object as a copy of the existing object, the copy function Object () { [native code] } is named. When a previously initialized object is given a new value from another object, the assignment operator is used. Function Object () { [native code] } is a member function that uses another object of the same class to initialize an object. The following is a general function prototype for a copy function Object () { [native code] }:

Classname(const classname &obj);

#include<iostream>

using namespace std; 

class Point

     int a, b;

     Point(int x1, int y1) { a =x1; b = y1; } 

     // Copy constructor

     Point(const Point &p1) {a = p1.a; b = p1.b; } 

     int getX()            { return a; }

     int getY()            { return b; }

     Point p1(10, 15); // Normal constructor is called here

     Point p2 = p1; // Copy constructor is called here

     // Let us access values assigned by constructors

     cout << "p1.x = " << p1.getX() << ", p1.y = " << p1.getY();

     cout << "\np2.x = " << p2.getX() << ", p2.y = " << p2.getY();

     return 0;

According to C++ copy constructor the C++ compiler produces a default copy constructor Object() { [native code] } for each class if it doesn’t define own copy constructor Object() { [native code] }, which performs a member-wise copy between items. In general, the copy function Object() { [native code] } generated by the compiler works well. It just needs to define its own copy function Object() [native code] if an object has pointers or any runtime resource allocation, such as a file handle or a network connection.

Stand Out From Your Peers this Appraisal Season

When a new object is generated from an existing object as a copy of the existing object, the copy function Object() { [native code] } is named. When an already initialized object is given a new value from another object, the assignment operator is used.

Myclass c1,c2;

Myclass c3;

The above line illustrates the copy constructor

Where Copy Constructor is Needed:

#include<cstring>

class String

     char *s;

     int size;

     String(const char *str = NULL); // constructor

     ~String() { delete [] s; }// destructor

     String(const String&); // copy constructor

     void print() { cout << s << endl; } // Function to print string

     void change(const char *); // Function to change

 String::String(const char *str)

     size = strlen(str);

     s = new char[size+1];

     strcpy(s, str);

 void String::change(const char *str)

     delete [] s;

String::String(const String& old_str)

     size = old_str.size;

     strcpy(s, old_str.s);

     String str1("Welcome");

     String str2 = str1;

     str1.print(); // what is printed ?

     str2.print();

     str2.change("Welcome you all"); 

     str1.print(); // what is printed now ?

What Happens if We Remove the Copy Constructor from the Above Code?

In  c++ copy constructor users don't get the predicted result if we delete the copy function Object() { [native code] } from the above program. Changes to str2 are reflected in str1 as well, which is unexpected.

         char *s;

         int size;

String(const char *str = NULL); // constructor

         ~String() { delete [] s;  }// destructor

         void print() { cout << s << endl; }

         void change(const char *);  // Function to change

String::String(const char *str)

         size = strlen(str);

         s = new char[size+1];

         strcpy(s, str);

         delete [] s;

         String str1("Welcome");

         String str2 = str1; 

str1.print(); // what is printed ?

str2.print(); 

str2.change("Welcome you all"); 

str1.print(); // what is printed now ?

str2.print();

According to the C + + copy constructor it is possible to make a copy function Object() { [native code] }. When a copy function Object() { [native code] } in a class is made private, objects in that class become non-copyable. This is especially useful when the class contains pointers or resources that are dynamically allocated. In such cases, it can either write our own copy function Object() { [native code] }, as in the String example above, or create a private copy function Object() { [native code] }, in which case users will receive compiler errors rather than warnings.

According to C + + copy constructor, when an object is transferred by value, a copy function Object() { [native code] } is named. The copy function Object() { [native code] } is a function in and of itself. If an argument is passed by value in a copy function Object() { [native code] }, a call to copy function Object() { [native code] } is made to call copy function Object() { [native code] }, resulting in a non-terminating sequence of calls. As a result, the compiler won't let you move parameters by value.

Want a Top Software Development Job? Start Here!

According to C++ copy constructor, we pass an object by reference to the copy function Object() { [native code] }, and we usually pass it as a const reference. One justification for passing a const reference is that it can use const wherever possible in C++ to avoid unintentionally changing objects. This is one compelling excuse to transfer references as const, but there are others.

/* Class data members */

Test(Test &t) { /* Copy data members from t*/}

Test()  { /* Initialize data members */ }

     cout << "fun() Called\n";

     Test t;

     return t;

     Test t1;

     Test t2 = fun();

Need to change the copy constructor by the following:

Test(const Test &t) { cout << "Copy Constructor Called\n"; }

The fun() function returns a value. As a result, the compiler generates a temporary entity, which is then copied to t2 using the original program's copy function Object() { [native code] } (The temporary object is passed as an argument to the copy constructor). The compiler error occurs because compiler-created temporary objects cannot be bound to non-const references, despite the fact that the original program attempts to do so. It doesn't make sense to change something that isn't broken.

Advance your career as a MEAN stack developer with the  Full Stack Web Developer - MEAN Stack Master's Program . Enroll now!

According to C++ copy constructor, when an object is made, a function Object() { [native code] } is a special type of member function that is called automatically. A function Object() { [native code] } in C++ has the same name as the class it belongs to, and it does not have a return form.

In this article you learned about stack , implementation, operations with syntax and examples. To get expertise in C++ programming you can join Simplilearn’s C++ certification training course. For learners, Simplilearn has made a special selection of courses available for free. Join Simplilearn’s free courses and revolutionise your profession with certificates, specialisations, and dozens of other courses.

Have any questions for us? Leave them in the comments section of this article, and our experts will get back to you on them, as soon as possible!

Recommended Reads

Free eBook: Salesforce Developer Salary Report

All You Need to Know About Constructor in Java

A One-Stop Solution Guide to Understand Constructors in C#

Skills Acquisition Vs. Talent Acquisition

Copy File in Python

Operators in C#: An Ultimate C# Operations Guide With Examples

Get Affiliated Certifications with Live Class programs

Post graduate program in full stack web development.

• Live sessions on the latest AI trends, such as generative AI, prompt engineering, explainable AI, and more
• Caltech CTME Post Graduate Certificate

Full Stack Web Developer - MEAN Stack

• Comprehensive Blended Learning program
• 8X higher interaction in live online classes conducted by industry experts
• PMP, PMI, PMBOK, CAPM, PgMP, PfMP, ACP, PBA, RMP, SP, and OPM3 are registered marks of the Project Management Institute, Inc.

This browser is no longer supported.

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

C++ At Work

Copy Constructors, Assignment Operators, and More

Paul DiLascia

Code download available at: CAtWork0509.exe (276 KB) Browse the Code Online

Q I have a simple C++ problem. I want my copy constructor and assignment operator to do the same thing. Can you tell me the best way to accomplish this?

A At first glance this seems like a simple question with a simple answer: just write a copy constructor that calls operator=.

Or, alternatively, write a common copy method and call it from both your copy constructor and operator=, like so:

This code works fine for many classes, but there's more here than meets the eye. In particular, what happens if your class contains instances of other classes as members? To find out, I wrote the test program in Figure 1 . It has a main class, CMainClass, which contains an instance of another class, CMember. Both classes have a copy constructor and assignment operator, with the copy constructor for CMainClass calling operator= as in the first snippet. The code is sprinkled with printf statements to show which methods are called when. To exercise the constructors, cctest first creates an instance of CMainClass using the default ctor, then creates another instance using the copy constructor:

Figure 1 Copy Constructors and Assignment Operators

If you compile and run cctest, you'll see the following printf messages when cctest constructs obj2:

The member object m_obj got initialized twice! First by the default constructor, and again via assignment. Hey, what's going on?

In C++, assignment and copy construction are different because the copy constructor initializes uninitialized memory, whereas assignment starts with an existing initialized object. If your class contains instances of other classes as data members, the copy constructor must first construct these data members before it calls operator=. The result is that these members get initialized twice, as cctest shows. Got it? It's the same thing that happens with the default constructor when you initialize members using assignment instead of initializers. For example:

As opposed to:

Using assignment, m_obj is initialized twice; with the initializer syntax, only once. So, what's the solution to avoid extra initializations during copy construction? While it goes against your instinct to reuse code, this is one situation where it's best to implement your copy constructor and assignment operator separately, even if they do the same thing. Calling operator= from your copy constructor will certainly work, but it's not the most efficient implementation. My observation about initializers suggests a better way:

Now the main copy ctor calls the member object's copy ctor using an initializer, and m_obj is initialized just once by its copy ctor. In general, copy ctors should invoke the copy ctors of their members. Likewise for assignment. And, I may as well add, the same goes for base classes: your derived copy ctor and assignment operators should invoke the corresponding base class methods. Of course, there are always times when you may want to do something different because you know how your code works—but what I've described are the general rules, which are to be broken only when you have a compelling reason. If you have common tasks to perform after the basic objects have been initialized, you can put them in a common initialization method and call it from your constructors and operator=.

Q Can you tell me how to call a Visual C++® class from C#, and what syntax I need to use for this?

Sunil Peddi

Q I have an application that is written in both C# (the GUI) and in classic C++ (some business logic). Now I need to call from a DLL written in C++ a function (or a method) in a DLL written in Visual C++ .NET. This one calls another DLL written in C#. The Visual C++ .NET DLL acts like a proxy. Is this possible? I was able to use LoadLibrary to call a function present in the Visual C++ .NET DLL, and I can receive a return value, but when I try to pass some parameters to the function in the Visual C++ .NET DLL, I get the following error:

How can I resolve this problem?

Giuseppe Dattilo

A I get a lot of questions about interoperability between the Microsoft® .NET Framework and native C++, so I don't mind revisiting this well-covered topic yet again. There are two directions you can go: calling the Framework from C++ or calling C++ from the Framework. I won't go into COM interop here as that's a separate issue best saved for another day.

Let's start with the easiest one first: calling the Framework from C++. The simplest and easiest way to call the Framework from your C++ program is to use the Managed Extensions. These Microsoft-specific C++ language extensions are designed to make calling the Framework as easy as including a couple of files and then using the classes as if they were written in C++. Here's a very simple C++ program that calls the Framework's Console class:

To use the Managed Extensions, all you need to do is import <mscorlib.dll> and whatever .NET assemblies contain the classes you plan to use. Don't forget to compile with /clr:

Your C++ code can use managed classes more or less as if they were ordinary C++ classes. For example, you can create Framework objects with operator new, and access them using C++ pointer syntax, as shown in the following:

Here, the String s is declared as pointer-to-String because String::Format returns a new String object.

The "Hello, world" and date/time programs seem childishly simple—and they are—but just remember that however complex your program is, however many .NET assemblies and classes you use, the basic idea is the same: use <mscorlib.dll> and whatever other assemblies you need, then create managed objects with new, and use pointer syntax to access them.

So much for calling the Framework from C++. What about going the other way, calling C++ from the Framework? Here the road forks into two options, depending on whether you want to call extern C functions or C++ class member functions. Again, I'll take the simpler case first: calling C functions from .NET. The easiest thing to do here is use P/Invoke. With P/Invoke, you declare the external functions as static methods of a class, using the DllImport attribute to specify that the function lives in an external DLL. In C# it looks like this:

This tells the compiler that MessageBox is a function in user32.dll that takes an IntPtr (HWND), two Strings, and an int. You can then call it from your C# program like so:

Of course, you don't need P/Invoke for MessageBox since the .NET Framework already has a MessageBox class, but there are plenty of API functions that aren't supported directly by the Framework, and then you need P/Invoke. And, of course, you can use P/Invoke to call C functions in your own DLLs. I've used C# in the example, but P/Invoke works with any .NET-based language like Visual Basic® .NET or JScript®.NET. The names are the same, only the syntax is different.

Note that I used IntPtr to declare the HWND. I could have got away with int, but you should always use IntPtr for any kind of handle such as HWND, HANDLE, or HDC. IntPtr will default to 32 or 64 bits depending on the platform, so you never have to worry about the size of the handle.

DllImport has various modifiers you can use to specify details about the imported function. In this example, CharSet=CharSet.Auto tells the Framework to pass Strings as Unicode or Ansi, depending on the target operating system. Another little-known modifier you can use is CallingConvention. Recall that in C, there are different calling conventions, which are the rules that specify how the compiler should pass arguments and return values from one function to another across the stack. The default CallingConvention for DllImport is CallingConvention.Winapi. This is actually a pseudo-convention that uses the default convention for the target platform; for example, StdCall (in which the callee cleans the stack) on Windows® platforms and CDecl (in which the caller cleans the stack) on Windows CE .NET. CDecl is also used with varargs functions like printf.

The calling convention is where Giuseppe ran into trouble. C++ uses yet a third calling convention: thiscall. With this convention, the compiler uses the hardware register ECX to pass the "this" pointer to class member functions that don't have variable arguments. Without knowing the exact details of Giuseppe's program, it sounds from the error message that he's trying to call a C++ member function that expects thiscall from a C# program that's using StdCall—oops!

Aside from calling conventions, another interoperability issue when calling C++ methods from the Framework is linkage: C and C++ use different forms of linkage because C++ requires name-mangling to support function overloading. That's why you have to use extern "C" when you declare C functions in C++ programs: so the compiler won't mangle the name. In Windows, the entire windows.h file (now winuser.h) is enclosed in extern "C" brackets.

While there may be a way to call C++ member functions in a DLL directly using P/Invoke and DllImport with the exact mangled names and CallingConvention=ThisCall, it's not something to attempt if you're in your right mind. The proper way to call C++ classes from managed code—option number two—is to wrap your C++ classes in managed wrappers. Wrapping can be tedious if you have lots of classes, but it's really the only way to go. Say you have a C++ class CWidget and you want to wrap it so .NET clients can use it. The basic formula looks something like this:

The pattern is the same for any class. You write a managed (__gc) class that holds a pointer to the native class, you write a constructor and destructor that allocate and destroy the instance, and you write wrapper methods that call the corresponding native C++ member functions. You don't have to wrap all the member functions, only the ones you want to expose to the managed world.

Figure 2 shows a simple but concrete example in full detail. CPerson is a class that holds the name of a person, with member functions GetName and SetName to change the name. Figure 3 shows the managed wrapper for CPerson. In the example, I converted Get/SetName to a property, so .NET-based programmers can use the property syntax. In C#, using it looks like this:

Figure 3 Managed Person Class

Figure 2 Native CPerson Class

Using properties is purely a matter of style; I could equally well have exposed two methods, GetName and SetName, as in the native class. But properties feel more like .NET. The wrapper class is an assembly like any other, but one that links with the native DLL. This is one of the cool benefits of the Managed Extensions: You can link directly with native C/C++ code. If you download and compile the source for my CPerson example, you'll see that the makefile generates two separate DLLs: person.dll implements a normal native DLL and mperson.dll is the managed assembly that wraps it. There are also two test programs: testcpp.exe, a native C++ program that calls the native person.dll and testcs.exe, which is written in C# and calls the managed wrapper mperson.dll (which in turn calls the native person.dll).

Figure 4** Interop Highway **

I've used a very simple example to highlight the fact that there are fundamentally only a few main highways across the border between the managed and native worlds (see Figure 4 ). If your C++ classes are at all complex, the biggest interop problem you'll encounter is converting parameters between native and managed types, a process called marshaling. The Managed Extensions do an admirable job of making this as painless as possible (for example, automatically converting primitive types and Strings), but there are times where you have to know something about what you're doing.

For example, you can't pass the address of a managed object or subobject to a native function without pinning it first. That's because managed objects live in the managed heap, which the garbage collector is free to rearrange. If the garbage collector moves an object, it can update all the managed references to that object—but it knows nothing of raw native pointers that live outside the managed world. That's what __pin is for; it tells the garbage collector: don't move this object. For strings, the Framework has a special function PtrToStringChars that returns a pinned pointer to the native characters. (Incidentally, for those curious-minded souls, PtrToStringChars is the only function as of this date defined in <vcclr.h>. Figure 5 shows the code.) I used PtrToStringChars in MPerson to set the Name (see Figure 3 ).

Figure 5 PtrToStringChars

Pinning isn't the only interop problem you'll encounter. Other problems arise if you have to deal with arrays, references, structs, and callbacks, or access a subobject within an object. This is where some of the more advanced techniques come in, such as StructLayout, boxing, __value types, and so on. You also need special code to handle exceptions (native or managed) and callbacks/delegates. But don't let these interop details obscure the big picture. First decide which way you're calling (from managed to native or the other way around), and if you're calling from managed to native, whether to use P/Invoke or a wrapper.

In Visual Studio® 2005 (which some of you may already have as beta bits), the Managed Extensions have been renamed and upgraded to something called C++/CLI. Think of the C++/CLI as Managed Extensions Version 2, or What the Managed Extensions Should Have Been. The changes are mostly a matter of syntax, though there are some important semantic changes, too. In general C++/CLI is designed to highlight rather than blur the distinction between managed and native objects. Using pointer syntax for managed objects was a clever and elegant idea, but in the end perhaps a little too clever because it obscures important differences between managed and native objects. C++/CLI introduces the key notion of handles for managed objects, so instead of using C pointer syntax for managed objects, the CLI uses ^ (hat):

As you no doubt noticed, there's also a gcnew operator to clarify when you're allocating objects on the managed heap as opposed to the native one. This has the added benefit that gcnew doesn't collide with C++ new, which can be overloaded or even redefined as a macro. C++/CLI has many other cool features designed to make interoperability as straightforward and intuitive as possible.

Send your questions and comments for Paul to   [email protected] .

Paul DiLascia is a freelance software consultant and Web/UI designer-at-large. He is the author of Windows ++: Writing Reusable Windows Code in C ++ (Addison-Wesley, 1992). In his spare time, Paul develops PixieLib, an MFC class library available from his Web site, www.dilascia.com .

Additional resources

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

• Interview Q

C++ Tutorial

C++ control statement, c++ functions, c++ pointers, c++ object class, c++ inheritance, c++ polymorphism, c++ abstraction, c++ namespaces, c++ strings, c++ exceptions, c++ templates, signal handling, c++ file & stream, c++ stl tutorial, c++ iterators, c++ programs, interview question.

The object-oriented programming idea is supported by the general-purpose, middle-level, case-sensitive, platform agnostic computer language C++. Bjarne Stroustrup developed the C++ programming language in 1979 at Bell Laboratories. Since C++ is a platform-independent programming language, it may be used on a wide range of operating systems, including Windows, Mac OS, and different UNIX versions. Assignment operators are used to assign values to variables from the aforementioned groups. Let's first study a little bit about constructors before moving on to copy constructors. When an object is formed, a specific method called a constructor-which has the same name as the class name with the parentheses "()"-is automatically called. Initializing the variables of a freshly generated object is done using the constructor. A copy constructor is a form of constructor that uses an already-created object from the same class to initialize a new object. Let's now go over the specifics of the notion and contrast and compare the features of the assignment operator and copy constructor. The assignment operator is used to give a variable a value. The assignment operator has a variable name as its left operand and a value to that variable as its right operand. A compilation error will be triggered if neither operand's datatype matches the other. Assignment operators come in various forms. : = operator Only the value is given to the variable. For instance, if "a=10," variable "a" will be given the value of 10. The += operator first multiplies the variable's current value by the value on the right side before assigning the new value. The operator "-=" first subtracts the variable's current value from the value on the right side before appending the new value. In order to assign a new value to a variable, the *= operator first multiplies the variable's current value by the value on the right side. The operator /= first divides the variable's current value by the value on the right side before assigning the new value to the variable. Below is an illustration of an assignment operator. The assignment operator is being used in this case to give values to several variables. The two variables "a" and "b" were used in the example above, and we first set the value of "a" to 5 using the assignment operator "=". And we've given variable b the value of the a variable. The output from the aforementioned code is shown below. Programmers frequently need to do this in order to duplicate an object without affecting the original. The copy constructor is used in these circumstances. The copy constructor produces an object by initializing it with a different object of the same class that has already been constructed. The copy constructor comes in two varieties. The default copy constructor is created by the C++ compiler when the copy constructor is not declared, and it copies all member variables exactly as they are. User-Defined Copy Constructor: This term refers to a copy constructor that has been defined by the user. The syntax for Copy Constructor is - All of these C++ concepts' primary functions are to assign values, but the key distinction between them is that while the copy constructor produces a new object and assigns the value, the assignment operator assigns the value to the data member of the same object rather than to a new object. The key distinctions between assignment operator and copy constructor are shown in the following table. Copy constructor Assignment operator An example of an overloaded constructor is the copy constructor. A new object is initialized by an existing object of the same type using the copy constructor. An operator that assigns a value to objects or data members is known as an assignment operator. It transfers an object's value from one produced object to another. When an old object is used to initialize a new one, as well as when the object is supplied to a function as a non-reference parameter, the copy constructor is called. When an old object's value is transferred to a new object, the assignment operator is used. The newly invoked object will share distinct memory addresses with the previously generated object. The first object and the second object, to whom the first object's value is assigned, share the same memory addresses. Send your Feedback to [email protected] Help Others, Please Share Learn Latest Tutorials Transact-SQL Reinforcement Learning R Programming React Native Python Design Patterns Python Pillow Python Turtle Preparation Verbal Ability Interview Questions Company Questions Trending Technologies Artificial Intelligence Cloud Computing Data Science Machine Learning B.Tech / MCA Data Structures Operating System Computer Network Compiler Design Computer Organization Discrete Mathematics Ethical Hacking Computer Graphics Software Engineering Web Technology Cyber Security C Programming Control System Data Mining Data Warehouse 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 Copy Constructor in C++ A copy constructor is a type of constructor 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 .   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. Syntax of Copy Constructor in C++ Copy constructor takes a reference to an object of the same class as an argument: Here, the const qualifier is optional but is added so that we do not modify the obj by mistake. Syntax of Copy Constructor Examples of Copy Constructor in C++ Example 1: user defined copy constructor. If the programmer does not define the copy constructor, the compiler does it for us. Example 2: 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. Need of User Defined Copy Constructor If we don’t define our own copy constructor, the C++ compiler creates a default copy constructor for each class which works fine in general. However, 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 because the default constructor does only shallow copy. Shallow Copy means that only the pointers will be copied not the actual resources that the pointers are pointing to. This can lead to dangling pointers if the original object is deleted. 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 copy of the dynamic resource allocated manually in the copy constructor using new operators. 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.  Note: Such classes also need the overloaded assignment operator. See this article for more info – C++ Assignment Operator Overloading 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 c hanges made to str2 reflect in str1 as well which is never expected. Also, if the str1 is destroyed, the str2’s data member s will be pointing to the deallocated memory. 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). Refer to this article for more details – When is a Copy Constructor Called in C++? Copy Elision In copy elision, the compiler prevents the making of extra copies by making the use to techniques such as NRVO and RVO which results in saving space and better the program complexity (both time and space); Hence making the code more optimized. 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. Frequently Asked Questions in C++ Copy Constructors 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?   If you pass the object by value in the copy constructor, it will 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 recursion. Using a reference avoids this recursion. So, we use reference of objects to avoid infinite calls. 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?’ Related Articles: Constructors in C++ Please Login to comment... Similar reads. cpp-constructor Improve your Coding Skills with Practice What kind of Experience do you want to share? Get the Reddit app a subreddit for c++ questions and answers Confusion on Copy Constructor and Copy Assignment Operator So i've been refreshing on C++ and I am going through Kate Gregory's pluralsight C++17 course (fantastic by the way) and I pretty much understood everything that was going on up until here: (best screenshot I could take) https://imgur.com/a/FhzdKnC This specific video was on the "rule of 3" and shallow copies. Ignore basically everything else on the person object besides this generic "resource" pointer pResource. My confusion comes in where she creates the Copy Constructor and Copy Assignment operator (2nd image). From my understanding when we copy an object that has dynamically allocated pointers, unless we have a copy constructor C++ just sort of does a shallow copy (Which im not 100% sure what exactly that means) but from my understanding it's using the same pointer to point at a different memory location? Thereby losing the pointer to the first memory location making a memory leak (Since we can no longer follow the pointer to get back to it). Someone please correct me if Im wrong. Regardless im not exactly sure what is going on with the functions: - For the Copy Constructor it seems like it's taking the object being copied by reference (Since it's an object we don't want a "by value" copy I assume as that's expensive) and then follow that objects pointer via pResource (Which I don't understand...because the pointer is just a member value.....so it's following the pointer to the actual object itself?) But regardless it's follow the "copied" objects pointer to actually grab the name. I have no idea "Why" though. - The Copy Assignment Operator is even more confusing for me. Why do we delete the resource here but not the Copy constructor? And then we are returning a pointer to the original object we are copying? or the new one? (Assuming *this is what that is) Any help? It's tough because she didn't really show what "Resource.cpp" was.....but I imagine it's just another object. By continuing, you agree to our User Agreement and acknowledge that you understand the Privacy Policy . Enter the 6-digit code from your authenticator app You’ve set up two-factor authentication for this account. Enter a 6-digit backup code Create your username and password. Reddit is anonymous, so your username is what you’ll go by here. Choose wisely—because once you get a name, you can’t change it. Reset your password Enter your email address or username and we’ll send you a link to reset your password Check your inbox An email with a link to reset your password was sent to the email address associated with your account Choose a Reddit account to continue cppreference.com Std:: inplace_vector. (C++20) (C++20) (C++11) (C++20) (C++17) (C++11) (C++11) Tables inplace_vector::cbegin inplace_vector::cend inplace_vector::crbegin inplace_vector::crend erase_if(std::inplace_vector) (C++26) operator<=> (C++26) <     class T,     N > struct inplace_vector; (since C++26) inplace_vector is a dynamically-resizable array with contiguous inplace storage (that is, the elements of type T are stored and properly aligned within the object itself) and with fixed at compile-time capacity N . inplace_vector is useful in environments where dynamic memory allocations are undesired. The inplace_vector satisfies the requirements of Container , ReversibleContainer , ContiguousContainer , and of a SequenceContainer , including most of the optional sequence container requirements , except that the push_front , prepend_range , pop_front , and emplace_front member functions are not provided. For any N , std :: inplace_vector < T, N > :: iterator and std :: inplace_vector < T, N > :: const_iterator meet the constexpr iterator requirements. For any N > 0 , if std:: is_trivial_v < T > is false , then no std :: inplace_vector < T, N > member functions are usable in constant expressions. Any member function of inplace_vector < T, N > that would cause the size to exceed N throws an exception of type std::bad_alloc . Let V denote a specialization of inplace_vector < T, N > . If N is zero, then V is both trivial and empty. Otherwise: If std:: is_trivially_copy_constructible_v < T > is true , then V has a trivial copy constructor . If std:: is_trivially_move_constructible_v < T > is true , then V has a trivial move constructor . If std:: is_trivially_copy_constructible_v < T > && std:: is_trivially_copy_assignable_v < T > is true , then V has a trivial copy assignment operator . If std:: is_trivially_move_constructible_v < T > && std:: is_trivially_move_assignable_v < T > is true , then V has a trivial move assignment operator . Iterator invalidation Template parameters Member types Member functions Element access Iterators Size and capacity Modifiers Non-member functions Notes Example See also External links [ edit ] Iterator invalidation

This section is incomplete

[ edit ] Template parameters

This section is incomplete
Reason: Complete the descriptions of template parameters.

[ edit ] Member types

Member type	Definition
	value_type&
	const value_type&
	value_type*
	const value_type*
	implementation-defined and to
	implementation-defined and to const value_type
	<iterator>
	<const_iterator>

[ edit ] Member functions

	constructs the (public member function)
	destructs the (public member function)
	assigns values to the container (public member function)
	assigns values to the container (public member function)
	assigns a range of values to the container (public member function)
	access specified element with bounds checking (public member function)
	access specified element (public member function)
	access the first element (public member function)
	access the last element (public member function)
	direct access to the underlying contiguous storage (public member function)
cbegin	returns an iterator to the beginning (public member function)
cend	returns an iterator to the end (public member function)
crbegin	returns a reverse iterator to the beginning (public member function)
crend	returns a reverse iterator to the end (public member function)
	checks whether the container is empty (public member function)
	returns the number of elements (public member function)
	returns the maximum possible number of elements (public static member function)
	returns the number of elements that can be held in currently allocated storage (public static member function)
	changes the number of elements stored (public member function)
	reserves storage (public static member function)
	reduces memory usage by freeing unused memory (public static member function)
	inserts elements (public member function)
	inserts a range of elements (public member function)
	constructs element in-place (public member function)
	constructs an element in-place at the end (public member function)
	tries to construct an element in-place at the end (public member function)
	unconditionally constructs an element in-place at the end (public member function)
	adds an element to the end (public member function)
	tries to add an element to the end (public member function)
	unconditionally adds an element to the end (public member function)
	removes the last element (public member function)
	adds a range of elements to the end (public member function)
	tries to add a range of elements to the end (public member function)
	changes the number of elements stored (public member function)
	clears the contents (public member function)
	erases elements (public member function)
	swaps the contents (public member function)

[ edit ] Non-member functions

	specializes the algorithm (function template)
erase_if(std::inplace_vector)	erases all elements satisfying specific criteria (function template)
operator<=>	lexicographically compares the values of two s (function template)

[ edit ] Notes

macro	Value	Std	Feature
	202406L	(C++26)	: dynamically-resizable vector with fixed capacity inplace storage

[ edit ] Example

[ edit ] see also.

	dynamic contiguous array (class template)
	fixed-sized inplace contiguous array (class template)
	double-ended queue (class template)

[ edit ] External links

	— A reference implementation of ( ).
	— Boost.Container implements inplace vector as a standalone type with its own guarantees.
	— EASTL implements inplace vector via an extra template parameter.
	— Folly also implements inplace vector via an extra template parameter.
	— Howard Hinnant's Custom allocators that emulate on top of .

• Todo without reason
• Todo with reason
• 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 10 August 2024, at 21:28.
• Privacy policy
• About cppreference.com
• Disclaimers

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

Which to use: move assignment operator vs copy assignment operator

I don't seem to get why would you use the move assignment operator :

over, the copy assignment operator :

The move assignment operator takes an r-value reference only e.g.

In the copy assignment operator , other can be constructor using a copy constructor or a move constructor (if other is initialized with an rvalue, it could be move-constructed --if move-constructor defined--).

If it is copy-constructed , we will be doing 1 copy and that copy can't be avoided.

If it is move-constructed then the performance/behavior is identical to the one produced by the first overload.

My questions are:

1- Why would one want to implement the move assignment operator .

2- If other is constructed from an r-value then which assignment operator would the compiler choose to call? And why?

• overload-resolution

• 1) less work, 2) it'd be ambiguous. –  Kerrek SB Commented Nov 6, 2014 at 5:20
• So you are saying for 2) the first overload will be called? –  Kam Commented Nov 6, 2014 at 5:24
• CLASSA & operator=(CLASSA && other); is a move assignment operator . Not sure how that changes what you are asking about. A copy assignment operator takes either a CLASSA or a const CLASSA& . –  Radiodef Commented Nov 6, 2014 at 5:25
• @Kam: No. An ambiguous overload means that overload resolution fails when you try to use the overload, which in turn makes the program ill formed. –  Kerrek SB Commented Nov 6, 2014 at 5:27
• The performance/behaviour will not be identical. There will be probably be one less move if you pass by r-value reference. Whether that matters will depend on how expensive it is to move CLASSA . –  Chris Drew Commented Nov 6, 2014 at 5:43

2 Answers 2

You are not comparing like-with-like

If you are writing a move-only type like std::unique_ptr then a move assignment operator would be your only choice.

The more typical case is where you have a copyable type in which case I think you have three options.

• T& operator=(T const&)
• T& operator=(T const&) and T& operator=(T&&)
• T& operator=(T) and move

Note that having both the overloads you suggested in one class is not an option as it would be ambiguous.

Option 1 is the traditional C++98 option and will perform fine in most cases. However, if you need to optimize for r-values you could consider Option 2 and add a move assignment operator.

It is tempting to consider Option 3 and pass-by-value and then move which I think is what you are suggesting. In that case you only have to write one assignment operator. It accepts l-values and at the cost of only one extra move accepts r-values and many people will advocate this approach.

However, Herb Sutter pointed out in his "Back to the Basics! Essentials of Modern C++ Style" talk at CppCon 2014 that this option is problematic and can be much slower. In the case of l-values it will perform an unconditional copy and will not reuse any existing capacity. He provides numbers to backup his claims. The only exception is constructors where there is no existing capacity to reuse and you often have many parameters so pass by-value can reduce the number of overloads needed.

So I would suggest you start with Option 1 and move to Option 2 if you need to optimize for r-values.

Clearly, the two overloads are not equivalent:

• The assignment operator taking an rvalue reference only works with rvalues are on the right-hand side of the expression. To also support lvalues, another overload, e.g., using T const& would be needed for copyable types. Of course, for move-only types, like std::unique_ptr<T> , defining this assignment operator is the appropriate choice.
• The assignment operator taking a value covers both rvalue and lvalue assignments assuming the type in question is both copy- and move-constructible. Its canonical implementation is to call swap() to replace the object's state with the state from the right-hand side. It has the advantage that the copy/move construction of the argument can often be elided.

In any case, you wouldn't want to have both overloads in one class! When assigning from an lvalue, obviously, the version taking a value would be chosen (the other option isn't viable). However, both assignment operators are viable when assigning an rvalue, i.e., there would be an ambiguity. This can easily be verified by trying to compile this code:

To deal with a move- and copy construction separately you could define a pair of assignment operators using T&& and T const& as arguments. However, this results in having to implement two versions of essentially the same copy assignment while having just a T as argument requires just one copy assignment to be implemented.

Thus, there are two obvious choices:

• For a move-only type you'd define T::operator= (T&&) .
• For a copyable type you'd define T::operator=(T) .

• 2 Herb sutter points out that using pass by-value in this way can be much slower than pass by reference-to-const due to making an unconditional copy and not reusing existing capacity. –  Chris Drew Commented Nov 6, 2014 at 7:20

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 overload-resolution or ask your own question .

• The Overflow Blog
• How we’re making Stack Overflow more accessible
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Introducing an accessibility dashboard and some upcoming changes to display...
• Tag hover experiment wrap-up and next steps

Hot Network Questions

• Counting them 100 years later
• Can I continue using technology after it is patented
• What counts as a pet?
• Flow Decision Passing when it should fail
• Why don't programming languages or IDEs support attaching descriptive metadata to variables?
• How can electrons hop large distances if they are connected to the atom which is stationary in an lattice?
• Possible bug in DateList, DateObject etc returning negative years in 14.1
• What is the meaning of 'in the note'?
• How can the Word be God and be with God simultaneously without creating the meaning of two Gods?
• Can light be somehow confined to create a kugelblitz?
• Flashlight and 6 batteries
• If pressure is caused by the weight of water above you, why is pressure said to act in all direction, not just down?
• How do I use "batcat" to colorize the output of the "--help" and "-h" options of commands?
• Direct limits in homotopy category
• Do radios need a minimum range to function properly?
• Why did Borland ignore the Macintosh market?
• When can a citizen's arrest of an Interpol fugitive be legal in Washington D.C.?
• What does "contradictions trivialize truth" mean?
• Can the Bible be the word of God, when there are multiple versions of it?
• In Norway, when number ranges are listed 3 times on a sign, what do they mean?
• Sums of exponentials joint probability
• BMX Logo and bike type please
• Design for this automated menu-building method in GUI
• Refereeing papers by people you are very close to