assignment operator and constructor

• Trending Categories

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

Difference Between Copy Constructor and Assignment Operator in C++

C++ is a General purpose, middle-level, case sensitive, platform independent programming language that supports object oriented programming concept. C++ was created by Bjarne Stroustrup at Bell Labs in 1979. Since C++ is a platform independent programming language, it can be used on a variety of systems, including Windows, Mac OS, and various UNIX versions.

Operators in C++ are used to perform specific operations on values and variables. The following are the list of operators used in C++

Arithmetic operators

Assignment operators

Comparison operators

Relational Operators

Logical operators

Bitwise operators

Unary operators

Ternary/Conditional operators.

From the above groups, Assignment operators are used to assign values to variables.

Before learning about copy constructors, let’s get a brief idea about constructors. A Constructor in C++ is a special method, same name as class name with parenthesis "( )", that is automatically invoked when an object is created. Constructor is used to initialize the variables of the object which is created newly.

A Copy Constructor is a type of constructor that uses another object from the same class which has been created previously, to initialize an object.

Now let’s go through the detailed concept and compare and contrast the various features of copy constructor and assignment operator.

What is Assignment operator

The use of Assignment operator is to assign a value to a variable. The left operand of the assignment operator is variable name and the right operand of the operator is value to that variable. The datatype must be same for both the operands, if not so a compilation error will be raised.

The types of assignment operators are

= operator − It only assigns the value to the variable. For example, "a=10", here the value 10 will be assigned to variable "a".

+= operator −This operator first adds the current value of the variable by the value which is on right side and then assigns the new value to variable.

–= operator − This operator first subtracts the current value of the variable by the value which is on right side and then assigns the new value to variable.

*= operator − This operator first multiplies the current value of the variable by the value which is on right side and then assigns the new value to variable.

/= operator − This operator first divides the current value of the variable by the value which is on right side and then assigns the new value to variable.

Example on Assignment Operator

Let’s see an example of assignment operator. Here we are using the assignment operator to assign values to different variables.

In the above example, we have taken two variables "a" and "b" and at first we have assigned the value of a to 5 through assignment operator "=". And we have assigned the value of a to variable b. The above code will result the output as given below.

What is a Copy Constructor?

This is often required in programming to make a separate copy of an object without impacting the original. In these cases, the copy constructor comes in use. The copy constructor is a constructor that creates an object by initializing it using a previously created object of the same class. There are two types of copy constructor.

Default Copy Constructor − When the copy Constructor is not declared, the C++ compiler creates a default Constructor that copies all member variables as they are.

User-Defined Copy Constructor − The copy constructor defined by the user is called user defined copy constructor.

The syntax for Copy Constructor is −

Copy Constructor - Example

The copy constructor is used to initialize one object from another object of the same class, to copy an object to pass as an argument to a function, and to copy an object to pass as a parameter to a function. To return an object from a function, copy the object.

Let’s see an example to understand how exactly we can use a copy constructor.

In the above example, we have taken the class name as Example, and created a constructor and passed the value 20 and 30 to the constructor. The statement Example (Example &ex) indicates the copy constructor. It copies the value of the data members previously created.

The above code will produce the following output −

In our example, we have created two objects obj1 and obj2 and we are assigning the value of obj1 to obj2.

Comparison between Copy Constructor and Assignment Operator

The main purpose of both the concepts in C++ is to assign the value, but the main difference between both is copy constructor creates a new object and assigns the value but assignment operator does not create a new object, instead it assigns the value to the data member of the same object.

The following table highlights the major differences between copy constructor and assignment operator.

The difference between a copy constructor and an assignment operator is that a copy constructor helps to create a copy of an already existing object without altering the original value of the created object, whereas an assignment operator helps to assign a new value to a data member or an object in the program.

• Related Articles
• What's the difference between assignment operator and copy constructor in C++?
• Copy constructor vs assignment operator in C++
• Difference between Static Constructor and Instance Constructor in C#
• What is the difference between new operator and object() constructor in JavaScript?
• Virtual Copy Constructor in C++
• Difference between "new operator" and "operator new" in C++?
• How to use an assignment operator in C#?
• Difference Between Constructor and Destructor
• When is copy constructor called in C++?
• What is a copy constructor in C#?
• What is the difference between initialization and assignment of values in C#?
• Difference between constructor and method in Java
• What is the difference between = and: = assignment operators?
• Why do we need a copy constructor and when should we use a copy constructor in Java?
• Difference between == and === operator in JavaScript

Kickstart Your Career

Get certified by completing the course

14.14 — Introduction to the copy constructor

• 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

cppreference.com

Copy assignment operator.

A copy assignment operator is a non-template non-static member function with the name operator = that can be called with an argument of the same class type and copies the content of the argument without mutating the argument.

[ edit ] Syntax

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

[ edit ] 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.

[ edit ] Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type, 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 & ) .

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.

[ 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 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, the operator performs member-wise copy assignment of the object's direct bases and non-static data members, in their initialization order, using built-in assignment for the scalars, memberwise copy-assignment for arrays, and copy assignment operator for class types (called non-virtually).

[ edit ] Deleted copy assignment operator

An implicitly-declared or explicitly-defaulted (since C++11) copy assignment operator for class T is undefined (until C++11) defined as deleted (since C++11) if any of the following conditions is satisfied:

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

[ 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);
• 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 ] Eligible copy assignment operator

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

[ edit ] Notes

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

It is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined 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.

[ edit ] See also

• 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
• 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 2 February 2024, at 16:13.
• Privacy policy
• About cppreference.com
• Disclaimers

This browser is no longer supported.

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

Move Constructors and Move Assignment Operators (C++)

• 9 contributors

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

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

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

To create a move constructor for a C++ class

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

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

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

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

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

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

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

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

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

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

Example: Complete move constructor and assignment operator

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

Example Use move semantics to improve performance

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

This example produces the following output:

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

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

Robust Programming

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

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

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

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

Rvalue Reference Declarator: && std::move

Was this page helpful?

Additional resources

• C++ Data Types
• C++ Input/Output
• C++ Pointers
• C++ Interview Questions
• C++ Programs
• C++ Cheatsheet
• C++ Projects
• C++ Exception Handling
• C++ Memory Management

C++ Assignment Operator Overloading

Prerequisite: Operator Overloading

The assignment operator,”=”, is the operator used for Assignment. It copies the right value into the left value. Assignment Operators are predefined to operate only on built-in Data types.

• Assignment operator overloading is binary operator overloading.
• Overloading assignment operator in C++ copies all values of one object to another object.
• Only a non-static member function should be used to overload the assignment operator.

In C++, the compiler automatically provides a default assignment operator for classes. This operator performs a shallow copy of each member of the class from one object to another. This means that if we don’t explicitly overload the assignment operator, the compiler will still allow us to assign one object to another using the assignment operator ( = ), and it won’t generate an error.

So, when we should perform assignment operator overloading? when our class involves dynamic memory allocation (e.g., pointers) and we need to perform a deep copy to prevent issues like double deletion or data corruption.

here, a and b are of type integer, which is a built-in data type. Assignment Operator can be used directly on built-in data types.

c1 and c2 are variables of type “class C”.

The above example can be done by implementing methods or functions inside the class, but we choose operator overloading instead. The reason for this is, operator overloading gives the functionality to use the operator directly which makes code easy to understand, and even code size decreases because of it. Also, operator overloading does not affect the normal working of the operator but provides extra functionality to it.

Now, if the user wants to use the assignment operator “=” to assign the value of the class variable to another class variable then the user has to redefine the meaning of the assignment operator “=”.  Redefining the meaning of operators really does not change their original meaning, instead, they have been given additional meaning along with their existing ones.

Also, always check if the object is not being assigned to itself (e.g., if (this != &other)), as assigning an object to itself does not make sense and may cause runtime issues.

While managing dynamic resources, the above approach of assignment overloading have few flaws and there is more efficient approach that is recommended. See this article for more info – Copy-and-Swap Idiom in C++

Similar Reads

• cpp-operator
• cpp-operator-overloading

Please Login to comment...

• Best Smartwatches in 2024: Top Picks for Every Need
• Top Budgeting Apps in 2024
• 10 Best Parental Control App in 2024
• Top Language Learning Apps in 2024
• GeeksforGeeks Practice - Leading Online Coding Platform

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Front-end education for the real world. Since 2018.

— From set.studio

• Switch to Dark Theme

A guide to destructuring in JavaScript

Published: 25 September 2024

Written by: Mat “Wilto” Marquis

If you’ve spent plenty of time wading through modern JavaScript, odds are you’ve seen enough ellipses ( ... ) to put even the most brooding 90s role-playing game protagonist to shame. I wouldn’t fault you for finding them a little confusing. Granted, I wouldn’t fault you for finding anything about JavaScript confusing, but I’ve always thought those ellipses were uniquely unintuitive at a glance. It doesn’t help that you’ll frequently encounter these little weirdos in the context of “destructuring assignment,” which is a strange syntax in and of itself.

A destructuring assignment allows you to extract individual values from an array or object and assign them to a set of identifiers without needing to access the values of each element the old-fashioned way—one at a time, by index or key like this:

In its simplest form — called “binding pattern destructuring” — each value is unpacked from the array or object literal and assigned to a corresponding identifier, all of which are initialized with a single let or const (or var , I suppose, if you’re feeling nostalgic for function-scoping).

The assigned value is the array or object literal to be destructured. When working with an array the identifiers are wrapped in a pair of brackets, and each identifier you define within those brackets will correspond to the same index in the source array:

Elements can be skipped over by using a comma but leaving out the identifier, the way you’d leave out a value when creating a sparse array :

You’ll sometimes see destructuring referred to as “unpacking” a data structure, but despite how that might sound, keep in mind that destructuring doesn’t modify the original array or object:

Destructuring: not just for arrays permalink

Now, you’re not often going to create a data structure and then immediately assign the values of the elements it contains to a bunch of identifiers like this, but now and then you are going to have to grab the contents of a data structure put together elsewhere in a script in order to use or manipulate those values. For example, say an API provided you with an object literal containing information about an image that you want to use to construct an img element:

Pulling this object apart isn’t the most onerous task in all of web development, sure, but it feels a little clunky doing it one line at a time:

You can destructure objects just like you can destructure an array, with a few differences in syntax. First, the identifiers are wrapped in a pair of curly braces rather than brackets. Second, the identifiers are populated with the values of the corresponding object keys, regardless of the order in which they’re specified:

And just like assigning these values to identifiers using dot notation , you can set default values that will be assigned if a property isn’t present at all, or it contains an explicit undefined value:

We can make this even more concise. We don’t have to unpack the nested size object separately; we can unpack it at the same time.

Which leaves us with this updated code:

All told, the destructuring assignment provides you with a quick and convenient way to break down complex data structures, but it definitely isn’t the most approachable syntax for how dense it is.

So where does the ellipsis come in? permalink

Well, in the context of a destructuring assignment, an ellipsis followed by an identifier represents a “rest property” — an identifier that will contain the rest of the array or object being unpacked as a new array or object. This rest property will contain all the remaining elements beyond the ones we’ve explicitly unpacked to their own identifiers, all bundled up in the same kind of data structure as the one we unpacked:

Another example:

Like the destructuring assignment itself, rest properties probably don’t seem all that useful in a vacuum like this — again, we’re pulling apart a simple data structure that we only just put together. Where it becomes really useful is working with large data structures that you don’t necessarily control.

For example, say you were working with the output of a static site generator for a single page:

This object addresses two concerns, all mingled together: there’s meta information about the post — the path the file that generated the post, the path where the generated post will live, an ID for the post, the tags associated with the post — and the content that makes up the post itself. Odds are, we’ll need all of this information, but accessing each property as-needed would be repetitive so we’ll use destructuring syntax to grab the meta information we need and retain all the rest of the properties — the post content itself — as a new object:

One line! No need to grab each property value and assign it to an identifier independently, no need to continually access a big unwieldy object throughout a script, and all the properties that make up the post itself bundled up in a tidy new object. Minimal fuss and hardly any muss.

The rest and spread operators permalink

You’ll most frequently run into the rest operator ( ... ) in a destructuring assignment, but like an indecisive text-messager, JavaScript is going to present you with ellipses in a few unexpected places. Those uses all have something in common with the one you’ve come to know from destructuring: they’re all concerned with aggregating data into, or spreading data out from, a data structure.

In front of the identifier for a function parameter, an ellipsis performs the same function as it does when performing destructuring assignment: as a “rest operator,” it bundles up all the rest of the arguments passed to this function as an iterable data structure — an array — and assign it the identifier that follows the ellipsis. This allows you to create “ varidic functions ,” a sure-to-impress term that really just means “a function that can accept any number of arguments.”

The last place you’ll run into an ellipsis (apart from especially emotionally-charged comments, that is) is something altogether different. In contexts where array elements or a function’s arguments are expected, that same ellipsis will take on an entirely different name and use: the “spread operator” ( ... ), which expands an iterable data structure—an array, an object literal, or even a string — into its individual elements.

The most common uses of the spread operator are copying and combining arrays:

Now, again, remember that spread syntax applies only where arguments in a function call or elements of an array are expected. As you saw in the example above, an array pretty predictably accepts elements from an array. Less predictably, so does an object literal:

It’s a safe bet that you’ll never find yourself in a situation where you need to spread the contents of a data structure into… well, nothing. If you were to try, say, for the sake of an example in a blog post about JavaScript’s many ellipses:

No dice. But if I’d used that same syntax inside of a console.log , then I’d be using the spread operator in the context of an argument to the console.log method, so it does work:

Object Spread

Using a spread operator with object literals is a more recent addition to JavaScript: while the spread operator itself was added in 2015’s ES6 , it only applies to object literals as of ES2018 . The spread operator creates “shallow” copies of an object. That is, it will spread a value’s “ own properties ” — that is, any enumerable properties not inherited by way of the prototype chain — into a new object.

This is an unbelievably useful syntax, allowing you to copy and merge objects with just a few characters.

A few things to keep in mind: when merging arrays that contain duplicate keys, the values associated with those keys will be overwritten:

Also, because an object isn’t iterable in the same way an array or string is, the context for object spread isn’t quite the same — while arrays and strings can be spread into an object, an array, or across a function’s arguments, an object can only be spread into another object:

Bringing it all together

Once you’ve got the hang of all these syntaxes, it isn’t hard to see how a script file might end up with more ellipses than a LiveJournal post circa 2005.

Let’s revisit both of our closer-to-reality examples, for both destructuring and spread syntax: an object containing information about an image we want to render, and an object containing a bunch of information about a single blog post.

We could work with these objects the way they are, right out of the box, but that’s a lot to wade through. Instead, we’ll use destructuring syntax to break down the postData object into two separate concerns, the way we did earlier: the post’s meta information, and the body of the post that we’ll use to populate the rendered page.

Now, let’s use use object spread to combine the newly-created postContent object with the object containing information about our image, but with one addition: since we’ll be putting this image up at the top of the page and we don’t want to run afoul of any issues with Largest Contentful Paint , we may want to render this with an explicit loading="eager" attribute — we’ll add that to the object representing the image data as well.

And in the end, we’re left with an object that contains only the properties we need, including a quick addition of our own — one-stop shopping for all our blog-post-rendering needs:

It’s much easier to work with than line-after-line of dot notation and plucking properties one-by-one out of whatever disorganized objects have been foisted upon us. And the downsides, you ask? I mean… I guess our code might end up reading a little more… well… nah, nevermind…

Get new articles in your inbox

Loading, please wait…

Powered by Buttondown . - Privacy policy

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

Why does the = operator work on structs without having been defined?

Let's look at a simple example:

Then abc_copy is an exact copy of abc .. how is it possible without defining the = operator ?

(This took me by surprise when working on some code..)

7 Answers 7

If you do not define these four methods (six in C++11) the compiler will generate them for you:

• Default Constructor
• Copy Constructor

Assignment Operator

• Move Constructor (C++11)
• Move Assignment (C++11)

If you want to know why? It is to maintain backward compatibility with C (because C structs are copyable using = and in declaration). But it also makes writing simple classes easier. Some would argue that it adds problems because of the "shallow copy problem". My argument against that is that you should not have a class with owned RAW pointers in it. By using the appropriate smart pointers that problem goes away.

Default Constructor (If no other constructors are defined)

The compiler generated default constructor will call the base classes default constructor and then each members default constructor (in the order they are declared)

Destructor (If no destructor defined)

Calls the destructor of each member in reverse order of declaration. Then calls the destructor of the base class.

Copy Constructor (If no copy constructor is defined)

Calls the base class copy constructor passing the src object. Then calls the copy constructor of each member using the src objects members as the value to be copied.

Calls the base class assignment operator passing the src object. Then calls the assignment operator on each member using the src object as the value to be copied.

Move Constructor (If no move constructor is defined)

Calls the base class move constructor passing the src object. Then calls the move constructor of each member using the src objects members as the value to be moved.

Move Assignment Operator

Calls the base class move assignment operator passing the src object. Then calls the move assignment operator on each member using the src object as the value to be copied.

If you define a class like this:

What the compiler will build is:

• This is an insanely good answer already, but I would love to see an example using the smart pointers. I've never been amazing at auto_ptr –  Hamy Commented Apr 17, 2013 at 6:17
• @Hamy: This is the information you need to build the smart pointer. If you are using smart pointers then you don't actually need to worry about this. You only need to worry about the above if you have RAW owned pointers in your class. –  Loki Astari Commented Apr 17, 2013 at 15:07
• 1 This answer confuses the types of initialization . With no initializer, the struct will be default initialized : its POD-typed members will assume indeterminate values. With an empty initializer, the struct will be value initialized : its POD-typed members will be zero initialized . –  Matt Whitlock Commented Jan 2, 2017 at 19:07

In C++, structs are equivalent to classes where members default to public rather than private access.

C++ compilers will also generate the following special members of a class automatically if they are not provided:

• Default constructor - no arguments, default initalizes everything.
• Copy constructor - ie a method with the same name as the class, that takes a reference to another object of the same class. Copies all values across.
• Destructor - Called when the object is destroyed. By default does nothing.
• Assignment operator - Called when one struct/class is assigned to another. This is the automatically generated method that's being called in the above case.

• 3 An implicit default constructor is also not provided if there is any user-defined constructor. –  sellibitze Commented Oct 16, 2009 at 9:31
• An implicit destructor also invokes destructors of members and subobjects (if there are any) –  sellibitze Commented Oct 16, 2009 at 9:34

That behavior is necessary in order to maintain source compatibility with C.

C does not give you the ability to define/override operators, so structs are normally copied with the = operator.

• K&R C didn't allow for structures to be copied with = at all, and I'm not sure about C89. If it was introduced in C99, then I'd argue that it was due to C++ influence. –  ephemient Commented Oct 15, 2009 at 22:16
• 4 According to K&R (2nd edition, 1988, p. 127) it was introduced by ANSI C but most existing compilers already supported it. –  Ferruccio Commented Oct 18, 2009 at 13:40

But it is defined. In the standard. If you supply no operator =, one is supplied to you. And the default operator just copies each of the member variables. And how does it know which way to copy each member? it calls their operator = (which, if not defined, is supplied by default...).

The assignment operator ( operator= ) is one of the implicitly generated functions for a struct or class in C++.

Here is a reference describing the 4 implicitly generated members: http://www.cs.ucf.edu/~leavens/larchc++manual/lcpp_136.html

In short, the implicitly generated member performs a memberwise shallow copy . Here is the long version from the linked page:

The implicitly-generated assignment operator specification, when needed, is the following. The specification says that the result is the object being assigned ( self ), and that the value of the abstract value of self in the post-state self " is the same as the value of the abstract value of the argument from .

• The default assignment operator can't throw because it doesn't allocate any memory. :dunno: –  Sam Harwell Commented Oct 16, 2009 at 1:16
• 4 @Rob: The definition of the default copy assignment operator starting at 12.8:10 makes no mention of a throw clause. This makes sense to me, since a default copy assignment operator can call a non-default assignment, which could throw. In the specific example given in the question obviously std::string::operator=(const std::string&) can throw. –  Steve Jessop Commented Oct 16, 2009 at 1:45

The compiler will synthesise some members for you if you don't define them explicitly yourself. The assignment operator is one of them. A copy constructor is another, and you get a destructor too. You also get a default constructor if you don't provide any constructors of your own. Beyond that I'm not sure what else but I believe there may be others (the link in the answer given by 280Z28 suggests otherwise though and I can't remember where I read it now so maybe it's only four).

structs are basically a concatenation of its components in memory (with some possible padding built in for alignment). When you assign one struct the value of another, the values are just coped over.

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++ gcc operators or ask your own question .

• The Overflow Blog
• Masked self-attention: How LLMs learn relationships between tokens
• Deedy Das: from coding at Meta, to search at Google, to investing with Anthropic
• Featured on Meta
• User activation: Learnings and opportunities
• Preventing unauthorized automated access to the network
• Should low-scoring meta questions no longer be hidden on the Meta.SO home...
• Feedback Requested: How do you use the tagged questions page?
• Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

• Is the Earth still capable of massive volcanism, like the kind that caused the formation of the Siberian Traps?
• Is this a balanced way to implement the "sparks" spell from Skyrim into D&D?
• is it okay to mock a database when writing unit test?
• Tikz: On straight lines moving balls on a circle inside a regular polygon
• How similar were the MC6800 and MOS 6502?
• Easily unload gravel from pickup truck
• Why would an ocean world prevent the creation of ocean bases but allow ships?
• How do I avoid getting depressed after receiving edits?
• How to format units inside math environment?
• Where is the best place to get bows in TotK?
• In John 3:16, what is the significance of Jesus' distinction between the terms 'world' and 'everyone who believes' within the context?
• Is there any language which distinguishes between “un” as in “not” and “un” as in “inverse”?
• What is the mechanical equivalent of an electronic AND gate?
• Has Azerbaijan signed a contract to purchase JF-17s from Pakistan?
• Place some or all of the White Chess pieces on a chessboard in such a way that none of them can legally move
• Macro not working in newcommand, but plain text input works
• Is there a name for this Fibonacci formula that uses hyperbolic trigonometry?
• Why was Z moved to the end of the alphabet when Zeta was near the beginning?
• Fjord Explorer – a Nagareru crossword
• Do early termination fees hold up in court?
• Are logic and mathematics the only fields in which certainty (proof) can be obtained?
• Including specific points in Plot
• On a glassed landmass, how long would it take for plants to grow?
• Purpose of sleeve on sledge hammer handle