c assignment operator automatically generated

About Jonathan Boccara

Hello, my name is Jonathan Boccara, I'm your host on Fluent C++. I have been a developer for 10 years. My focus is on how to write expressive code . I wrote the book The Legacy Code Programmer's Toolbox . I'm happy to take your feedback, don't hesitate to drop a comment on a post, follow me or get in touch directly !

Jonathan Boccara's blog

Recent Posts

• Usage First, Implementation After: A Principle of Software Development
• Design Patterns VS Design Principles: Factory method
• How to Store an lvalue or an rvalue in the Same Object
• Copy-Paste Developments
• Design Patterns VS Design Principles: Abstract Factory
• How to Generate All the Combinations from Several Collections

Compiler-generated Functions, Rule of Three and Rule of Five

When you read a class interface that defines some basic functions (constructors, destructors, assignment) but not all of them , don’t you wonder what that code means, and what functions will be available for that class in practice? I often do.

To clarify this type of situation, I suggest we make a recap of what class functions the compiler generates in C++. Being clear on this will let us:

• better understand such code,
• reflect on higher-level questions, such as whether  = default  makes code more expressive or not, which we’ll explore in the next post.

I went to my compiler and tested out various combinations of user-defined and compiler-defined functions. You’ll find the results synthesized in this article, with some rationale that I took from Effective C++  (item 5 and 6) and Modern Effective C++ (item 17).

Hope you’ll find those results useful.

What functions the compiler can generate

The idea of compiler-generated functions is that, if some functions of a class are so trivial to write that their code would nearly be boilerplate, the compiler will take care of writing them for you.

This feature has been here since C++98, where the compiler would try to generate:

• a default constructor X() , that calls the default constructor of each class member and base class,
• a copy constructor X(X const& other) , that calls a copy constructor on each member and base class,
• a copy assignment operator X& operator=(X const& other) , that calls a copy assignment operator on each class member and base class,
• the destructor ~X() , that calls the destructor of each class member and base class. Note that this default-generated destructor is never virtual  (unless it is for a class inheriting from one that has a virtual  destructor).

With C++11, the compiler generates 2 new functions related to move semantics:

• a move constructor X(X&& other) , that calls a move constructor of each class member and base class,
• a move assignment operator X& operator=(X&& other) , that calls a move assignment operator on each class member and base class.

Note that other functions have been proposed for automatic generation such as the comparison operators, and something related to this should hit C++20 with the spaceship operator. More on that later.

The Rule of Three and the Rule of Five

It is important to note that the default constructor has different semantics from the rest of the above functions. Indeed, all the other functions deal with the management of the resources inside of the class: how to copy them, how to dispose of them.

If a class holds a handle to a resource such as a database connection or an owning raw pointer (which would be the case in a smart pointer for example), those functions need to pay special care to handle the life cycle of that resource.

The default constructor only initializes the resource, and is closer in semantics to any other constructor that takes values, rather than to those special functions that handle resource life cycle.

Let’s now count the functions in the above bullet points that handle the resource management of the class:

• there are 3 in C++98 (4 minus the default constructor),
• there are 5 in C++11.

Which gives the “Rule of Three” in C++98, and the “Rule of Five” in C++11: let x be 3 in C++98 and 5 in C++11, then we have:

If you need to write the code for one of the x resource management functions, it suggests that your class’s resource handling is not trivial and you certainly need to write the other x – 1.  – Rule of x

When the compiler generates them

In some cases, the compiler won’t generate those functions.

If you write any of those functions yourself, the compiler won’t generate it. That’s pretty obvious.

If you don’t write one of the following (and you didn’t write move operations either, see below why):

• a copy constructor,
• a copy-assignement operator,
• a destructor,

the compiler will try to generate them for you. Even if you’ve hand-written the other two. In some cases it may not succeed though, for instance if the class contains a const  or reference member, the compiler won’t be able to come up with an operator= .

If you write any of the following:

• a direct constructor  X(int, double) ,
• a move constructor,

then the compiler thinks: “the developer made the decision to write a constructor, maybe they don’t want a default one then”, and it doesn’t generate the default constructor. Which makes sense to me in the case of the value constructor, but that I find weird for the copy and move constructor, since like we said, default constructor and copy constructor have different semantics.

• a copy assignment operator,

the compiler thinks “there must be something complex about the resource management of that class if the developer took the time to write one of those”, and it doesn’t generate the move constructor nor the move assignment operator.

You may wonder, why does the compiler only refrain from generating the  move functions and not the copy functions? After all, if it feels that the resource handling of the class is beyond its understanding, it shouldn’t generate any of the resource-handling functions, not even the destructor while we’re at it. That’s the rule of 5, isn’t it?

That’s true, and the reason for the observed behaviour is history. C++98 didn’t natively enforce the rule of 3. But C++11, that brought the  move functions, also wanted to enforce the rule of 5. But to preserve backward compatibility, C++11 couldn’t remove the  copy functions that existing code relied upon, only the move function that didn’t exist yet. This led to that compromise that we could (somewhat approximately) call the “rule of 2”.

Finally, if you write any of the following:

• a move assignment operator,

the compiler still thinks “there must be something complex about the resource management of that class if the developer took the time to write one of those”. But code that contains move operations can’t be pre-C++11. So there is no longer a backward compatibility and the compiler can fully enforce the rule of 5 by refraining from generating any of the 5 resource management functions.

= default  and = delete

C++11 brought those two keywords that you can tack on the 6 functions that the compiler can generate.

If you write = default , as in:

Or in an implementation file:

Then you are explicitly asking the compiler to generate that function for you, and it will do it to the best of its abilities. It can fail though, if there is no possible default implementation. For a default constructor, that would be if one of the members of the class doesn’t itself have a default constructor for example.

And if you write = delete , you explicitly ask to remove that function, and the compiler can always satisfy this request. It looks like this:

The Rule of Zero

Now that we’re clear on what makes the compiler generate functions or not, we can move on to higher-level questions. In the next post, we’ll reflect over whether = default  make an interface more expressive or not.

One of the aspects of that question will lead us the to Rule of Zero, which is to the Rule of Three and the Rule of Five what Batman Begins is to The Dark Knight and the The Dark Knight Rises, if I may say.

With that said, stay tuned for the next post.

Copy assignment operator

A copy assignment operator of class T is a non-template non-static member function with the name operator = that takes exactly one parameter of type T , T & , const T & , volatile T & , or const volatile T & . A type with a public copy assignment operator is CopyAssignable .

[ edit ] Syntax

[ edit ] explanation.

• Typical declaration of a copy assignment operator when copy-and-swap idiom can be used
• Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used
• Forcing a copy assignment operator to be generated by the compiler
• Avoiding implicit copy assignment

The copy assignment operator is called whenever selected by overload resolution , e.g. when an object appears on the left side of an assignment expression.

[ edit ] Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type ( struct , class , or union ), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T & T :: operator = ( const T & ) if all of the following is true:

• each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B &
• each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M &

Otherwise the implicitly-declared copy assignment operator is declared as T & T :: operator = ( T & ) . (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument)

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

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

[ edit ] Deleted implicitly-declared copy assignment operator

The implicitly-declared or defaulted copy assignment operator for class T is defined as deleted in any of the following is true:

• T has a non-static data member that is const
• T has a non-static data member of a reference type.
• T has a non-static data member that cannot be copy-assigned (has deleted, inaccessible, or ambiguous copy assignment operator)
• T has direct or virtual base class that cannot be copy-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
• T has a user-declared move constructor
• T has a user-declared move assignment operator

[ edit ] Trivial copy assignment operator

The implicitly-declared copy assignment operator for class T is trivial if all of the following is true:

• 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) memeber of T is trivial

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

[ edit ] Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined copy assignment copies the object representation (as by std:: memmove ). For non-union class types ( class and struct ), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated (since C++11) if T has a user-declared destructor or user-declared copy constructor.

[ edit ] Notes

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

[ edit ] Copy and swap

Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:

T & T :: operator = ( T arg ) { // copy/move constructor is called to construct arg     swap ( arg ) ;     // resources exchanged between *this and arg     return * this ; }   // destructor is called to release the resources formerly held by *this

For non-throwing swap(), this form provides strong exception guarantee . For rvalue arguments, this form automatically invokes the move constructor, and is sometimes referred to as "unifying assignment operator" (as in, both copy and move).

[ edit ] Example

This browser is no longer supported.

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

Copy constructors and copy assignment operators (C++)

• 8 contributors

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

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

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

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

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

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

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

Use the copy constructor.

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

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

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

Compiler generated copy constructors

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

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

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

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

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

For more information about overloaded assignment operators, see Assignment .

Was this page helpful?

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

Submit and view feedback for

Additional resources

• Sign In / Suggest an Article

Current ISO C++ status

Upcoming ISO C++ meetings

Upcoming C++ conferences

Compiler conformance status

ISO C++ committee meeting

June 24-29, St. Louis, MO, USA

July 2-5, Folkestone, Kent, UK

assignment operators

Assignment operators, what is “self assignment”.

Self assignment is when someone assigns an object to itself. For example,

Obviously no one ever explicitly does a self assignment like the above, but since more than one pointer or reference can point to the same object (aliasing), it is possible to have self assignment without knowing it:

This is only valid for copy assignment. Self-assignment is not valid for move assignment.

Why should I worry about “self assignment”?

If you don’t worry about self assignment , you’ll expose your users to some very subtle bugs that have very subtle and often disastrous symptoms. For example, the following class will cause a complete disaster in the case of self-assignment:

If someone assigns a Fred object to itself, line #1 deletes both this->p_ and f.p_ since *this and f are the same object. But line #2 uses *f.p_ , which is no longer a valid object. This will likely cause a major disaster.

The bottom line is that you the author of class Fred are responsible to make sure self-assignment on a Fred object is innocuous . Do not assume that users won’t ever do that to your objects. It is your fault if your object crashes when it gets a self-assignment.

Aside: the above Fred::operator= (const Fred&) has a second problem: If an exception is thrown while evaluating new Wilma(*f.p_) (e.g., an out-of-memory exception or an exception in Wilma ’s copy constructor ), this->p_ will be a dangling pointer — it will point to memory that is no longer valid. This can be solved by allocating the new objects before deleting the old objects.

Okay, okay, already; I’ll handle self-assignment. How do I do it?

You should worry about self assignment every time you create a class . This does not mean that you need to add extra code to all your classes: as long as your objects gracefully handle self assignment, it doesn’t matter whether you had to add extra code or not.

We will illustrate the two cases using the assignment operator in the previous FAQ :

If self-assignment can be handled without any extra code, don’t add any extra code. But do add a comment so others will know that your assignment operator gracefully handles self-assignment:

Example 1a:

Example 1b:

If you need to add extra code to your assignment operator, here’s a simple and effective technique:

Or equivalently:

By the way: the goal is not to make self-assignment fast. If you don’t need to explicitly test for self-assignment, for example, if your code works correctly (even if slowly) in the case of self-assignment, then do not put an if test in your assignment operator just to make the self-assignment case fast. The reason is simple: self-assignment is almost always rare, so it merely needs to be correct - it does not need to be efficient. Adding the unnecessary if statement would make a rare case faster by adding an extra conditional-branch to the normal case, punishing the many to benefit the few.

In this case, however, you should add a comment at the top of your assignment operator indicating that the rest of the code makes self-assignment is benign, and that is why you didn’t explicitly test for it. That way future maintainers will know to make sure self-assignment stays benign, or if not, they will need to add the if test.

I’m creating a derived class; should my assignment operators call my base class’s assignment operators?

Yes (if you need to define assignment operators in the first place).

If you define your own assignment operators, the compiler will not automatically call your base class’s assignment operators for you. Unless your base class’s assignment operators themselves are broken, you should call them explicitly from your derived class’s assignment operators (again, assuming you create them in the first place).

However if you do not create your own assignment operators, the ones that the compiler create for you will automatically call your base class’s assignment operators.

Please Login to submit a recommendation.

If you don’t have an account, you can register for free.

C Data Types

C operators.

• C Input and Output
• C Control Flow
• C Functions
• C Preprocessors

C File Handling

• C Cheatsheet

C Interview Questions

• C Programming Language Tutorial
• C Language Introduction
• Features of C Programming Language
• C Programming Language Standard
• C Hello World Program
• Compiling a C Program: Behind the Scenes
• Tokens in C
• Keywords in C

C Variables and Constants

• C Variables
• Constants in C
• Const Qualifier in C
• Different ways to declare variable as constant in C
• Scope rules in C
• Internal Linkage and External Linkage in C
• Global Variables in C
• Data Types in C
• Literals in C
• Escape Sequence in C
• Integer Promotions in C
• Character Arithmetic in C
• Type Conversion in C

C Input/Output

• Basic Input and Output in C
• Format Specifiers in C
• printf in C
• Scansets in C
• Formatted and Unformatted Input/Output functions in C with Examples
• Operators in C
• Arithmetic Operators in C
• Unary operators in C
• Relational Operators in C
• Bitwise Operators in C
• C Logical Operators

Assignment Operators in C

• Increment and Decrement Operators in C
• Conditional or Ternary Operator (?:) in C
• sizeof operator in C
• Operator Precedence and Associativity in C

C Control Statements Decision-Making

• Decision Making in C (if , if..else, Nested if, if-else-if )
• C - if Statement
• C if...else Statement
• C if else if ladder
• Switch Statement in C
• Using Range in switch Case in C
• while loop in C
• do...while Loop in C
• For Versus While
• Continue Statement in C
• Break Statement in C
• goto Statement in C
• User-Defined Function in C
• Parameter Passing Techniques in C
• Function Prototype in C
• How can I return multiple values from a function?
• main Function in C
• Implicit return type int in C
• Callbacks in C
• Nested functions in C
• Variadic functions in C
• _Noreturn function specifier in C
• Predefined Identifier __func__ in C
• C Library math.h Functions

C Arrays & Strings

• Properties of Array in C
• Multidimensional Arrays in C
• Initialization of Multidimensional Array in C
• Pass Array to Functions in C
• How to pass a 2D array as a parameter in C?
• What are the data types for which it is not possible to create an array?
• How to pass an array by value in C ?
• Strings in C
• Array of Strings in C
• What is the difference between single quoted and double quoted declaration of char array?
• C String Functions
• Pointer Arithmetics in C with Examples
• C - Pointer to Pointer (Double Pointer)
• Function Pointer in C
• How to declare a pointer to a function?
• Pointer to an Array | Array Pointer
• Difference between constant pointer, pointers to constant, and constant pointers to constants
• Pointer vs Array in C
• Dangling, Void , Null and Wild Pointers in C
• Near, Far and Huge Pointers in C
• restrict keyword in C

C User-Defined Data Types

• C Structures
• dot (.) Operator in C
• Structure Member Alignment, Padding and Data Packing
• Flexible Array Members in a structure in C
• Bit Fields in C
• Difference Between Structure and Union in C
• Anonymous Union and Structure in C
• Enumeration (or enum) in C

C Storage Classes

• Storage Classes in C
• extern Keyword in C
• Static Variables in C
• Initialization of static variables in C
• Static functions in C
• Understanding "volatile" qualifier in C | Set 2 (Examples)
• Understanding "register" keyword in C

C Memory Management

• Memory Layout of C Programs
• Dynamic Memory Allocation in C using malloc(), calloc(), free() and realloc()
• Difference Between malloc() and calloc() with Examples
• What is Memory Leak? How can we avoid?
• Dynamic Array in C
• How to dynamically allocate a 2D array in C?
• Dynamically Growing Array in C

C Preprocessor

• C Preprocessor Directives
• How a Preprocessor works in C?
• Header Files in C
• What’s difference between header files "stdio.h" and "stdlib.h" ?
• How to write your own header file in C?
• Macros and its types in C
• Interesting Facts about Macros and Preprocessors in C
• # and ## Operators in C
• How to print a variable name in C?
• Multiline macros in C
• Variable length arguments for Macros
• Branch prediction macros in GCC
• typedef versus #define in C
• Difference between #define and const in C?
• Basics of File Handling in C
• C fopen() function with Examples
• EOF, getc() and feof() in C
• fgets() and gets() in C language
• fseek() vs rewind() in C
• What is return type of getchar(), fgetc() and getc() ?
• Read/Write Structure From/to a File in C
• C Program to print contents of file
• C program to delete a file
• C Program to merge contents of two files into a third file
• What is the difference between printf, sprintf and fprintf?
• Difference between getc(), getchar(), getch() and getche()

Miscellaneous

• time.h header file in C with Examples
• Input-output system calls in C | Create, Open, Close, Read, Write
• Signals in C language
• Program error signals
• Socket Programming in C
• _Generics Keyword in C
• Multithreading in C
• C Programming Interview Questions (2024)
• Commonly Asked C Programming Interview Questions | Set 1
• Commonly Asked C Programming Interview Questions | Set 2
• Commonly Asked C Programming Interview Questions | Set 3

Assignment operators are used for assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of the variable on the left side otherwise the compiler will raise an error.

Different types of assignment operators are shown below:

1. “=”: This is the simplest assignment operator. This operator is used to assign the value on the right to the variable on the left. Example:

2. “+=” : This operator is combination of ‘+’ and ‘=’ operators. This operator first adds the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a += 6) = 11.

3. “-=” This operator is combination of ‘-‘ and ‘=’ operators. This operator first subtracts the value on the right from the current value of the variable on left and then assigns the result to the variable on the left. Example:

If initially value stored in a is 8. Then (a -= 6) = 2.

4. “*=” This operator is combination of ‘*’ and ‘=’ operators. This operator first multiplies the current value of the variable on left to the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 5. Then (a *= 6) = 30.

5. “/=” This operator is combination of ‘/’ and ‘=’ operators. This operator first divides the current value of the variable on left by the value on the right and then assigns the result to the variable on the left. Example:

If initially value stored in a is 6. Then (a /= 2) = 3.

Below example illustrates the various Assignment Operators:

Please Login to comment...

Similar reads.

• C-Operators
• cpp-operator

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

C++ rules for automatic member function generation

I cannot remember the rules according to which C++ automatically generates some class members, so this note serves as a reminder.

The rules for automatically generating class members for a class T are:

A copy constructor (which takes a single argument of type const T & ) is generated if all base classes and members are copy-constructible. Note that reference members are copy-constructible.

The parameter-less default constructor is generated if the class does not define any constructor and all base classes and members are default-constructible. This means that once you declare a copy constructor (perhaps to disable the automatically provided one, see below), the compiler will not supply a default construtor.

The copy-assignment operator T &T::operator=(const T &) is generated if all base classes and members are copy-assignable. For this purpose, reference members are not considered copy-assignable.

The destructor is always automatically supplied if possible, based on the members and the base classes.

In C++11, A move constructor with an argument T && is supplied unless the class has any of the following: a user-defined copy constructor, copy-assignment operator, move-assignment operator, or destructor. If the move constructor cannot be implemented because not all bases or members are move-constructible, the supplied move constructor will be defined as deleted.

Similarly, in C++11, a move-assignment operator T &T::operator=(T &&) is supplied under the same conditions.

Comparison operator such as bool operator==(const T &) const are never automatically generated by the compiler, even if all base classes and members are comparable.

In order to suppress the automatically generated copy constructor and copy-assignment operator, it is customary in C++03 and earlier to declare them as private members, but do not define them:

class T { T( const T &); // not implemented T & operator =( const T &); // not implemented public: ... };

This will result in a compile-time error if code which has not private access tries to use this members, or a link-time error for code that has access. In C++11 and later, the delete should be used because it results in a better diagnostic:

class T { T( const T &) = delete; T & operator =( const T &) = delete; public: ... };

C++11 supports initialization of members as part of the class declaration, like this:

class T { int a = 1; public: explicit T( int ); }

Here, the user-defined constructor prevents generation of the default constructor with the initialization operations. Generation of the default constructor can be requested using the default keyword.

class T { int a = 1; public: explicit T( int ); T() = default ; }

The rules are fairly simple (as far as things related to C++ are considered), and after writing them down, I will probably never have to look at this note again.

2013-11-02: published

Florian Weimer Home Blog (DE) Blog (EN) Impressum RSS Feeds

cppreference.com

Default comparisons (since c++20).

Provides a way to request the compiler to generate consistent comparison operators for a class.

[ edit ] Syntax

[ edit ] explanation.

The three-way comparison function (whether defaulted or not) is called whenever values are compared using < , > , <= , >= , or <=> and overload resolution selects this overload.

The equality comparison function (whether defaulted or not) is called whenever values are compared using == or != and overload resolution selects this overload.

Like defaulted special member functions, a defaulted comparison function is defined if odr-used or needed for constant evaluation .

[ edit ] Defaulted comparisons

[ edit ] defaulted three-way comparison.

The default operator <=> performs lexicographical comparison by successively comparing the base (left-to-right depth-first) and then non-static member (in declaration order) subobjects of T to compute <=> , recursively expanding array members (in order of increasing subscript), and stopping early when a not-equal result is found, that is:

It is unspecified whether virtual base subobjects are compared more than once.

If the declared return type is auto , then the actual return type is the common comparison category of the base and member subobject and member array elements to be compared (see std::common_comparison_category ). This makes it easier to write cases where the return type non-trivially depends on the members, such as:

Let R be the return type, each pair of subobjects a , b is compared as follows:

• If a <=> b is usable and can be explicitly converted to R using static_cast , the result of comparison is static_cast < R > ( a <=> b ) .
• Otherwise, if overload resolution for a <=> b is performed and finds at least one viable candidate, the comparison is not defined ( operator <=> is defined as deleted).
• Otherwise, if R is not a comparison category type (see below), or either a == b or a < b is not usable, the comparison is not defined ( operator <=> is defined as deleted).
• Otherwise, if R is std::strong_ordering , the result is
• Otherwise, if R is std::weak_ordering , the result is
• Otherwise ( R is std::partial_ordering ), the result is

Per the rules for any operator <=> overload, a defaulted <=> overload will also allow the type to be compared with < , <= , > , and >= .

If operator <=> is defaulted and operator == is not declared at all, then operator == is implicitly defaulted.

[ edit ] Defaulted equality comparison

A class can define operator == as defaulted, with a return value of bool . This will generate an equality comparison of each base class and member subobject, in their declaration order. Two objects are equal if the values of their base classes and members are equal. The test will short-circuit if an inequality is found in members or base classes earlier in declaration order.

Per the rules for operator == , this will also allow inequality testing:

[ edit ] Other defaulted comparison operators

Any of the four relational operators can be explicitly defaulted. A defaulted relational operator must have the return type bool .

Such operator will be deleted if overload resolution over x <=> y (considering also operator <=> with reversed order of parameters) fails, or if this operator@ is not applicable to the result of that x <=> y . Otherwise, the defaulted operator@ calls x <=> y @ 0 if an operator <=> with the original order of parameters was selected by overload resolution, or 0 @ y <=> x otherwise:

Similarly, operator ! = can be defaulted. It is deleted if overload resolution over x == y (considering also operator == with reversed order of parameters) fails, or if the result of x == y does not have type bool . The defaulted operator ! = calls ! ( x == y ) or ! ( y == x ) as selected by overload resolution.

Defaulting the relational operators can be useful in order to create functions whose addresses may be taken. For other uses, it is sufficient to provide only operator <=> and operator == .

[ edit ] Custom comparisons and comparison categories

When the default semantics are not suitable, such as when the members must be compared out of order, or must use a comparison that's different from their natural comparison, then the programmer can write operator <=> and let the compiler generate the appropriate two-way comparison operators. The kind of two-way comparison operators generated depends on the return type of the user-defined operator <=> .

There are three available return types:

[ edit ] Strong ordering

An example of a custom operator <=> that returns std::strong_ordering is an operator that compares every member of a class, except in order that is different from the default (here: last name first).

Note: an operator that returns a std::strong_ordering should compare every member, because if any member is left out, substitutability can be compromised: it becomes possible to distinguish two values that compare equal.

[ edit ] Weak ordering

An example of a custom operator <=> that returns std::weak_ordering is an operator that compares string members of a class in case-insensitive manner: this is different from the default comparison (so a custom operator is required) and it is possible to distinguish two strings that compare equal under this comparison:

Note that this example demonstrates the effect a heterogeneous operator <=> has: it generates heterogeneous comparisons in both directions.

[ edit ] Partial ordering

Partial ordering is an ordering that allows incomparable (unordered) values, such as NaN values in floating-point ordering, or, in this example, persons that are not related:

[ edit ] See also

• overload resolution in a call to an overloaded operator
• Built-in three-way comparison operator
• Operator overloading for comparison operators
• Todo with reason
• Pages with unreviewed CWG DR marker
• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 14 January 2024, at 15:48.
• This page has been accessed 300,766 times.
• Privacy policy
• About cppreference.com
• Disclaimers