overloading assignment operator in c program

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

Because a subscript operator can only take one subscript until C++23, 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 ; .

[ 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 9 October 2023, at 05:12.
• This page has been accessed 5,317,006 times.
• Privacy policy
• About cppreference.com
• Disclaimers

Code With C

The Way to Programming

• C Tutorials
• Java Tutorials
• Python Tutorials
• PHP Tutorials
• Java Projects

Mastering Operator Overloads: A Comprehensive Guide

Hey there, tech-savvy pals! Today, I’m diving headfirst into the fabulous world of operator overloads! 🚀 As an code-savvy friend 😋 with killer coding chops, I know the buzz around mastering these bad boys is real. So buckle up, grab your chai ☕, and let’s unravel the magic of operator overloads together!

Understanding Operator Overloads

Definition of operator overloads.

Operator overloading, my fellow code enthusiasts, is a fancy way of giving superpowers to those operators (+, -, *, /) in programming languages . It’s like teaching an old dog new tricks! 🐕✨

Importance of Operator Overloads in Programming

Why bother with operator overloads , you ask? Well, they make your code elegant, efficient, and oh-so-fancy! Imagine customizing how your objects behave with just a simple operator. It’s like painting with a broad brush! 🎨

Overloading Unary Operators

Explanation of unary operators.

Unary operators, folks, work on a single operand. Think of them as the solo artists of the programming world, strutting their stuff like Beyoncé on stage! 💃🎤

Examples of Overloading Unary Operators

Picture this: overloading the ++ operator to increment a value or the ~ operator to complement a binary number . It’s like jazzing up your code with some killer solos! 🎸🎶

Overloading Binary Operators

Explanation of binary operators.

Now, binary operators are the dynamic duos of the coding universe, working their magic on two operands like peanut butter and jelly! 🥪✨

Examples of Overloading Binary Operators

From overloading the + operator to concatenate strings to using the == operator to compare custom objects, the possibilities are endless! It’s like salsa dancing with your code! 💃💻

Best Practices for Operator Overloads

Avoiding ambiguity in operator overloads.

Ah, the dreaded ambiguity! To steer clear of the confusion, make sure your operator overloads have clear semantics and don’t leave room for misinterpretation. It’s like speaking fluently in code! 💬💻

Choosing the Right Operator Overload for Different Data Types

Different data types , different strokes! Be mindful of choosing the right operator overload to ensure smooth sailing across various data types . It’s like matching the right shoes with your outfit!👠👗

Common Challenges in Operator Overloads

Handling error cases in operator overloads.

Errors? Ain’t nobody got time for that! Make sure to handle those pesky error cases gracefully in your operator overloads. It’s like being the calm in the coding storm! 🌪️💻

Ensuring Consistency in Operator Overloads

Consistency is key, my pals! Keep your operator overloads consistent across your codebase for that smooth coding experience. It’s like creating a symphony of code! 🎶💻

Overall, mastering operator overloads is like adding spices to your favorite dish – it brings out the flavor and makes it oh-so-delicious! Remember, with great power comes great responsibility, so wield those operator overloads wisely, my coding comrades! 💻✨

Stay techy, stay sassy! Adios, amigos! ✌️🚀

Program Code – Mastering Operator Overloads: A Comprehensive Guide

Code output:.

The output of the given code snippet, when run, will be:

Code Explanation:

The program defines a class ComplexNumber to represent complex numbers and provide operator overloads for common mathematical operations.

• The __init__ method initializes each complex number with a real and an imaginary component.
• The __repr__ method allows us to print complex number objects in a way that’s human-readable, showing the real and imaginary parts.
• The __add__ method enables the use of the + operator to add two complex numbers, resulting in a new complex number whose real and imaginary parts are the sums of the real and imaginary parts of the operands, respectively.
• The __sub__ method allows the use of the - operator to subtract one complex number from another, yielding the differences in real and imaginary parts.
• __mul__ describes how two complex numbers are multiplied by employing the * operator, using the standard formula for complex multiplication.
• __truediv__ enables division with the / operator. It uses the conjugate to divide complex numbers, following standard rules for complex division.
• The __eq__ method defines how two complex numbers are compared for equality using == . It returns True if both the real and imaginary parts are equal, otherwise False.
• The __ne__ method defines inequality check ( != ) and it yields True if the complex numbers are not equal.

The code then creates two complex number instances, a and b , and performs addition , subtraction, multiplication, division, and equality checks, displaying the results. Each mathematical operation utilizes the overloaded operator corresponding to it, demonstrating the power and flexibility of operator overloading in Python.

You Might Also Like

Revolutionary feedback control project for social networking: enhancing information spread, the evolution of web development: past, present, and future, defining the future: an overview of software services, exploring the layers: the multifaceted world of software, deep dive: understanding the ‘case when’ clause in sql.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Latest Posts

IEEE Approved Draft Standard Project for Port-Based Network Access Control in Local and Metropolitan Area Networks

EARS Project: Optimizing Software-Defined Networking with Intelligence-driven Experiential Network Architecture

Emotion Correlation Mining Project: Deep Learning Models on Natural Language Text

Unleashing Social Boosted Recommendation: Folded Bipartite Network Project

Unlock the Future: Efficiently Updating Publicly Verifiable Databases Project

Privacy overview.

Sign in to your account

Username or Email Address

Remember Me

Overloading assignments (C++ only)

• Copy assignment operators (C++ only)
• Assignment operators

• C++ Overview
• C++ Environment Setup
• C++ Basic Syntax
• C++ Comments
• C++ Data Types
• C++ Variable Types
• C++ Variable Scope
• C++ Constants/Literals
• C++ Modifier Types
• C++ Storage Classes
• C++ Operators
• C++ Loop Types
• C++ Decision Making
• C++ Functions
• C++ Numbers
• C++ Strings
• C++ Pointers
• C++ References
• C++ Date & Time
• C++ Basic Input/Output
• C++ Data Structures
• C++ Object Oriented
• C++ Classes & Objects
• C++ Inheritance
• C++ Overloading
• C++ Polymorphism
• C++ Abstraction
• C++ Encapsulation
• C++ Interfaces
• C++ Advanced
• C++ Files and Streams
• C++ Exception Handling
• C++ Dynamic Memory
• C++ Namespaces
• C++ Templates
• C++ Preprocessor
• C++ Signal Handling
• C++ Multithreading
• C++ Web Programming
• C++ Useful Resources
• C++ Questions and Answers
• C++ Quick Guide
• C++ STL Tutorial
• C++ Standard Library
• C++ Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Assignment Operators Overloading in C++

You can overload the assignment operator (=) just as you can other operators and it can be used to create an object just like the copy constructor.

Following example explains how an assignment operator can be overloaded.

When the above code is compiled and executed, it produces the following result −

• All Platforms
• First Naukri
• All Companies
• Cognizant GenC
• Cognizant GenC Next
• Cognizant GenC Elevate
• Goldman Sachs
• Infosys SP and DSE
• TCS CodeVita
• TCS Digital
• TCS iON CCQT
• TCS Smart Hiring
• Tech Mahindra
• Zs Associates

• Top 100 Codes
• Learn Python
• Learn Data Structures
• Learn Competitve & Advanced Coding
• Learn Operating System
• Software Engineering
• Online Compiler
• Microsoft Coding Questions
• Amazon Coding Questions

• Learn Logical
• Learn Verbal
• Learn Data Interp.
• Psychometric Test

• All Syllabus
• Cognizant-Off Campus
• L&T Infotech
• Mahindra ComViva
• Reliance Jio
• Wells Fargo
• ZS-Associates

• Interview Preparation
• HR Interview
• Virtual Interview
• Technical Interview
• Group Discussions

• All Interview Exp.
• Accenture ASE
• ZS Associates

• Get OffCampus updates
• On Instagram
• On LinkedIn
• On Telegram
• On Whatsapp
• AMCAT vs CoCubes vs eLitmus vs TCS iON CCQT
• Companies hiring via TCS iON CCQT
• Companies hiring via CoCubes
• Companies hiring via AMCAT
• Companies hiring via eLitmus
• Companies hiring from AMCAT, CoCubes, eLitmus
• Prime Video
• PrepInsta Prime
• The Job Company
• Placement Stats

Notifications Mark All Read

TCS NQT OffCampus Hiring Announced for 2024 Batch

• Get Prime

Assignment Operator Overloading in C++

February 8, 2023

What is assignment operator overloading in C++?

The assignment operator is a binary operator that is used to assign the value to the variables. It is represented by equal to symbol(=). It copies the right value into the left value i.e the value that is on the right side of equal to into the variable that is on the left side of equal to.

Overloading assignment operator in C++

• Overloading assignment operator in C++ copies all values of one object to another object.
• The object from which values are being copied is known as an instance variable.
• A non-static member function should be used to overload the assignment operator.

The compiler generates the function to overload the assignment operator if the function is not written in the class. The overloading assignment operator can be used to create an object just like the copy constructor. If a new object does not have to be created before the copying occurs, the assignment operator is used, and if the object is created then the copy constructor will come into the picture. Below is a program to explain how the assignment operator overloading works.

C++ Introduction

History of C++

Structure of a C++ Program

String in C++

Program to check armstrong number or not

C++ program demonstrating assignment operator overloading

Prime course trailer, related banners.

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others

Checkout list of all the video courses in PrepInsta Prime Subscription

Login/Signup to comment

• [email protected]

What’s New ?

The Top 10 favtutor Features You Might Have Overlooked

• Don’t have an account Yet? Sign Up

Remember me Forgot your password?

• Already have an Account? Sign In

Lost your password? Please enter your email address. You will receive a link to create a new password.

Back to log-in

By Signing up for Favtutor, you agree to our Terms of Service & Privacy Policy.

Operator Overloading in C++ (Rules, Types & Program)

• Sep 13, 2023
• 5 Minute Read
• Why Trust Us We uphold a strict editorial policy that emphasizes factual accuracy, relevance, and impartiality. Our content is crafted by top technical writers with deep knowledge in the fields of computer science and data science, ensuring each piece is meticulously reviewed by a team of seasoned editors to guarantee compliance with the highest standards in educational content creation and publishing.
• By Abrar Ahmed

In C++, operator overloading allows you to redefine the behavior of operators for user-defined types. In this article, we will explore the concept of operator overloading in C++, including its types and how to use it in your C++ programs. 

What is Operator Overloading in C++?

Operator overloading in C++ is the ability to redefine the behavior of existing operators to work with user-defined types. It is a powerful feature that enables you to extend the functionality of operators to work with custom objects.

By overloading operators, you can provide custom implementations for operations such as addition, subtraction, comparison, and more, making your objects behave as if they were built-in types. This allows for a more intuitive and natural representation of operations involving your custom objects.

Syntax of Operator Overloading in C++

To overload an operator in C++, you need to define a function that implements the desired behavior for the operator. The function should have a specific name and signature based on the operator being overloaded.

The general syntax for operator overloading is as follows:

return_type operator symbol (parameters) { // Implementation of the operator behavior // ... }

Here, `return_type` specifies the type of the value returned by the operator overloading function. `operator` is the keyword used to indicate operator overloading, followed by the `symbol` of the operator being overloaded. The `parameters` represent the operands on which the operator is being applied.

Let's illustrate the syntax with an example of overloading the addition operator (+) for a custom class named `Vector`:

In this example, we overload the addition operator (+) for the `Vector` class. The `operator+` function takes a const reference to another `Vector` object as a parameter and returns a new `Vector` object. The implementation of the function performs the addition operation for the `x` and `y` components of the vectors and returns the result.

Types of Operator Overloading

C++ allows operator overloading for a wide range of operators, including arithmetic operators, comparison operators, assignment operators, and more. Some common operators that can be overloaded in C++ include:

• Arithmetic Operators: `+`, `-`, `*`, `/`, `%`
• Comparison Operators: `==`, `!=`, `<`, `>`, `<=`, `>=`
• Assignment Operators: `=`, `+=`, `-=`, `*=`, `/=`, `%=`
• Increment and Decrement Operators: `++`, `--`
• Subscript Operator: `[]`
• Function Call Operator: `()`
• Stream Insertion and Extraction Operators: `<<`, `>>`

Rules to Follow

When overloading operators in C++, it is essential to follow certain rules to ensure proper usage and maintain consistency. Here are some key rules to keep in mind:

• Overloaded operators must have at least one operand of a user-defined type.
• Precedence and associativity of operators cannot be changed through overloading.
• Overloaded operators cannot alter the number of operands.
• Overloaded operators retain their original meaning for built-in types.
• Some operators, such as the dot operator (`.`) and
• The ternary conditional operator (`?:`), cannot be overloaded.

C++ Program

To use operator overloading in your C++ program, follow these steps:

• Define a class for which you want to overload an operator.
• Implement a member function or a non-member function that defines the behavior of the operator for the class.
• Use the overloaded operator with objects of your class as operands.

Here's an example of using operator overloading to add two `Vector` objects:

In this program, we define a `Vector` class and overload the addition operator (+) using the `operator+` member function. We create two `Vector` objects, `v1` and `v2`, and add them together using the overloaded operator. The result is stored in the `sum` object and printed to the console.

By overloading operators, you can extend the functionality of operators to work seamlessly with your custom objects, providing a more intuitive and expressive programming experience. You can now leverage operator overloading effectively to enhance the usability and readability of your C++ code.

FavTutor - 24x7 Live Coding Help from Expert Tutors!

About The Author

Abrar Ahmed

More by favtutor blogs, monte carlo simulations in r (with examples), aarthi juryala.

The unlist() Function in R (with Examples)

Paired Sample T-Test using R (with Examples)

• 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

• C++ Programming Language

C++ Overview

• Introduction to C++ Programming Language
• Features of C++
• History of C++
• Interesting Facts about C++
• Setting up C++ Development Environment
• Difference between C and C++
• Writing First C++ Program - Hello World Example
• C++ Basic Syntax
• C++ Comments
• Tokens in C
• C++ Keywords
• Difference between Keyword and Identifier

C++ Variables and Constants

• C++ Variables
• Constants in C
• Scope of Variables in C++
• Storage Classes in C++ with Examples
• Static Keyword in C++

C++ Data Types and Literals

• C++ Data Types
• Literals in C
• Derived Data Types in C++
• User Defined Data Types in C++
• Data Type Ranges and their macros in C++
• C++ Type Modifiers
• Type Conversion in C++
• Casting Operators in C++

C++ Operators

• Operators in C++
• C++ Arithmetic Operators
• Unary operators in C
• Bitwise Operators in C
• Assignment Operators in C
• C++ sizeof Operator
• Scope resolution operator in C++

C++ Input/Output

• Basic Input / Output in C++
• cout in C++
• cerr - Standard Error Stream Object in C++
• Manipulators in C++ with Examples

C++ Control Statements

• 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++
• Jump statements in C++
• for Loop in C++
• Range-based for loop in C++
• C++ While Loop
• C++ Do/While Loop

C++ Functions

• Functions in C++
• return statement in C++ with Examples
• Parameter Passing Techniques in C
• Difference Between Call by Value and Call by Reference in C
• Default Arguments in C++
• Inline Functions in C++
• Lambda expression in C++

C++ Pointers and References

• Pointers and References in C++
• C++ Pointers
• Dangling, Void , Null and Wild Pointers in C
• Applications of Pointers in C
• Understanding nullptr in C++
• References in C++
• Can References Refer to Invalid Location in C++?
• Pointers vs References in C++
• Passing By Pointer vs Passing By Reference in C++
• When do we pass arguments by pointer?
• Variable Length Arrays (VLAs) in C
• Pointer to an Array | Array Pointer
• How to print size of array parameter in C++?
• Pass Array to Functions in C
• What is Array Decay in C++? How can it be prevented?

C++ Strings

• Strings in C++
• std::string class in C++
• Array of Strings in C++ - 5 Different Ways to Create
• String Concatenation in C++
• Tokenizing a string in C++
• Substring in C++

C++ Structures and Unions

• Structures, Unions and Enumerations in C++
• Structures in C++
• C++ - Pointer to Structure
• Self Referential Structures
• Difference Between C Structures and C++ Structures
• Enumeration in C++
• typedef in C++
• Array of Structures vs Array within a Structure in C

C++ Dynamic Memory Management

• Dynamic Memory Allocation in C using malloc(), calloc(), free() and realloc()
• new and delete Operators in C++ For Dynamic Memory
• new vs malloc() and free() vs delete in C++
• What is Memory Leak? How can we avoid?
• Difference between Static and Dynamic Memory Allocation in C

C++ Object-Oriented Programming

• Object Oriented Programming in C++
• Access Modifiers in C++
• Friend Class and Function in C++
• Constructors in C++
• Default Constructors in C++
• Copy Constructor in C++
• Destructors in C++
• Private Destructor in C++
• When is a Copy Constructor Called in C++?
• Shallow Copy and Deep Copy in C++
• When Should We Write Our Own Copy Constructor in C++?
• Does C++ compiler create default constructor when we write our own?
• C++ Static Data Members
• Static Member Function in C++
• 'this' pointer in C++
• Scope Resolution Operator vs this pointer in C++
• Local Classes in C++
• Nested Classes in C++
• Enum Classes in C++ and Their Advantage over Enum DataType
• Difference Between Structure and Class in C++
• Why C++ is partially Object Oriented Language?

C++ Encapsulation and Abstraction

• Encapsulation in C++
• Abstraction in C++
• Difference between Abstraction and Encapsulation in C++
• Function Overriding in C++
• Virtual Functions and Runtime Polymorphism in C++
• Difference between Inheritance and Polymorphism
• Function Overloading in C++
• Constructor Overloading in C++
• Functions that cannot be overloaded in C++
• Function overloading and const keyword
• Function Overloading and Return Type in C++
• Function Overloading and float in C++
• C++ Function Overloading and Default Arguments
• Can main() be overloaded in C++?
• Function Overloading vs Function Overriding in C++
• Advantages and Disadvantages of Function Overloading in C++

C++ Operator Overloading

Operator overloading in c++.

• Types of Operator Overloading in C++
• Functors in C++
• What are the Operators that Can be and Cannot be Overloaded in C++?
• Inheritance in C++
• C++ Inheritance Access
• Multiple Inheritance in C++
• C++ Hierarchical Inheritance
• C++ Multilevel Inheritance
• Constructor in Multiple Inheritance in C++
• Inheritance and Friendship in C++
• Does overloading work with Inheritance?

C++ Virtual Functions

• Virtual Function in C++
• Virtual Functions in Derived Classes in C++
• Default Arguments and Virtual Function in C++
• Can Virtual Functions be Inlined in C++?
• Virtual Destructor
• Advanced C++ | Virtual Constructor
• Advanced C++ | Virtual Copy Constructor
• Pure Virtual Functions and Abstract Classes in C++
• Pure Virtual Destructor in C++
• Can Static Functions Be Virtual in C++?
• RTTI (Run-Time Type Information) in C++
• Can Virtual Functions be Private in C++?

C++ Exception Handling

• Exception Handling in C++
• Exception Handling using classes in C++
• Stack Unwinding in C++
• User-defined Custom Exception with class in C++

C++ Files and Streams

• File Handling through C++ Classes
• I/O Redirection in C++
• Templates in C++ with Examples
• Template Specialization in C++
• Using Keyword in C++ STL

C++ Standard Template Library (STL)

• The C++ Standard Template Library (STL)
• Containers in C++ STL (Standard Template Library)
• Introduction to Iterators in C++
• Algorithm Library | C++ Magicians STL Algorithm

C++ Preprocessors

• C Preprocessors
• C Preprocessor Directives
• #include in C
• Difference between Preprocessor Directives and Function Templates in C++

C++ Namespace

• Namespace in C++ | Set 1 (Introduction)
• namespace in C++ | Set 2 (Extending namespace and Unnamed namespace)
• Namespace in C++ | Set 3 (Accessing, creating header, nesting and aliasing)
• C++ Inline Namespaces and Usage of the "using" Directive Inside Namespaces

Advanced C++

• Multithreading in C++
• Smart Pointers in C++
• auto_ptr vs unique_ptr vs shared_ptr vs weak_ptr in C++
• Type of 'this' Pointer in C++
• "delete this" in C++
• Passing a Function as a Parameter in C++
• Signal Handling in C++
• Generics in C++
• Difference between C++ and Objective C
• Write a C program that won't compile in C++
• Write a program that produces different results in C and C++
• How does 'void*' differ in C and C++?
• Type Difference of Character Literals in C and C++
• Cin-Cout vs Scanf-Printf

C++ vs Java

• Similarities and Difference between Java and C++
• Comparison of Inheritance in C++ and Java
• How Does Default Virtual Behavior Differ in C++ and Java?
• Comparison of Exception Handling in C++ and Java
• Foreach in C++ and Java
• Templates in C++ vs Generics in Java
• Floating Point Operations & Associativity in C, C++ and Java

Competitive Programming in C++

• Competitive Programming - A Complete Guide
• C++ tricks for competitive programming (for C++ 11)
• Writing C/C++ code efficiently in Competitive programming
• Why C++ is best for Competitive Programming?
• Test Case Generation | Set 1 (Random Numbers, Arrays and Matrices)
• Fast I/O for Competitive Programming
• Setting up Sublime Text for C++ Competitive Programming Environment
• How to setup Competitive Programming in Visual Studio Code for C++
• Which C++ libraries are useful for competitive programming?
• Common mistakes to be avoided in Competitive Programming in C++ | Beginners
• C++ Interview Questions and Answers (2024)
• Top C++ STL Interview Questions and Answers
• 30 OOPs Interview Questions and Answers (2024)
• Top C++ Exception Handling Interview Questions and Answers
• C++ Programming Examples

in C++, Operator overloading is a compile-time polymorphism. It is an idea of giving special meaning to an existing operator in C++ without changing its original meaning.

In this article, we will further discuss about operator overloading in C++ with examples and see which operators we can or cannot overload in C++.

C++ has the ability to provide the operators with a special meaning for a data type, this ability is known as operator overloading. Operator overloading is a compile-time polymorphism. For example, we can overload an operator ‘+’ in a class like String so that we can concatenate two strings by just using +. Other example classes where arithmetic operators may be overloaded are Complex Numbers, Fractional Numbers, Big integers, etc.

Here, variables “a” and “b” are of types “int” and “float”, which are built-in data types. Hence the addition operator ‘+’ can easily add the contents of “a” and “b”. This is because the addition operator “+” is predefined to add variables of built-in data type only. 

Implementation:

In this example, we have 3 variables “a1”, “a2” and “a3” of type “class A”. Here we are trying to add two objects “a1” and “a2”, which are of user-defined type i.e. of type “class A” using the “+” operator. This is not allowed, because the addition operator “+” is predefined to operate only on built-in data types. But here, “class A” is a user-defined type, so the compiler generates an error. This is where the concept of “Operator overloading” comes in.

Now, if the user wants to make the operator “+” add two class objects, the user has to redefine the meaning of the “+” operator such that it adds two class objects. This is done by using the concept of “Operator overloading”. So the main idea behind “Operator overloading” is to use C++ operators with class variables or class objects. Redefining the meaning of operators really does not change their original meaning; instead, they have been given additional meaning along with their existing ones.

Example of Operator Overloading in C++

Difference between operator functions and normal functions.

Operator functions are the same as normal functions. The only differences are, that the name of an operator function is always the operator keyword followed by the symbol of the operator, and operator functions are called when the corresponding operator is used. 

Can We Overload All Operators?  

Almost all operators can be overloaded except a few. Following is the list of operators that cannot be overloaded. 

Operators that can be Overloaded in C++

We can overload

Unary operators Binary operators Special operators ( [ ], (), etc)

But, among them, there are some operators that cannot be overloaded. They are

Scope resolution operator (: 🙂 Member selection operator                              Member selection through  *

Pointer to a member variable

• Conditional operator (? 🙂
• Sizeof operator  sizeof()

Why can’t the above-stated operators be overloaded?

1. sizeof operator.

This returns the size of the object or datatype entered as the operand. This is evaluated by the compiler and cannot be evaluated during runtime. The proper incrementing of a pointer in an array of objects relies on the sizeof operator implicitly. Altering its meaning using overloading would cause a fundamental part of the language to collapse.

2. typeid Operator

This provides a CPP program with the ability to recover the actually derived type of the object referred to by a pointer or reference. For this operator, the whole point is to uniquely identify a type. If we want to make a user-defined type ‘look’ like another type, polymorphism can be used but the meaning of the typeid operator must remain unaltered, or else serious issues could arise.

3. Scope resolution (::) Operator

This helps identify and specify the context to which an identifier refers by specifying a namespace. It is completely evaluated at runtime and works on names rather than values. The operands of scope resolution are note expressions with data types and CPP has no syntax for capturing them if it were overloaded. So it is syntactically impossible to overload this operator.

4. Class member access operators (.(dot ), .* (pointer to member operator))

The importance and implicit use of class member access operators can be understood through the following example:

Explanation:

The statement ComplexNumber c3 = c1 + c2; is internally translated as ComplexNumber c3 = c1.operator+ (c2); in order to invoke the operator function. The argument c1 is implicitly passed using the ‘.’ operator. The next statement also makes use of the dot operator to access the member function print and pass c3 as an argument. 

Besides, these operators also work on names and not values and there is no provision (syntactically) to overload them.

5. Ternary or conditional (?:) Operator

The ternary or conditional operator is a shorthand representation of an if-else statement. In the operator, the true/false expressions are only evaluated on the basis of the truth value of the conditional expression. 

A function overloading the ternary operator for a class say ABC using the definition

would not be able to guarantee that only one of the expressions was evaluated. Thus, the ternary operator cannot be overloaded.

Important Points about Operator Overloading  

1) For operator overloading to work, at least one of the operands must be a user-defined class object.

2) Assignment Operator: Compiler automatically creates a default assignment operator with every class. The default assignment operator does assign all members of the right side to the left side and works fine in most cases (this behavior is the same as the copy constructor). See this for more details.

3) Conversion Operator: We can also write conversion operators that can be used to convert one type to another type. 

Example:  

Overloaded conversion operators must be a member method. Other operators can either be the member method or the global method.

4) Any constructor that can be called with a single argument works as a conversion constructor, which means it can also be used for implicit conversion to the class being constructed. 

Quiz on Operator Overloading

Please Login to comment...

• cpp-operator-overloading
• cpp-overloading
• 10 Best Free Social Media Management and Marketing Apps for Android - 2024
• 10 Best Customer Database Software of 2024
• How to Delete Whatsapp Business Account?
• Discord vs Zoom: Select The Efficienct One for Virtual Meetings?

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Learn C++ practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c++ interactively, c++ examples, increment ++ and decrement -- operator overloading in c++ programming.

Subtract Complex Number Using Operator Overloading

C++ Tutorials

• C++ Operator Overloading
• C++ Operator Precedence and Associativity

Add Complex Numbers by Passing Structure to a Function

• C++ Function Overloading
• C++ Polymorphism

To understand this example, you should have the knowledge of the following C++ programming topics:

• C++ Classes and Objects
• C++ Constructors

In this tutorial, increment ++ and decrements -- operator are overloaded in best possible way, i.e., increase the value of a data member by 1 if ++ operator operates on an object and decrease value of data member by 1 if -- operator is used.

Example 1: Prefix ++ Increment Operator Overloading with no return type

Initially when the object obj is declared, the value of data member i for object obj is 0 (constructor initializes i to 0).

When ++ operator is operated on obj , operator function void operator++( ) is invoked which increases the value of data member i to 1.

This program is not complete in the sense that, you cannot used code:

It is because the return type of operator function in above program is void.

Here is the little modification of above program so that you can use code obj1 = ++obj .

Example 2: Prefix Increment ++ operator overloading with return type

This program is similar to the one above.

The only difference is that, the return type of operator function is Check in this case which allows to use both codes ++obj; obj1 = ++obj; . It is because, temp returned from operator function is stored in object obj .

Since, the return type of operator function is Check , you can also assign the value of obj to another object.

Notice that, = (assignment operator) does not need to be overloaded because this operator is already overloaded in C++ library.

Example 3: Postfix Increment ++ Operator Overloading

Overloading of increment operator up to this point is only true if it is used in prefix form.

This is the modification of above program to make this work both for prefix form and postfix form.

When increment operator is overloaded in prefix form; Check operator ++ () is called but, when increment operator is overloaded in postfix form; Check operator ++ (int) is invoked.

Notice, the int inside bracket. This int gives information to the compiler that it is the postfix version of operator.

Don't confuse this int doesn't indicate integer.

Example 4: Operator Overloading of Decrement -- Operator

Decrement operator can be overloaded in similar way as increment operator.

Also, unary operators like: !, ~ etc can be overloaded in similar manner.

• C++ Program to Subtract Complex Number Using Operator Overloading

Sorry about that.

Related Examples

C++ Example

Check Whether Number is Even or Odd

Display Prime Numbers Between Two Intervals

13.5 — Introduction to overloading the I/O operators

In the prior lesson ( 13.4 -- Converting an enumeration to and from a string ), we showed this example, where we used a function to convert an enumeration into an equivalent string:

Although the above example works just fine, there are two downsides:

• We have to remember the name of the function we created to get the enumerator name.
• Having to call such a function adds clutter to our output statement.

Ideally, it would be nice if we could somehow teach operator<< to output an enumeration, so we could do something like this: std::cout << shirt and have it do what we expect.

Introduction to operator overloading

In lesson 11.1 -- Introduction to function overloading , we introduced function overloading, which allows us to create multiple functions with the same name so long as each function has a unique function prototype. Using function overloading, we can create variations of a function that work with different data types, without having to think up a unique name for each variant.

Similarly, C++ also supports operator overloading , which lets us define overloads of existing operators, so that we can make those operators work with our program-defined data types.

Basic operator overloading is fairly straightforward:

• Define a function using the name of the operator as the function’s name.
• Add a parameter of the appropriate type for each operand (in left-to-right order). One of these parameters must be a user-defined type (a class type or an enumerated type), otherwise the compiler will error.
• Set the return type to whatever type makes sense.
• Use a return statement to return the result of the operation.

When the compiler encounters the use of an operator in an expression and one or more of the operands is a user-defined type, the compiler will check to see if there is an overloaded operator function that it can use to resolve that call. For example, given some expression x + y , the compiler will use function overload resolution see if there is an operator+(x, y) function call that it can use to evaluate the operation. If a non-ambiguous operator+ function can be found, it will be called, and the result of the operation returned as the return value.

Related content

We cover operator overloading in much more detail in chapter chapter 21 .

For advanced readers

Operators can also be overloaded as member functions of the left-most operand. We discuss this in lesson 21.5 -- Overloading operators using member functions .

Overloading operator<< to print an enumerator

Before we proceed, let’s quickly recap how operator<< works when used for output.

Consider a simple expression like std::cout << 5 . std::cout has type std::ostream (which is a user-defined type in the standard library), and 5 is a literal of type int .

When this expression is evaluated, the compiler will look for an overloaded operator<< function that can handle arguments of type std::ostream and int . It will find such a function (also defined as part of the standard I/O library) and call it. Inside that function, std::cout is used to output x to the console (exactly how is implementation-defined). Finally, the operator<< function returns its left-operand (which in this case is std::cout ), so that subsequent calls to operator<< can be chained.

With the above in mind, let’s implement an overload of operator<< to print a Color :

This prints:

Let’s unpack our overloaded operator function a bit. First, the name of the function is operator<< , since that is the name of the operator we’re overloading. operator<< has two parameters. The left parameter is our output stream, which has type std::ostream . We use pass by non-const reference here because we don’t want to make a copy of a std::ostream object when the function is called, but the std::ostream object needs to be modified in order to do output. The right parameter is our Color object. Since operator<< conventionally returns its left operand, the return type matches the type of the left-operand, which is std::ostream& .

Now let’s look at the implementation. A std::ostream object already knows how to print a std::string_view using operator<< (this comes as part of the standard library). So out << getColorName(color) simply fetches our color’s name as a std::string_view and then prints it to the output stream.

Note that our implementation uses parameter out instead of std::cout because we want to allow the caller to determine which output stream they will output to (e.g. std::cerr << color should output to std::cerr , not std::cout ).

Returning the left operand is also easy. The left operand is parameter out , so we just return out .

Putting it all together: when we call std::cout << shirt , the compiler will see that we’ve overloaded operator<< to work with objects of type Color . Our overloaded operator<< function is then called with std::cout as the out parameter, and our shirt variable (which has value blue ) as parameter color . Since out is a reference to std::cout , and color is a copy of enumerator blue , the expression out << getColorName(color) prints "blue" to the console. Finally out is returned back to the caller in case we want to chain additional output.

Overloading operator>> to input an enumerator

Similar to how we were able to teach operator<< to output an enumeration above, we can also teach operator>> how to input an enumeration:

There are a few differences from the output case worth nothing here. First, std::cin has type std::istream , so we use std::istream& as the type of our left parameter and return value instead of std::ostream& . Second, the pet parameter is a non-const reference. This allows our operator>> to modify the value of the right operand that is passed in if our extraction results in a match.

Inside the function, we use operator>> to input a std::string (something it already knows how to do). If the value the user enters matches one of our pets, then we can assign pet the appropriate enumerator and return the left operand ( in ).

If the user did not enter a valid pet, then we handle that case by putting std::cin into “failure mode”. This is the state that std::cin typically goes into when an extraction fails. The caller can then check std::cin to see if the extraction succeeded or failed.

In lesson 17.6 -- std::array and enumerations , we show how we can use std::array to make our input and output operators less redundant, and avoid having to modify then when a new enumerator is added.