overload assignment operator in template

21.14 — Overloading operators and function templates

In lesson 11.7 -- Function template instantiation , we discussed how the compiler will use function templates to instantiate functions, which are then compiled. We also noted that these functions may not compile, if the code in the function template tries to perform some operation that the actual type doesn’t support (such as adding integer value 1 to a std::string ).

In this lesson, we’ll take a look at a few examples where our instantiated functions won’t compile because our actual class types don’t support those operators, and show how we can define those operators so that the instantiated functions will then compile.

Operators, function calls, and function templates

First, let’s create a simple class:

and define a max function template:

Now, let’s see what happens when we try to call max() with object of type Cents :

C++ will create a template instance for max() that looks like this:

And then it will try to compile this function. See the problem here? C++ has no idea how to evaluate x < y when x and y are of type Cents ! Consequently, this will produce a compile error.

To get around this problem, simply overload operator< for any class we wish to use max with:

This works as expected, and prints:

Another example

Let’s do one more example of a function template not working because of missing overloaded operators.

The following function template will calculate the average of a number of objects in an array:

This produces the values:

As you can see, it works great for built-in types!

Now let’s see what happens when we call this function on our Cents class:

The compiler goes berserk and produces a ton of error messages! The first error message will be something like this:

Remember that average() returns a Cents object, and we are trying to stream that object to std::cout using operator<< . However, we haven’t defined the operator<< for our Cents class yet. Let’s do that:

If we compile again, we will get another error:

This error is actually being caused by the function template instance created when we call average(const Cents*, int) . Remember that when we call a templated function, the compiler “stencils” out a copy of the function where the template type parameters (the placeholder types) have been replaced with the actual types in the function call. Here is the function template instance for average() when T is a Cents object:

The reason we are getting an error message is because of the following line:

In this case, sum is a Cents object, but we have not defined operator+= for Cents objects! We will need to define this function in order for average() to be able to work with Cents . Looking forward, we can see that average() also uses the operator/= , so we will go ahead and define that as well:

Finally, our code will compile and run! Here is the result:

Note that we didn’t have to modify average() at all to make it work with objects of type Cents . We simply had to define the operators used to implement average() for the Cents class, and the compiler took care of the rest!

How to Implement Assignment Operator Overloading in C++

• How to Implement Assignment Operator …

This article will explain several methods of how to implement assignment operator overloading in C++.

Use copy-assignment operator to Implement Overloaded Assignment Operator in C++

C++ provides the feature to overload operators, a common way to call custom functions when a built-in operator is called on specific classes. These functions should have a special name starting with operator followed by the specific operator symbol itself. E.g., a custom assignment operator can be implemented with the function named operator= . Assignment operator generally should return a reference to its left-hand operand. Note that if the user does not explicitly define the copy assignment operator, the compiler generates one automatically. The generated version is quite capable when the class does not contain any data members manually allocated on the heap memory. It can even handle the array members by assigning each element to the corresponding object members. Although, it has shortcomings when dealing with dynamic memory data members, as shown in the following example code.

The above code defines only copy-constructor explicitly, which results in incorrect behavior when P1 object contents are assigned to the P3 object. Note that the second call to the P1.renamePerson function should not have modified the P3 object’s data members, but it did. The solution to this is to define an overloaded assignment operator i.e., copy-assignment operator. The next code snippet implements the version of the Person class that can copy assign the two objects of the same class correctly. Notice, though, the if statement in the copy-assignment function guarantees that the operator works correctly even when the object is assigned to itself.

Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.

Related Article - C++ Class

• How to Initialize Static Variables in C++ Class
• How to Get Class Name in C++
• Point and Line Class in C++
• Class Template Inheritance in C++
• Difference Between Structure and Class in C++
• Wrapper Class in C++

• Windows Programming
• UNIX/Linux Programming
• General C++ Programming
• Overloaded assignment operator for class

    Overloaded assignment operator for class template objects

# Operator Overloading

(opens new window) .

# Array subscript operator

You can even overload the array subscript operator [] .

You should always (99.98% of the time) implement 2 versions, a const and a not- const version, because if the object is const , it should not be able to modify the object returned by [] .

The arguments are passed by const& instead of by value because passing by reference is faster than by value, and const so that the operator doesn't change the index accidentally.

The operators return by reference, because by design you can modify the object [] return, i.e:

You can only overload inside a class / struct :

Multiple subscript operators, [][]... , can be achieved via proxy objects. The following example of a simple row-major matrix class demonstrates this:

# Arithmetic operators

You can overload all basic arithmetic operators:

• & and &=
• >> and >>=
• << and <<=

Overloading for all operators is the same. Scroll down for explanation

Overloading outside of class / struct :

Overloading inside of class / struct :

Note: operator+ should return by non-const value, as returning a reference wouldn't make sense (it returns a new object) nor would returning a const value (you should generally not return by const ). The first argument is passed by value, why? Because

• You can't modify the original object ( Object foobar = foo + bar; shouldn't modify foo after all, it wouldn't make sense)
• You can't make it const , because you will have to be able to modify the object (because operator+ is implemented in terms of operator+= , which modifies the object)

Passing by const& would be an option, but then you will have to make a temporary copy of the passed object. By passing by value, the compiler does it for you.

operator+= returns a reference to the itself, because it is then possible to chain them (don't use the same variable though, that would be undefined behavior due to sequence points).

The first argument is a reference (we want to modify it), but not const , because then you wouldn't be able to modify it. The second argument should not be modified, and so for performance reason is passed by const& (passing by const reference is faster than by value).

# Conversion operators

You can overload type operators, so that your type can be implicitly converted into the specified type.

The conversion operator must be defined in a class / struct :

Note: the operator is const to allow const objects to be converted.

# Complex Numbers Revisited

The code below implements a very simple complex number type for which the underlying field is automatically promoted, following the language's type promotion rules, under application of the four basic operators (+, -, *, and /) with a member of a different field (be it another complex<T> or some scalar type).

This is intended to be a holistic example covering operator overloading alongside basic use of templates.

# Unary operators

You can overload the 2 unary operators:

• ++foo and foo++
• --foo and foo--

Overloading is the same for both types ( ++ and -- ). Scroll down for explanation

Note: The prefix operator returns a reference to itself, so that you can continue operations on it. The first argument is a reference, as the prefix operator changes the object, that's also the reason why it isn't const (you wouldn't be able to modify it otherwise).

The postfix operator returns by value a temporary (the previous value), and so it cannot be a reference, as it would be a reference to a temporary, which would be garbage value at the end of the function, because the temporary variable goes out of scope). It also cannot be const , because you should be able to modify it directly.

The first argument is a non- const reference to the "calling" object, because if it were const , you wouldn't be able to modify it, and if it weren't a reference, you wouldn't change the original value.

It is because of the copying needed in postfix operator overloads that it's better to make it a habit to use prefix ++ instead of postfix ++ in for loops. From the for loop perspective, they're usually functionally equivalent, but there might be a slight performance advantage to using prefix ++, especially with "fat" classes with a lot of members to copy. Example of using prefix ++ in a for loop:

# Comparison operators

You can overload all comparison operators:

• > and <
• >= and <=

The recommended way to overload all those operators is by implementing only 2 operators ( == and < ) and then using those to define the rest. Scroll down for explanation

The operators obviously return a bool , indicating true or false for the corresponding operation.

All of the operators take their arguments by const& , because the only thing that does operators do is compare, so they shouldn't modify the objects. Passing by & (reference) is faster than by value, and to make sure that the operators don't modify it, it is a const -reference.

Note that the operators inside the class / struct are defined as const , the reason for this is that without the functions being const , comparing const objects would not be possible, as the compiler doesn't know that the operators don't modify anything.

# Assignment operator

The assignment operator is one of the most important operators because it allows you to change the status of a variable.

If you do not overload the assigment operator for your class / struct , it is automatically generated by the compiler: the automatically-generated assignment operator performs a "memberwise assignment", ie by invoking assignment operators on all members, so that one object is copied to the other, a member at time. The assignment operator should be overloaded when the simple memberwise assignment is not suitable for your class / struct , for example if you need to perform a deep copy of an object.

Overloading the assignment operator = is easy, but you should follow some simple steps.

• **Test for self-assignment.** This check is important for two reasons: 1. a self-assignment is a needless copy, so it does not make sense to perform it; 1. the next step will not work in the case of a self-assignment.

Note: other is passed by const& , because the object being assigned should not be changed, and passing by reference is faster than by value, and to make sure than operator= doesn't modify it accidentally, it is const .

The assignment operator can only to be overloaded in the class / struct , because the left value of = is always the class / struct itself. Defining it as a free function doesn't have this guarantee, and is disallowed because of that.

When you declare it in the class / struct , the left value is implicitly the class / struct itself, so there is no problem with that.

# Named operators

You can extend C++ with named operators that are "quoted" by standard C++ operators.

First we start with a dozen-line library:

this doesn't do anything yet.

First, appending vectors

The core here is that we define an append object of type append_t:named_operator::make_operator<append_t> .

We then overload named_invoke( lhs, append_t, rhs ) for the types we want on the right and left.

The library overloads lhs*append_t , returning a temporary half_apply object. It also overloads half_apply*rhs to call named_invoke( lhs, append_t, rhs ) .

We simply have to create the proper append_t token and do an ADL-friendly named_invoke of the proper signature, and everything hooks up and works.

For a more complex example, suppose you want to have element-wise multiplication of elements of a std::array:

This element-wise array code can be extended to work on tuples or pairs or C-style arrays, or even variable length containers if you decide what to do if the lengths don't match.

You could also an element-wise operator type and get lhs *element_wise<'+'>* rhs .

Writing a *dot* and *cross* product operators are also obvious uses.

The use of * can be extended to support other delimiters, like + . The delimeter precidence determines the precidence of the named operator, which may be important when translating physics equations over to C++ with minimal use of extra () s.

With a slight change in the library above, we can support ->*then* operators and extend std::function prior to the standard being updated, or write monadic ->*bind* . It could also have a stateful named operator, where we carefully pass the Op down to the final invoke function, permitting:

generating a named container-appending operator in C++17.

# Function call operator

You can overload the function call operator () :

Overloading must be done inside of a class / struct :

For example:

# Bitwise NOT operator

Overloading the bitwise NOT ( ~ ) is fairly simple. Scroll down for explanation

Note: operator~ returns by value, because it has to return a new value (the modified value), and not a reference to the value (it would be a reference to the temporary object, which would have garbage value in it as soon as the operator is done). Not const either because the calling code should be able to modify it afterwards (i.e. int a = ~a + 1; should be possible).

Inside the class / struct you have to make a temporary object, because you can't modify this , as it would modify the original object, which shouldn't be the case.

# Bit shift operators for I/O

The operators << and >> are commonly used as "write" and "read" operators:

• std::ostream overloads << to write variables to the underlying stream (example: std::cout )
• std::istream overloads >> to read from the underlying stream to a variable (example: std::cin )

The way they do this is similar if you wanted to overload them "normally" outside of the class / struct , except that specifying the arguments are not of the same type:

• Return type is the stream you want to overload from (for example, std::ostream ) passed by reference, to allow chaining (Chaining: std::cout << a << b; ). Example: std::ostream&
• lhs would be the same as the return type
• rhs is the type you want to allow overloading from (i.e. T ), passed by const& instead of value for performance reason ( rhs shouldn't be changed anyway). Example: const Vector& .

The operators for built-in types cannot be changed, operators can only be overloaded for user-defined types. That is, at least one of the operands has to be of a user-defined type.

The following operators cannot be overloaded:

• The member access or "dot" operator .
• The pointer to member access operator .*
• The scope resolution operator, ::
• The ternary conditional operator, ?:
• dynamic_cast , static_cast , reinterpret_cast , const_cast , typeid , sizeof , alignof , and noexcept
• The preprocessing directives, # and ## , which are executed before any type information is available.

There are some operators that you should not (99.98% of the time) overload:

• && and || (prefer, instead, to use implicit conversion to bool )
• The address-of operator (unary & )

Why? Because they overload operators that another programmer might never expect, resulting in different behavior than anticipated.

(opens new window) , the sequencing issue also applies to , operator overloads.

← Function Overloading Function Template Overloading →

cppreference.com

Operator overloading.

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

[ edit ] Syntax

Overloaded operators are functions with special function names:

[ edit ] 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 co_await , (since C++20) 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:

[ edit ] 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.
• It is not possible to change the precedence, grouping, or number of operands of operators.
• 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.
• The overloads of operators && and || lose short-circuit evaluation.

[ edit ] Canonical implementations

Besides 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]

[ edit ] 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 be safe on self-assignment , and to return the lhs by reference:

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.

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

[ edit ] Function call operator

When a user-defined class overloads the function call operator, operator ( ) , it becomes a FunctionObject type.

An object of such a type can be used in a function call expression:

Many standard algorithms, from std:: sort to std:: accumulate accept FunctionObject s to customize behavior. There are no particularly notable canonical forms of operator ( ) , but to illustrate the usage:

[ edit ] Increment and decrement

When the postfix increment or decrement operator appears 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 ) or T operator -- ( int ) , where the argument is ignored. The postfix increment and decrement operators are usually implemented in terms of the prefix versions:

Although the canonical implementations of the prefix increment and decrement operators return by 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.

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

[ edit ] Comparison 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 two-way comparison operators may be expressed through that:

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

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

[ edit ] Boolean negation operator

[ edit ] 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 & , it is unspecified whether the operator has the built-in meaning or the operator function is called. 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 CComPtrBase . An example of this operator's 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 a 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 .

[ edit ] Notes

[ edit ] example, [ edit ] defect reports.

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

[ edit ] See also

• Operator precedence
• Alternative operator syntax
• Argument-dependent lookup

[ edit ] External links

• 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 30 April 2024, at 17:49.
• This page has been accessed 5,484,942 times.
• Privacy policy
• About cppreference.com
• Disclaimers

• C++ Classes and Objects
• C++ Polymorphism
• C++ Inheritance
• C++ Abstraction
• C++ Encapsulation
• C++ OOPs Interview Questions
• C++ OOPs MCQ
• C++ Interview Questions
• C++ Function Overloading
• C++ Programs
• C++ Preprocessor
• C++ Templates

Overloading Subscript or array index operator [] in C++

• Relational Operators on STL Array in C++
• Operator Overloading in C++
• Types of Operator Overloading in C++
• Input/Output Operators Overloading in C++
• Overloading New and Delete operator in c++
• Overloading stream insertion (<>) operators in C++
• Overloading Relational Operators in C++
• Overloading of function-call operator in C++
• Increment (++) and Decrement (--) Operator Overloading in C++
• How to Overload == Operator in C++?
• Operator Overloading in Ruby
• C++ | Operator Overloading | Question 2
• C++ | Operator Overloading | Question 4
• C++ | Operator Overloading | Question 9
• C++ | Operator Overloading | Question 3
• C++ | Operator Overloading | Question 7
• C++ | Operator Overloading | Question 5
• C++ | Operator Overloading | Question 10
• Operator Overloading in Julia

The Subscript or Array Index Operator is denoted by ‘[]’. This operator is generally used with arrays to retrieve and manipulate the array elements. This is a binary or n-ary operator and is represented in two parts:

• postfix/primary expression

The postfix expression, also known as the primary expression, is a pointer value such as array or identifiers and the second expression is an integral value. In the second expression we can also include the enumerated values.

The primary-expression followed by the subscript operator is the pointer and it can be an integral value but the one must keep in mind that one of expression among two expressions must be a pointer value and it does not matter whether the second one is of an integral order or not.

Explanation:

In the above example both “cout” statement provides similar output due to the exclusive property of the subscript operator. The compiler reads both the statement in a similar way, so there is no difference between the

*(name + 5)

*(5 + name)

Positive and Negative subscripts

The first element of an array is stored at index 0. The range of a C++ array is from array[0] to array[size – 1]. However, C++ supports positive and negative subscripts. Negative subscripts must fall within array boundaries; if they do not, the results are unpredictable. The following code shows positive and negative array subscripts:

The negative subscript in the last line can produce a run-time error because it points to an address -256 positions which can be lower in memory than the origin of the array. The pointer midArray is initialized to the middle of intArray; it is therefore possible (but not recommended) to use both positive and negative array indices simultaneously. Array subscript errors do not generate compile-time errors, but they might yield unpredictable results. We have introduced

operator overloading

. In this post overloading of index operator [] is discussed. Following are some useful facts about overloading of []. 1) Overloading of [] may be useful when we want to check for index out of bound. 2) We must return by reference in function because an expression like “arr[i]” can be used an lvalue. Following is C++ program to demonstrate overloading of array index operator [].

Please Login to comment...

Similar reads.

• cpp-operator-overloading
• cpp-overloading

Improve your Coding Skills with Practice

What kind of Experience do you want to share?