c default assignment operator struct

This browser is no longer supported.

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

Copy constructors and copy assignment operators (C++)

• 8 contributors

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

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

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

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

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

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

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

Use the copy constructor.

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

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

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

Compiler generated copy constructors

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

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

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

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

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

For more information about overloaded assignment operators, see Assignment .

Was this page helpful?

Additional resources

• 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

21.13 — Shallow vs. deep copying

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

Next: Unions , Previous: Overlaying Structures , Up: Structures   [ Contents ][ Index ]

15.13 Structure Assignment

Assignment operating on a structure type copies the structure. The left and right operands must have the same type. Here is an example:

Notionally, assignment on a structure type works by copying each of the fields. Thus, if any of the fields has the const qualifier, that structure type does not allow assignment:

See Assignment Expressions .

When a structure type has a field which is an array, as here,

structure assigment such as r1 = r2 copies array fields’ contents just as it copies all the other fields.

This is the only way in C that you can operate on the whole contents of a array with one operation: when the array is contained in a struct . You can’t copy the contents of the data field as an array, because

would convert the array objects (as always) to pointers to the zeroth elements of the arrays (of type struct record * ), and the assignment would be invalid because the left operand is not an lvalue.

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

Initializing default values in a struct

If I needed to initialize only a few select values of a C++ struct, would this be correct:

Am I correct to assume I would end up with one struct item called bar with elements bar.a = true , bar.b = true and an undefined bar.c ?

• the bar is just a renaming, if you are using c++ you don't need to do things this way –  aaronman Commented May 28, 2013 at 0:16
• 14 @aaronman no, bar is a variable. –  Luchian Grigore Commented May 28, 2013 at 0:20
• 6 @aaronman I think you're confusing this with typedef struct foo {} bar; . –  greatwolf Commented May 28, 2013 at 0:21
• 1 So, if bar is the struct, what's foo ? Is this the same as defining a foo struct and separately declaring a new variable bar as type foo ? –  Vince Commented Nov 29, 2013 at 4:10
• 5 bar is simply a foo object. It is the same as struct foo {//something}; foo bar; –  Yan Yi Commented Feb 22, 2015 at 21:39

4 Answers 4

You don't even need to define a constructor

To clarify: these are called brace-or-equal-initializers (because you may also use brace initialization instead of equal sign). This is not only for aggregates: you can use this in normal class definitions. This was added in C++11.

• 9 @jamesdlin: Since August 21, 2011, the c++ tag means C++11. People are welcome to say C++98 or C++03 if they want to discuss an old version. And sometime next year, the bare c++ tag will change again to mean C++14. –  Ben Voigt Commented May 28, 2013 at 5:35
• 12 It's worth noting this immediately makes the type non-POD (verified via std::is_pod<T>::value ) and so, in that sense, is equivalent to writing a non-default constructor that sets the same values in an initialiser list. –  underscore_d Commented Dec 17, 2015 at 21:47
• 3 Actually brace initialization is only allowed when there are no default member initializers in C++11. This limitation is lifted with C++14. ideone uses C++14 but if you use any C++11 compiler that code will fail. en.cppreference.com/w/cpp/language/aggregate_initialization –  Giovanni Botta Commented May 31, 2016 at 21:55
• What if the struct is defined using typedef, like C style? still initializes? –  Dumbo Commented Feb 11, 2017 at 5:38

Yes. bar.a and bar.b are set to true, but bar.c is undefined. However, certain compilers will set it to false.

See a live example here: struct demo

According to C++ standard Section 8.5.12:

if no initialization is performed, an object with automatic or dynamic storage duration has indeterminate value

For primitive built-in data types ( bool , char, wchar_t, short, int, long, float, double, long double), only global variables (all static storage variables) get default value of zero if they are not explicitly initialized.

If you don't really want undefined bar.c to start with, you should also initialize it like you did for bar.a and bar.b .

• 1 @CaptainObvlious just updated, sorry I was distracted by other stuff and not with computer. –  taocp Commented May 28, 2013 at 0:41
• 5 It's not "undefined", it is uninitialized , meaning it has an indeterminate value . –  Jonathan Wakely Commented Nov 13, 2015 at 17:59
• I think OP meant to say that the value is undefined, not the member. –  srujzs Commented Nov 5, 2018 at 23:30

You can do it by using a constructor, like this:

or like this:

In your case bar.c is undefined,and its value depends on the compiler (while a and b were set to true).

• 17 There is no reason to prefer the first form. You should use initialization lists. –  jamesdlin Commented May 28, 2013 at 3:51
• 1 @jamesdlin agreed in 99.9% of cases, where the 2nd is vastly preferable for countless reasons. however - just to play devil's advocate! - if rather than int s the members were custom classes that had to meet the definition of trivial (e.g. no non-default constructor), that would be a reason to assign in the body instead of constructing in the init list. however, the number of scenarios in which this is useful are, presumably, a tiny minority, so init lists should definitely be the default recommendation - with the rare exceptions being carefullly qualified and justified, unlike here. –  underscore_d Commented Dec 17, 2015 at 21:51
• 1 @underscore_d No it wouldn't be such a reason. You can use initialiser lists in all cases except where member variables are interdependent, and that is a violation of 3NF ;-) –  user207421 Commented May 22, 2016 at 2:40
• @EJP It very much can be a reason; I've needed it several times. I think you're focussing on the parent initialisation, but I'm talking about its members. For member objects whose default ctors are inappropriate & standard layout precludes non- default constructors, one must perform 'initialisation' another way, be it operator= or an init function or whatever. It makes sense to do this 'iniitialisation' in the parent's constructor i.e. assign in its body. operator= here is equivalent to in-body assignment of primitives as in the post. Overthinking or tangential maybe, but true ;-) –  underscore_d Commented May 22, 2016 at 11:17
• 1 @GabrielStaples If you're initializing individual elements of an array, then yes, you would need to do that in a constructor body. Obviously there are some things that must be done in a constructor body. My earlier comment was specifically talking about the specific examples in this answer. –  jamesdlin Commented Dec 11, 2019 at 22:16

An explicit default initialization can help:

Behavior bool a {} is same as bool b = bool(); and return false .

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

• The Overflow Blog
• Where developers feel AI coding tools are working—and where they’re missing...
• Masked self-attention: How LLMs learn relationships between tokens
• 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...
• Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

• Is there a name for this Fibonacci formula that uses hyperbolic trigonometry?
• On a glassed landmass, how long would it take for plants to grow?
• Is it common in modern classical music for timpani to play chromatic passages?
• Automatically italicize a letter only in math mode
• Is BitLocker susceptible to any known attacks other than bruteforcing when used with a very strong passphrase and no TPM?
• What is the simplest formula for calculating the circumference of a circle?
• Why the proper acceleration is zero during free fall?
• What does mean by "offers accepted" in Mathjobs portal?
• Sticky goo making it hard to open and close the main 200amp breaker
• How old was Abraham when Rebecca (Isaac's wife) was born?
• Does the Rogue's Evasion cost a reaction?
• Help. It's not compiling!
• Does Voyager send its data on a schedule and hope somebody's listening?
• Java class subset of C++ std::list with efficient std::list::sort()
• What exactly do I buy when I buy an index-following ETF?
• Do early termination fees hold up in court?
• Do mathematicians care about the validity ("truth") of the axioms?
• Easily unload gravel from pickup truck
• Why does the Rdson limit from a MOSFET’s SOA graph not match its output characteristics curve?
• Does a passenger jet detect excessive weight in the tail after it's just landed?
• If two subgroups intersect in only the identity, do their cosets intersect in at most one element?
• What causes, and how to avoid, finger numbness?
• tan 3θ = cot(−θ)
• Is there a faster way to find the positions of specific elements in a very large list?

cppreference.com

Move assignment operator.

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

[ edit ] Syntax

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

[ edit ] Explanation

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

Move assignment operators typically transfer the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, thread handles, etc.), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. Since move assignment doesn’t change the lifetime of the argument, the destructor will typically be called on the argument at a later point. For example, move-assigning from a std::string or from a std::vector may result in the argument being left empty. A move assignment is less, not more restrictively defined than ordinary assignment; where ordinary assignment must leave two copies of data at completion, move assignment is required to leave only one.

[ edit ] Implicitly-declared move assignment operator

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

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

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

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

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

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

[ edit ] Implicitly-defined move assignment operator

If the implicitly-declared move assignment operator is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used or needed for constant evaluation (since C++14) .

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

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

As with copy assignment, it is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined move assignment operator:

[ edit ] Deleted move assignment operator

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

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

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

[ edit ] Trivial move assignment operator

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

• It is not user-provided (meaning, it is implicitly-defined or defaulted);
• T has no virtual member functions;
• T has no virtual base classes;
• the move assignment operator selected for every direct base of T is trivial;
• the move assignment operator selected for every non-static class type (or array of class type) member of T is trivial.

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

[ edit ] Eligible move assignment operator

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

[ edit ] Notes

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

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

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

[ edit ] Example

[ edit ] defect reports.

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

[ edit ] See also

• constructor
• converting constructor
• copy assignment
• copy constructor
• default constructor
• aggregate initialization
• constant initialization
• copy initialization
• default initialization
• direct initialization
• list initialization
• reference initialization
• value initialization
• zero initialization
• move constructor
• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 4 September 2024, at 07:11.
• Privacy policy
• About cppreference.com
• Disclaimers