c overload addition assignment operator

• Todo without reason
• Community portal
• Current events
• Recent changes
• Random page
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• This page was last modified on 9 April 2014, at 08:25.
• This page has been accessed 30,627 times.
• Privacy policy
• About cppreference.com
• Disclaimers

operator overloading

Customizes the C++ operators for operands of user-defined types.

Overloaded operators are functions with special function names:

Overloaded operators

When an operator appears in an expression , and at least one of its operands has a class type or an enumeration type , then overload resolution is used to determine the user-defined function to be called among all the functions whose signatures match the following:

Note: for overloading user-defined conversion functions , user-defined literals , allocation and deallocation see their respective articles.

Overloaded operators (but not the built-in operators) can be called using function notation:

Restrictions

• The operators :: (scope resolution), . (member access), .* (member access through pointer to member), and ?: (ternary conditional) cannot be overloaded.
• New operators such as ** , <> , or &| cannot be created.
• The overloads of operators && and || lose short-circuit evaluation.
• The overload of operator -> must either return a raw pointer, or return an object (by reference or by value) for which operator -> is in turn overloaded.
• It is not possible to change the precedence, grouping, or number of operands of operators.

Canonical implementations

Other than the restrictions above, the language puts no other constraints on what the overloaded operators do, or on the return type (it does not participate in overload resolution), but in general, overloaded operators are expected to behave as similar as possible to the built-in operators: operator + is expected to add, rather than multiply its arguments, operator = is expected to assign, etc. The related operators are expected to behave similarly ( operator + and operator + = do the same addition-like operation). The return types are limited by the expressions in which the operator is expected to be used: for example, assignment operators return by reference to make it possible to write a = b = c = d , because the built-in operators allow that.

Commonly overloaded operators have the following typical, canonical forms: [1]

Assignment operator

The assignment operator ( operator = ) has special properties: see copy assignment and move assignment for details.

The canonical copy-assignment operator is expected to perform no action on self-assignment , and to return the lhs by reference:

The canonical move assignment is expected to leave the moved-from object in valid state (that is, a state with class invariants intact), and either do nothing or at least leave the object in a valid state on self-assignment, and return the lhs by reference to non-const, and be noexcept:

In those situations where copy assignment cannot benefit from resource reuse (it does not manage a heap-allocated array and does not have a (possibly transitive) member that does, such as a member std::vector or std::string ), there is a popular convenient shorthand: the copy-and-swap assignment operator, which takes its parameter by value (thus working as both copy- and move-assignment depending on the value category of the argument), swaps with the parameter, and lets the destructor clean it up.

This form automatically provides strong exception guarantee , but prohibits resource reuse.

Stream extraction and insertion

The overloads of operator>> and operator<< that take a std:: istream & or std:: ostream & as the left hand argument are known as insertion and extraction operators. Since they take the user-defined type as the right argument ( b in a@b ), they must be implemented as non-members.

These operators are sometimes implemented as friend functions .

Function call operator

When a user-defined class overloads the function call operator, operator ( ) , it becomes a FunctionObject type. Many standard algorithms, from std:: sort to std:: accumulate accept objects of such types to customize behavior. There are no particularly notable canonical forms of operator ( ) , but to illustrate the usage

Increment and decrement

When the postfix increment and decrement appear in an expression, the corresponding user-defined function ( operator ++ or operator -- ) is called with an integer argument 0 . Typically, it is implemented as T operator ++ ( int ) , where the argument is ignored. The postfix increment and decrement operator is usually implemented in terms of the prefix version:

Although canonical form of pre-increment/pre-decrement returns a reference, as with any operator overload, the return type is user-defined; for example the overloads of these operators for std::atomic return by value.

Binary arithmetic operators

Binary operators are typically implemented as non-members to maintain symmetry (for example, when adding a complex number and an integer, if operator+ is a member function of the complex type, then only complex + integer would compile, and not integer + complex ). Since for every binary arithmetic operator there exists a corresponding compound assignment operator, canonical forms of binary operators are implemented in terms of their compound assignments:

Relational operators

Standard algorithms such as std:: sort and containers such as std:: set expect operator < to be defined, by default, for the user-provided types, and expect it to implement strict weak ordering (thus satisfying the Compare requirements). An idiomatic way to implement strict weak ordering for a structure is to use lexicographical comparison provided by std::tie :

Typically, once operator < is provided, the other relational operators are implemented in terms of operator < .

Likewise, the inequality operator is typically implemented in terms of operator == :

When three-way comparison (such as std::memcmp or std::string::compare ) is provided, all six relational operators may be expressed through that:

Array subscript operator

User-defined classes that provide array-like access that allows both reading and writing typically define two overloads for operator [ ] : const and non-const variants:

If the value type is known to be a built-in type, the const variant should return by value.

Where direct access to the elements of the container is not wanted or not possible or distinguishing between lvalue c [ i ] = v ; and rvalue v = c [ i ] ; usage, operator[] may return a proxy. see for example std::bitset::operator[] .

To provide multidimensional array access semantics, e.g. to implement a 3D array access a [ i ] [ j ] [ k ] = x ; , operator[] has to return a reference to a 2D plane, which has to have its own operator[] which returns a reference to a 1D row, which has to have operator[] which returns a reference to the element. To avoid this complexity, some libraries opt for overloading operator ( ) instead, so that 3D access expressions have the Fortran-like syntax a ( i, j, k ) = x ;

Bitwise arithmetic operators

User-defined classes and enumerations that implement the requirements of BitmaskType are required to overload the bitwise arithmetic operators operator & , operator | , operator ^ , operator~ , operator & = , operator | = , and operator ^ = , and may optionally overload the shift operators operator << operator >> , operator >>= , and operator <<= . The canonical implementations usually follow the pattern for binary arithmetic operators described above.

Boolean negation operator

The operator operator ! is commonly overloaded by the user-defined classes that are intended to be used in boolean contexts. Such classes also provide a user-defined conversion function explicit operator bool ( ) (see std::basic_ios for the standard library example), and the expected behavior of operator ! is to return the value opposite of operator bool .

Rarely overloaded operators

The following operators are rarely overloaded:

• The address-of operator, operator & . If the unary & is applied to an lvalue of incomplete type and the complete type declares an overloaded operator & , the behavior is undefined (until C++11) it is unspecified whether the operator has the built-in meaning or the operator function is called (since C++11) . Because this operator may be overloaded, generic libraries use std::addressof to obtain addresses of objects of user-defined types. The best known example of a canonical overloaded operator& is the Microsoft class CComPtr . An example of its use in EDSL can be found in boost.spirit .
• The boolean logic operators, operator && and operator || . Unlike the built-in versions, the overloads cannot implement short-circuit evaluation. Also unlike the built-in versions, they do not sequence their left operand before the right one. (until C++17) In the standard library, these operators are only overloaded for std::valarray .
• The comma operator, operator, . Unlike the built-in version, the overloads do not sequence their left operand before the right one. (until C++17) Because this operator may be overloaded, generic libraries use expressions such as a, void ( ) ,b instead of a,b to sequence execution of expressions of user-defined types. The boost library uses operator, in boost.assign , boost.spirit , and other libraries. The database access library SOCI also overloads operator, .
• The member access through pointer to member operator - > * . There are no specific downsides to overloading this operator, but it is rarely used in practice. It was suggested that it could be part of smart pointer interface , and in fact is used in that capacity by actors in boost.phoenix . It is more common in EDSLs such as cpp.react .

Defect reports

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

• Operator precedence
• Alternative operator syntax

• ↑ Operator Overloading on StackOverflow C++ FAQ

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

Assignment Operator Overload in c++

I realize that there are examples after examples of overloading the assignment operator on the web, but I have spent the last few hours trying to implement them in my program and figure out how they work and I just can't seem to do it and any help would be greatly appreciated.

I am trying to implement an overloaded assignment operator function.

I have 3 files working, the Complex.h header file, a Complex.cpp definition file, and a .cpp file I'm using as a driver to test my Complex class.

In the Complex.h header file my prototype for the assignment operator:

And so far what I have for the definition of the overloaded operator in my .cpp file is:

And the way I'm calling my assignment operator in my functions is:

So specifically, my problem is that when I call the overloaded assignment operator with x = y -z, it doesn't assign the passed in value to x when I return the passed in value and I'm unable to figure out why from numerous examples and explanations on the web, any help would be greatly appreciated and I thank you for any help ahead of time.

• operator-overloading
• assignment-operator

• 1 Why don't you read some of those examples after examples and model your assignment operator on one that actually works? –  juanchopanza Commented Mar 28, 2015 at 16:03
• = shouldn't probably modify its right hand operand. –  Emil Laine Commented Mar 28, 2015 at 16:03
• @juanchopanza I tried that, and I apologize for this and sincerely appreciate your input, but my brain just doesn't work this way, I did try to read those examples and model after those working examples but it would end in recursion. –  Prog Commented Mar 28, 2015 at 16:08
• @zenith So you're saying that by returning first I am modifying the right hand operand? –  Prog Commented Mar 28, 2015 at 16:08
• No, he clearly does not modify the right-hand-operand. –  Puppy Commented Mar 28, 2015 at 16:09

3 Answers 3

I think you need the following operator definition

You have to return reference to the object that is assigned to. Also the parameter should be a constant reference. In this case you may bind the reference to a temporary object or you have to write also a move assignment operator.

In your implementation of the copy assignment operator you do not change the assigned object.:) You simply create a temporary and return reference to this temporary or return reference to first.

• Whilst strictly accurate, this isn't that helpful as it doesn't really explain to the OP why you've written it that way. –  Puppy Commented Mar 28, 2015 at 16:09
• If I understand your method correctly I should assign to the real and imaginary private data members to create a new Complex object and then return the created Complex object with the address of the current (this) data member? –  Prog Commented Mar 28, 2015 at 16:15
• @DastardlyDeedDoer No, assignment should not create a new object (unless as an intermediary implementation detail). It assigns a value to an existing one. –  juanchopanza Commented Mar 28, 2015 at 16:16
• @juanchopanza You're saying I'm creating a new object by returning first? But isn't it already created because I called the overloaded operator with it? So I'm just returning the passed in value? Or is my understanding of this way off? –  Prog Commented Mar 28, 2015 at 16:20
• @DastardlyDeedDoer No, I am saying you don't create an new object and you shouldn't. I mean, you in your broken code do, but the code in this answer doesn't. –  juanchopanza Commented Mar 28, 2015 at 16:21

Assignment takes in two objects, the object to be assigned to, and the object with the desired value.

Assignment should:

• modify an existing object, the object being assigned to

Assignment should not:

• create a new object
• modify the object that has the desired value.

So let's say the object type we're dealing with is:

A function that performs assignment might have the signature:

And it would be used:

• the left hand side object is modifiable, and assignment will modify it, rather than create a new object.
• the right hand side object, the object with the desired value, is not modifiable.

Additionally, in C++ the built-in assignment operation is an expression rather than a statement; it has a value and can be used as a subexpression:

This sets j equal to k, and then takes the result of that assignment and prints it out. The important thing to note is that the result of the assignment expression is the object that was assigned to . No new object is created. In the above code, the value of j is printed (which is 10, because j was just assigned the value 10 from k ).

Updating our earlier assignment function to follow this convention results in a signature like:

S &assignment(S &left_hand_side, S const &right_hand_side);

An implementation looks like:

Note that this assignment function is not recursive; it does not use itself in the assignment, but it does use assignment of the member types .

The final piece of the puzzle is getting the syntax a = b to work, instead of assignment(a, b) . In order to do this, all you have to do is make assignment () a member function:

Replace the left_hand_side argument with *this :

And rename the function to operator= :

Another important thing to know is that the = sign is used in one place that is not assignment:

This is 'copy initialization'. It does not use operator= . It is not assignment. Try not to confuse the two.

Points to remember:

• assignment modifies the object being assigned to
• assignment does not modify the object being assigned from.
• assignment does not create a new object.
• assignment is not recursive, except insofar as assignment of a compound object makes use of assignment on all the little member objects it contains.
• assignment returns the object after modifying its value
• copy initialization looks sort of like assignment, but has little to do with assignment.

• I know this was posted awhile back - but its a really thoughtful answer and should be preserved. –  Don Shanil Commented May 7, 2021 at 11:58

An overloaded assignment operator should look like this:

You should also note, that if you overload the assignment operator you should overload the copy constructor for Complex in the same manner:

• This is a double fail. First, you overloaded = but made it do == , and secondly, self-assignment is for out-of-date lecturers and not for real-world use –  Puppy Commented Mar 28, 2015 at 16:06
• I have the code for the equality operator working just fine in later code, I need to be able to modify the left hand operand (the x) when I return the value from the assignment operator function. –  Prog Commented Mar 28, 2015 at 16:09
• @DastardlyDeedDoer "I need to be able to modify the left hand operand (the x) when I return the value from the assignment operator function." My example will exactly do this. –  πάντα ῥεῖ Commented Mar 28, 2015 at 16:11
• @Puppy I totally agree and that is a major reason I'm here asking for help, all of the coding I do doesn't do such round about crap. But this is for a class I'm taking and I will get little credit if I don't get this too work. But mostly my reason for the use of the equality operator is to avoid self-assignment, unless I'm going about that the wrong way too. –  Prog Commented Mar 28, 2015 at 16:12
• 1 @Puppy There is a very important use case where you simply have to check for self-assignment: Job interviews. ;-) –  Greenflow Commented Mar 28, 2015 at 19:09

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

• The Overflow Blog
• Scaling systems to manage all the metadata ABOUT the data
• Navigating cities of code with Norris Numbers
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• Feedback requested: How do you use tag hover descriptions for curating and do...

Hot Network Questions

• Finding the maximum squared distance between a pair of coordinates from a set of coordinates
• How to cite a book if only its chapters have DOIs?
• MOSFETs keep shorting way below rated current
• Caulking Bathtub and Wall Surround to prevent water leak
• How to Increase a Length in Inches by a Point without Manual Conversion?
• What is this houseplant with a red fleshy stem and thick waxy leaves?
• Erase the loops
• A short story about a demon, in a modernising Japan, living in electric wires and starting fires
• DIN Rail Logic Gate
• tmux - How to remove delay after pressing prefix key and Up key
• Dual UK/CAN national travelling from UK to Canada and back - which passport should I use to book tickets?
• Cleveref, biblatex and automatic equation numbering
• If Venus had a sapient civilisation similar to our own prior to global resurfacing, would we know it?
• Who became an oligarch after the collapse of the USSR
• How can I obscure branding on the side of a pure white ceramic sink?
• Why did evolution fail to protect humans against sun?
• Cumulative Addition of Index Switch Node Values
• Why is my differential equation for mass-spring-damper model not converging with ode45 in MATLAB?
• Clean up verbose code for Oracle SQL
• Stargate "instructional" videos
• Base change in Chriss-Ginzburg
• Car LED circuit
• Do "Whenever X becomes the target of a spell" abilities get triggered by counterspell?
• Does the First Amendment protect deliberately publicizing the incorrect date for an election?