overloading of assignment operator in c

21.12 — Overloading the assignment operator

The copy assignment operator (operator=) is used to copy values from one object to another already existing object .

Related content

As of C++11, C++ also supports “Move assignment”. We discuss move assignment in lesson 22.3 -- Move constructors and move assignment .

Copy assignment vs Copy constructor

The purpose of the copy constructor and the copy assignment operator are almost equivalent -- both copy one object to another. However, the copy constructor initializes new objects, whereas the assignment operator replaces the contents of existing objects.

The difference between the copy constructor and the copy assignment operator causes a lot of confusion for new programmers, but it’s really not all that difficult. Summarizing:

• If a new object has to be created before the copying can occur, the copy constructor is used (note: this includes passing or returning objects by value).
• If a new object does not have to be created before the copying can occur, the assignment operator is used.

Overloading the assignment operator

Overloading the copy assignment operator (operator=) is fairly straightforward, with one specific caveat that we’ll get to. The copy assignment operator must be overloaded as a member function.

This prints:

This should all be pretty straightforward by now. Our overloaded operator= returns *this, so that we can chain multiple assignments together:

Issues due to self-assignment

Here’s where things start to get a little more interesting. C++ allows self-assignment:

This will call f1.operator=(f1), and under the simplistic implementation above, all of the members will be assigned to themselves. In this particular example, the self-assignment causes each member to be assigned to itself, which has no overall impact, other than wasting time. In most cases, a self-assignment doesn’t need to do anything at all!

However, in cases where an assignment operator needs to dynamically assign memory, self-assignment can actually be dangerous:

First, run the program as it is. You’ll see that the program prints “Alex” as it should.

Now run the following program:

You’ll probably get garbage output. What happened?

Consider what happens in the overloaded operator= when the implicit object AND the passed in parameter (str) are both variable alex. In this case, m_data is the same as str.m_data. The first thing that happens is that the function checks to see if the implicit object already has a string. If so, it needs to delete it, so we don’t end up with a memory leak. In this case, m_data is allocated, so the function deletes m_data. But because str is the same as *this, the string that we wanted to copy has been deleted and m_data (and str.m_data) are dangling.

Later on, we allocate new memory to m_data (and str.m_data). So when we subsequently copy the data from str.m_data into m_data, we’re copying garbage, because str.m_data was never initialized.

Detecting and handling self-assignment

Fortunately, we can detect when self-assignment occurs. Here’s an updated implementation of our overloaded operator= for the MyString class:

By checking if the address of our implicit object is the same as the address of the object being passed in as a parameter, we can have our assignment operator just return immediately without doing any other work.

Because this is just a pointer comparison, it should be fast, and does not require operator== to be overloaded.

When not to handle self-assignment

Typically the self-assignment check is skipped for copy constructors. Because the object being copy constructed is newly created, the only case where the newly created object can be equal to the object being copied is when you try to initialize a newly defined object with itself:

In such cases, your compiler should warn you that c is an uninitialized variable.

Second, the self-assignment check may be omitted in classes that can naturally handle self-assignment. Consider this Fraction class assignment operator that has a self-assignment guard:

If the self-assignment guard did not exist, this function would still operate correctly during a self-assignment (because all of the operations done by the function can handle self-assignment properly).

Because self-assignment is a rare event, some prominent C++ gurus recommend omitting the self-assignment guard even in classes that would benefit from it. We do not recommend this, as we believe it’s a better practice to code defensively and then selectively optimize later.

The copy and swap idiom

A better way to handle self-assignment issues is via what’s called the copy and swap idiom. There’s a great writeup of how this idiom works on Stack Overflow .

The implicit copy assignment operator

Unlike other operators, the compiler will provide an implicit public copy assignment operator for your class if you do not provide a user-defined one. This assignment operator does memberwise assignment (which is essentially the same as the memberwise initialization that default copy constructors do).

Just like other constructors and operators, you can prevent assignments from being made by making your copy assignment operator private or using the delete keyword:

Note that if your class has const members, the compiler will instead define the implicit operator= as deleted. This is because const members can’t be assigned, so the compiler will assume your class should not be assignable.

If you want a class with const members to be assignable (for all members that aren’t const), you will need to explicitly overload operator= and manually assign each non-const member.

cppreference.com

Assignment operators.

Assignment operators modify the value of the object.

[ edit ] Definitions

Copy assignment replaces the contents of the object a with a copy of the contents of b ( b is not modified). For class types, this is performed in a special member function, described in copy assignment operator .

For non-class types, copy and move assignment are indistinguishable and are referred to as direct assignment .

Compound assignment replace the contents of the object a with the result of a binary operation between the previous value of a and the value of b .

[ edit ] Assignment operator syntax

The assignment expressions have the form

• ↑ target-expr must have higher precedence than an assignment expression.
• ↑ new-value cannot be a comma expression, because its precedence is lower.

[ edit ] Built-in simple assignment operator

For the built-in simple assignment, the object referred to by target-expr is modified by replacing its value with the result of new-value . target-expr must be a modifiable lvalue.

The result of a built-in simple assignment is an lvalue of the type of target-expr , referring to target-expr . If target-expr is a bit-field , the result is also a bit-field.

[ edit ] Assignment from an expression

If new-value is an expression, it is implicitly converted to the cv-unqualified type of target-expr . When target-expr is a bit-field that cannot represent the value of the expression, the resulting value of the bit-field is implementation-defined.

If target-expr and new-value identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same).

In overload resolution against user-defined operators , for every type T , the following function signatures participate in overload resolution:

For every enumeration or pointer to member type T , optionally volatile-qualified, the following function signature participates in overload resolution:

For every pair A1 and A2 , where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signature participates in overload resolution:

[ edit ] Built-in compound assignment operator

The behavior of every built-in compound-assignment expression target-expr   op   =   new-value is exactly the same as the behavior of the expression target-expr   =   target-expr   op   new-value , except that target-expr is evaluated only once.

The requirements on target-expr and new-value of built-in simple assignment operators also apply. Furthermore:

• For + = and - = , the type of target-expr must be an arithmetic type or a pointer to a (possibly cv-qualified) completely-defined object type .
• For all other compound assignment operators, the type of target-expr must be an arithmetic type.

In overload resolution against user-defined operators , for every pair A1 and A2 , where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signatures participate in overload resolution:

For every pair I1 and I2 , where I1 is an integral type (optionally volatile-qualified) and I2 is a promoted integral type, the following function signatures participate in overload resolution:

For every optionally cv-qualified object type T , the following function signatures participate in overload resolution:

[ edit ] Example

Possible output:

[ edit ] Defect reports

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

[ edit ] See also

Operator precedence

Operator overloading

• 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 25 January 2024, at 22:41.
• This page has been accessed 410,142 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

Top Machine Learning Projects in Python with Source Code for Your Next Project

Machine Learning Projects for Final Year with Source Code: A Comprehensive Guide to Success

Top 10 Machine Learning Projects for Students to Excel in Machine Learning Project

Top Machine Learning Projects for Students: A Compilation of Exciting ML Projects to Boost Your Skills in 2022 Project

Top Machine Learning Projects on GitHub for Deep Learning Enthusiasts – Dive into Exciting Project Ideas Now!

Privacy overview.

Sign in to your account

Username or Email Address

Remember Me

Overloading assignments (C++ only)

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

Best AI Code Assistant

100K+ Devs Worldwide

Highest rated AI app

C operator overloading: c explained, table of contents.

Operator overloading is a concept in the C programming language that allows for customizing operators to perform user defined operations. By overloading an operator, the programmer can create custom methods for use in their code. This is often beneficial for making code more expressive, while reducing the amount of code that must be written. In this article, we will explore the definition of operator overloading in C, the types of operators in C that can be overloaded, the benefits that operator overloading brings, how to overload operators in C, commonly used operators for overloading, potential pitfalls of operator overloading, and best practices for implementing operator overloading.

What is Operator Overloading?

Operator overloading is a feature of object-oriented programming languages such as C that allows the redefining of certain operators. This permits the same operators (such as addition ‘+’, or subtraction ‘-‘ operators) to have different meanings depending on the context in which they are used. For instance, if an operator is overloaded to perform addition on a string type, it will return a concatenated string instead of a numeric sum. Generally speaking, operator overloading allows developers to provide a more natural syntax for operations that involve user-defined types, rather than having to use longer function calls.

Operator overloading can be used to create custom operators for user-defined types, such as classes. This allows developers to create custom operators that are specific to their application, and can be used to simplify complex operations. For example, a custom operator could be created to perform a complex mathematical operation on two objects of a user-defined type. This would allow the operation to be performed with a single operator, rather than having to write out a lengthy function call.

Types of Operators in C

The C programming language defines numerous operators that can be used in constructing programs. These fall into a number of categories: assignment operators (‘=’), arithmetic operators (‘+’, ‘-’, ‘*’, ‘/’), comparison operators (‘<’, ‘>’, ‘==’), logical operators (‘&&’, ‘||’), bitwise operators (‘|’, ‘&’), increment and decrement operators (++, –), and compound assignment operators(+=, -=). All these operators can be overloaded with user-defined behaviour, though some, such as the assignment operators or increment and decrement operators, may require special modifications.

In addition to the operators listed above, C also supports a number of special operators, such as the ternary operator (?:), the sizeof operator, and the comma operator. These operators are used to perform specific tasks, such as conditionally evaluating an expression, determining the size of a data type, or combining multiple expressions into a single statement.

Benefits of Operator Overloading

One of the main benefits of operator overloading is increased readability of code. Overloaded operators can provide a powerful yet concise way of expressing an operation on a custom type. Overloaded operators also allow users to define custom behaviours for the usual operations on various types. For instance, the + operator could be overloaded to mean concatenation when used on strings rather than numeric addition. This means that instead of writing out clumsy string concatenation functions, the user only has to write out a simple statement for the same result.

Another benefit of operator overloading is that it allows for the creation of custom types that behave like built-in types. This means that users can create their own types that can be used in the same way as the built-in types, such as integers and strings. This makes it easier for users to create custom types that can be used in the same way as the built-in types, without having to write out complex functions for each operation.

How to Overload Operators in C

C enables users to redefine certain types of symbols, including mathematical and comparison operators. This is done by creating functions in their code with specific names that correspond to the particular operators: for example, to overload the ‘+’ operator, the programmer must create a function named “operator+” in their code.The user will then define the behaviour for this operator inside this function. It is important to note that the overloaded operator must be either a member of a class or a friend of it.

When overloading an operator, the programmer must also consider the number of parameters that the operator will take. For example, the ‘+’ operator can take one or two parameters, depending on the context. If the operator is being used to add two numbers, it will take two parameters. If it is being used to increment a number, it will take one parameter. The programmer must ensure that the overloaded operator is able to handle the correct number of parameters.

Commonly Used Operators for Overloading

Although it is possible to overload any type of operator in C, it is more common to overload certain types of operators more than others. Operators such as comparison (‘<’, ‘>’), logical (‘&&’, ‘||’), bitwise (‘&’, ‘|’) and arithmetic (‘+’, ‘-‘) are among those frequently overloaded due to the way these operators work with other types in compound expressions. Additionally, increment and decrement (‘++’ and ‘–’) operators are also commonly overloaded by C programmers seeking more simplified syntax when working with iterators.

Overloading operators can be a useful tool for C programmers, as it allows them to create custom functions that can be used in place of the standard operators. This can be especially helpful when dealing with complex data structures, as it allows the programmer to create custom functions that can be used to manipulate the data in a more efficient manner. Additionally, overloading operators can also help to reduce the amount of code that needs to be written, as the custom functions can be used in place of the standard operators.

Potential Pitfalls of Operator Overloading

One mistake commonly encountered when working with operator overloading is attempting to redefine certain types of assignment and increment operators. This is often done because the user intends to apply these operators on custom data types. However, this kind of redefinition can lead to unintended consequences due to the fact that these operators can have side effects which change the value of variables or objects. Also, it may be difficult to debug programs with overloaded operators due to not being able to easily see which operations are taking place where.

Best Practices for Implementing Operator Overloading

When attempting to overload operators in C, it is important to consider what implications this may have on the behaviour of other types. Achieving a consistent syntax when using overloaded operators can help make program logic more clear and understandable. However, careful consideration should be given when defining operators that can modify the value of variables or objects as this can lead to unexpected results. Additionally, it is important to ensure that the programmer understands how their code behaves when acting on two distinct sets of values – for example when operating on custom objects and when operating on fundamental data types.

In conclusion, operator overloading is a powerful tool in the C programming language that enables users to customize the way that certain symbols behave when used with user-defined types. It enables increased code readability while allowing users to define custom behaviours for commonly used operations. Operators such as comparison, logical, bit-wise arithmetic and increment/decrement operators are among those most commonly overloaded. However, potential pitfalls such as undefined behaviour due to intricacies with increment and decrement operators should be taken into account when implementing operator overloading.

Anand is Co-founder and CTO of Bito. He leads technical strategy and engineering, and is our biggest user! Formerly, Anand was CTO of Eyeota, a data company acquired by Dun & Bradstreet. He is co-founder of PubMatic, where he led the building of an ad exchange system that handles over 1 Trillion bids per day.

From Bito team with

This article is brought to you by Bito – an AI developer assistant.

Latest posts

Mastering python’s writelines() function for efficient file writing | a comprehensive guide, understanding the difference between == and === in javascript – a comprehensive guide, compare two strings in javascript: a detailed guide for efficient string comparison, exploring the distinctions: == vs equals() in java programming, understanding matplotlib inline in python: a comprehensive guide for visualizations, related articles.

Bring ChatGPT to your IDE to 10x yourself

Need help setting up? Check out our guide

• Join us on Slack
• Twitter / X
• AI Code Review Agent
• AI Chat in your IDE
• AI Chat in your CLI
• AI Code Completions
• AI Prompt Templates
• AI that understands your code
• AI Automations
• Documentation Agent
• Unit Test Agent
• Documentation
• 2023 State of AI in Software Report
• 2023 How Devs use AI Report
• Dev Resources
• Terms of Use
• Privacy Statement
• © 2023 Bito. All rights reserved.

Install on IDEs like IntelliJ, WebStorm etc.

Learn C++ practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c++ interactively, introduction to c++.

• Getting Started With C++
• Your First C++ Program

C++ Fundamentals

• C++ Comments
• C++ Variables, Literals and Constants
• C++ Data Types
• C++ Type Modifiers
• C++ Constants
• C++ Basic Input/Output
• C++ Operators

Flow Control

• C++ Relational and Logical Operators
• C++ if, if...else and Nested if...else
• C++ for Loop
• C++ while and do...while Loop
• C++ break Statement
• C++ continue Statement
• C++ switch..case Statement
• C++ goto Statement

C++ Ternary Operator

• C++ Functions
• C++ User-defined Function Types
• C++ Programming Default Arguments

C++ Function Overloading

• C++ Inline Functions
• C++ Recursion

Arrays and Strings

• Passing Array to a Function in C++ Programming
• C++ Multidimensional Arrays
• C++ String Class

Pointers and References

• C++ Pointers
• C++ Pointers and Arrays
• C++ References
• C++ Call by Reference: Using pointers
• C++ Return by Reference
• C++ Memory Management: new and delete

Structures and Enumerations

• C++ Structures
• C++ Structure and Function
• C++ Pointers to Structure
• C++ Enumeration

Object Oriented Programming I

• C++ Classes and Objects
• C++ Constructors and Destructors
• C++ Access Modifiers
• C++ Encapsulation
• C++ Inheritance
• C++ Public, Protected and Private Inheritance
• C++ Multiple, Multilevel and Hierarchical Inheritance
• C++ Pass and return object from C++ Functions
• C++ friend Function and friend Classes

C++ Polymorphism

• C++ Function Overriding
• C++ Virtual Functions
• C++ Abstract Class and Pure Virtual Function
• C++ Constructor Overloading

C++ Operator Overloading

• Increment ++ and Decrement -- Operator Overloading in C++ Programming

Standard Template Library (STL) I

• C++ Standard Template Library
• C++ STL Containers
• C++ std::array
• C++ Vectors
• C++ Forward List
• C++ Priority Queue

Standard Template Library (STL) II

• C++ Multimap
• C++ Multiset
• C++ Unordered Map
• C++ Unordered Set
• C++ Unordered Multiset
• C++ Unordered Multimap

Standard Template Library (STL) III

• C++ Iterators
• C++ Algorithm
• C++ Functor

Advanced Topics I

• C++ Exceptions Handling
• C++ File Handling
• C++ Ranged for Loop
• C++ Bitwise Operators
• C++ Nested Loop
• C++ Function Template
• C++ Class Templates
• C++ Type Conversion
• C++ Type Conversion Operators

Advanced Topics II

• C++ Namespaces
• C++ Preprocessors and Macros
• C++ Storage Class
• C++ Buffers
• C++ istream
• C++ ostream

C++ Tutorials

• Subtract Complex Number Using Operator Overloading
• Add Complex Numbers by Passing Structure to a Function

C++ Operator Precedence and Associativity

In C++, we can define how operators behave for user-defined types like class and structures For example,

The + operator, when used with values of type int , returns their sum. However, when used with objects of a user-defined type, it is an error.

In this case, we can define the behavior of the + operator to work with objects as well.

This concept of defining operators to work with objects and structure variables is known as operator overloading .

• Syntax for C++ Operator Overloading

The syntax for overloading an operator is similar to that of function with the addition of the operator keyword followed by the operator symbol.

• returnType - the return type of the function
• operator - a special keyword
• symbol - the operator we want to overload ( + , < , - , ++ , etc.)
• arguments - the arguments passed to the function
• Overloading the Binary + Operator

Following is a program to demonstrate the overloading of the + operator for the class Complex .

Here, we first created a friend function with a return type Complex .

The operator keyword followed by + indicates that we are overloading the + operator.

The function takes two arguments:

• Complex& indicates that we are passing objects by reference and obj1 and obj2 are references to Complex objects. This is an efficient approach because it avoids unnecessary copying, especially for large objects. To learn more, visit C++ References .
• const indicates that referenced objects are constant, meaning we cannot modify obj1 and obj2 within the function.

Inside the function, we created another Complex object, temp to store the result of addition.

We then add the real parts of two objects and store it into the real attribute of the temp object.

Similarly, we add the imaginary parts of the two objects and store them into the img attribute of the temp object.

At last, we return the temp object from the function.

We can also overload the operators using a member function instead of a friend function. For example,

In this case, the operator is invoked by the first operand. Meaning, the line

translates to

Here, the number of arguments to the operator function is reduced by one because the first argument is used to invoke the function.

The problem with this approach is, not all the time the first operand is an object of a user-defined type. For example:

That's why it is recommended to overload operator functions as a non-member function generally, defined as a friend function.

• Overloading ++ as a Prefix Operator

Following is a program to demonstrate the overloading of the ++ operator for the class Count .

Here, when we use ++count1; , the void operator ++ () is called. This increases the value attribute for the object count1 by 1.

Note : When we overload operators, we can use it to work in any way we like. For example, we could have used ++ to increase value by 100.

However, this makes our code confusing and difficult to understand. It's our job as a programmer to use operator overloading properly and in a consistent and intuitive way.

To overload the ++ operator as a Postfix Operator, we declare a member function operator++() with one argument having type int .

Here, when we use count1++; , the void operator ++ (int) is called. This increments the value attribute for the object count1 by 1.

Note : The argument int is just to indicate that the operator is used as a postfix operator.

• Things to Remember in C++ Operator Overloading

1. By default, operators = and & are already overloaded in C++. For example,

we can directly use the = operator to copy objects of the same class. Here, we do not need to create an operator function.

2. We cannot change the precedence and associativity of operators using operator overloading.

3. We cannot overload following operators in C++:

• :: (scope resolution)
• . (member selection)
• .* (member selection through pointer to function)
• ?: (ternary operator)
• sizeof operator
• typeid Operator

4. We cannot overload operators for fundamental data types like int , float , etc

• How to overload increment operator in right way?
• How to overload binary operator - to subtract complex numbers?
• Increment ++ and Decrement -- Operators

Table of Contents

• Introduction

Sorry about that.

Related Tutorials

C++ Tutorial

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