what is assignment operator overloading in c

21.12 — Overloading the assignment operator

This browser is no longer supported.

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

Operator overloading

• 8 contributors

The operator keyword declares a function specifying what operator-symbol means when applied to instances of a class. This gives the operator more than one meaning, or "overloads" it. The compiler distinguishes between the different meanings of an operator by examining the types of its operands.

type operator operator-symbol ( parameter-list )

You can redefine the function of most built-in operators globally or on a class-by-class basis. Overloaded operators are implemented as functions.

The name of an overloaded operator is operator x , where x is the operator as it appears in the following table. For example, to overload the addition operator, you define a function called operator+ . Similarly, to overload the addition/assignment operator, += , define a function called operator+= .

Redefinable Operators

1 Two versions of the unary increment and decrement operators exist: preincrement and postincrement.

See General Rules for Operator Overloading for more information. The constraints on the various categories of overloaded operators are described in the following topics:

Unary Operators

Binary Operators

Function Call

Subscripting

Class-Member Access

Increment and Decrement .

User-Defined Type Conversions

The operators shown in the following table cannot be overloaded. The table includes the preprocessor symbols # and ## .

Nonredefinable Operators

Although overloaded operators are usually called implicitly by the compiler when they are encountered in code, they can be invoked explicitly the same way as any member or nonmember function is called:

The following example overloads the + operator to add two complex numbers and returns the result.

In this section

General Rules for Operator Overloading

Overloading Unary Operators

Member Access

C++ Built-in Operators, Precedence and Associativity Keywords

Was this page helpful?

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

Submit and view feedback for

Additional resources

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.
• Privacy policy
• About cppreference.com
• Disclaimers

C++ Tutorial

C++ functions, c++ classes, c++ reference, c++ examples, c++ assignment operators, assignment operators.

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator ( = ) to assign the value 10 to a variable called x :

The addition assignment operator ( += ) adds a value to a variable:

A list of all assignment operators:

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

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++ Comments

C++ Fundamentals

• C++ Keywords and Identifiers
• 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++ goto Statement
• C++ switch..case Statement

C++ Ternary Operator

• C++ Functions
• C++ Programming Default Arguments

C++ Function Overloading

• C++ Inline Functions
• C++ Recursion

Arrays and Strings

• C++ Array to Function
• C++ Multidimensional Arrays
• C++ String Class

Pointers and References

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

Structures and Enumerations

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

Object Oriented Programming

• C++ Classes and Objects
• C++ Constructors
• C++ Constructor Overloading
• C++ Destructors
• C++ Access Modifiers
• C++ Encapsulation
• C++ friend Function and friend Classes

Inheritance & Polymorphism

• C++ Inheritance
• C++ Public, Protected and Private Inheritance
• C++ Multiple, Multilevel and Hierarchical Inheritance
• C++ Function Overriding
• C++ Virtual Functions
• C++ Abstract Class and Pure Virtual Function

STL - Vector, Queue & Stack

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

STL - Map & Set

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

STL - Iterators & Algorithms

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

Additional Topics

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

C++ Operator Overloading

Advanced topics.

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

C++ Tutorials

• Subtract Complex Number Using Operator Overloading
• Increment ++ and Decrement -- Operator Overloading in C++ Programming
• Add Complex Numbers by Passing Structure to a Function

C++ Polymorphism

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

Code With C

The Way to Programming

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

Mastering Operator Overloading: A Comprehensive Guide

Mastering Operator Overloading: A Comprehensive Guide 🚀

Have you ever felt like you’re in a magical land where operators like +, -, or even == behave exactly the way you want them to? Well, my fellow tech enthusiasts, welcome to the whimsical world of operator overloading in C++! 🎩✨

Basics of Operator Overloading 🎯

What is operator overloading 🤔.

Let’s start from the very beginning – what on earth is this “operator overloading” that we keep hearing about? 🤷‍♀️ It’s like giving these operators a new superpower! 🦸‍♀️ Operator overloading allows you to redefine the way operators work with user-defined data types. In simple terms, you get to teach C++ some new tricks! 🎩🐇

Why Use Operator Overloading? 🤓

Now, why bother with all this operator overloading business, you ask? 💭 Well, imagine making your code more elegant and readable by using + to concatenate strings or comparing objects with ==. It’s like adding a sprinkle of magic to your code, making it more intuitive and user-friendly! ✨🪄

Implementing Operator Overloading in C++ 🛠️

Syntax for operator overloading 📝.

To dip your toes into the enchanting waters of operator overloading, you need to know the syntax! It involves creating a function with a special name, ensuring that the compiler knows how to handle those magical new tricks you’re teaching it. Ah, it’s like writing a secret incantation that only your program can understand ! 🔮✍️

Overloading Unary and Binary Operators 🔢

Unary, binary – wait, what now? Don’t worry, it’s just a fancy way of saying you can overload operators like + or – for different uses! Whether you’re working with one operand or two, operator overloading lets you redefine their behavior based on your needs. It’s like juggling different tasks with the same tool! 🤹‍♂️🔧

Best Practices for Operator Overloading 🌟

Avoiding ambiguity in operator overloading ❌.

Ah, the dreaded ambiguity – the dark side of operator overloading! To steer clear of confusion, make sure your overloaded operators are crystal clear in their intentions. You wouldn’t want your program scratching its virtual head trying to decipher your mystical code, would you? 🤯🧙‍♂️

Overloading Commonly Used Operators 💡

When in doubt, remember – stick to the classics! Overloading familiar operators like +, -, or == can make your code more intuitive and user-friendly. It’s like speaking the language of C++ fluently, with a hint of your own unique dialect! 🗣️🌐

Advanced Techniques in Operator Overloading 💡

Overloading assignment operator (=) 📚.

Ah, the humble assignment operator – the unsung hero of C++ . By overloading this operator, you can customize how your objects are assigned values. It’s like giving your programs a personalized touch, ensuring they get all dressed up in the perfect outfit! 👗👔

Overloading Increment (++) and Decrement (–) Operators 🔝

Feeling adventurous? How about tinkering with the ++ and — operators? By overloading these bad boys, you can define how your objects increment or decrement. It’s like a virtual dance, where your objects move to the beat of your custom-made drum! 🥁🎶

Common Pitfalls to Avoid in Operator Overloading 🕳️

Handling memory management in operator overloading 🧠.

Ah, memory management – the bane of many programmers! When overloading operators, be extra cautious with memory allocation and deallocation. One wrong move, and your program could be lost in a memory maze, desperately searching for a way out! 🧟‍♂️🤖

Ensuring Consistency in Overloaded Operators 🤝

Consistency is key in the magical realm of operator overloading! Make sure that similar operations behave uniformly across your code. It’s like maintaining harmony in a chaotic symphony, ensuring that every note plays in perfect unison! 🎻🎶

In Closing 🌈

Overall, mastering the art of operator overloading in C++ is like wielding a powerful magic wand in the world of programming. By understanding the basics, embracing best practices, exploring advanced techniques, and steering clear of common pitfalls, you can elevate your code to new heights of elegance and efficiency! 🚀🌟

Thank you for joining me on this enchanting journey through the realms of operator overloading. Remember, in the magical land of C++, the possibilities are as endless as the stars in the night sky! 🌌✨

Now go forth, brave coders, and may your operator overloading adventures be filled with joy, laughter, and of course, lots of magical moments! 🎉🔮

P.S. Keep coding, keep creating, and always remember – the code is strong with this one! 💪👩‍💻

Program Code – Mastering Operator Overloading: A Comprehensive Guide

### code output:, ### code explanation:.

The provided code example illustrates the essence of operator overloading in C++ .

Architecture:

At its heart, it comprises a class named ComplexNumber . This class encapsulates two private attributes: real and imaginary , representing the real and imaginary parts of a complex number, respectively.

Logic and Implementation Details:

• Constructor Initialization: The constructor ComplexNumber initializes these two attributes. If values are not provided during object creation, it defaults to 0.0.
• Display Method: There’s a handy display method to output the complex number in a human-readable format, i.e., ‘Complex Number: X + Yi.
• Addition (‘+’ operator): It overloads the ‘+’ operator using the member function operator + to add two complex numbers. It takes an object of ComplexNumber as a parameter ( const ComplexNumber& obj ) representing the second operand. Inside, it creates a temporary object temp , calculates the summation of real and imaginary parts separately, and returns temp .
• Subtraction (‘-’ operator): Very similar to addition, it also overloads the ‘-‘ operator using the member function operator - for subtracting two complex numbers. It follows a procedure analogous to addition, calculating the difference of both real and imaginary parts separately.
• Main Function: In main() , two ComplexNumber objects c1 and c2 are instantiated with specific values. Then, leveraging our overloaded operators, we add ( c1 + c2 ) and subtract ( c1 - c2 ) these complex numbers and display the results using the display() method.

How it Achieves its Objectives:

The demonstration efficiently achieves its educational aim by intricately showing how operators can be overloaded to perform operations according to the nature of user-defined data types , in this case, complex numbers. Rather than just being confined to the built-in data types, operator overloading extends the expressiveness of C++ to accommodate complex operations in a manner that’s both intuitive and elegant for the programmer.

Frequently Asked Questions

What is operator overloading in c++.

Operator overloading in C++ allows us to redefine the way operators work for user-defined data types . This means we can use operators like +, -, *, /, etc., with custom objects just like built-in data types.

How does operator overloading work in C++?

In C++, operator overloading is achieved by defining a function to overload an operator. When an operator is used with objects of a class, the corresponding function is called to perform the operation.

Can we overload all operators in C++?

No, not all operators can be overloaded in C++. Some operators, like sizeof , :: , .* , etc., cannot be overloaded. It’s essential to understand which operators can and cannot be overloaded in C++.

What are the benefits of operator overloading?

Operator overloading can make our code more readable and intuitive by allowing us to use familiar operators with custom types. It can also lead to code that closely resembles mathematical expressions, making the code easier to understand .

What are some common mistakes to avoid when overloading operators in C++?

One common mistake when overloading operators in C++ is not handling edge cases or boundary conditions properly. It’s crucial to test the overloaded operators thoroughly to ensure they work as expected in all scenarios.

Are there any performance implications of operator overloading in C++?

Yes, there can be performance implications when using operator overloading in C++. Overloading operators can introduce overhead compared to regular function calls. It’s essential to consider the performance impact when overloading operators in performance-critical code.

How can I decide when to use operator overloading in my C++ code?

The decision to use operator overloading in C++ should be based on whether it enhances the readability and maintainability of the code. If overloading an operator makes the code more natural to read and less error-prone, it can be a good choice.

Where can I find more resources to learn about mastering operator overloading in C++?

There are plenty of online resources, tutorials, and books available to learn more about mastering operator overloading in C++. Websites like GeeksforGeeks, tutorials from cppreference.com, and books like “Effective C++” by Scott Meyers can be valuable sources of information.

You Might Also Like

The significance of ‘c’ in c programming language, c programming languages: understanding the basics and beyond, exploring the c programming language: from basics to advanced concepts, object-oriented programming: the pillar of modern software development, object-oriented coding: best practices and techniques.

Leave a Reply Cancel reply

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

Latest Posts

Creating a Google Sheet to Track Google Drive Files: Step-by-Step Guide

Cutting-Edge Artificial Intelligence Project Unveiled in Machine Learning World

Enhancing Exams with Image Processing: E-Assessment Project

Cutting-Edge Blockchain Projects for Cryptocurrency Enthusiasts – Project

Artificial Intelligence Marvel: Cutting-Edge Machine Learning Project

Privacy overview.

Sign in to your account

Username or Email Address

Remember Me

• 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 in C

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

Similar reads.

• cpp-operator-overloading
• cpp-overloading

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• TECHNOLOGIES
• An Interview Question

Mastering the Null-Coalescing Operator in C#

• Jitendra Mesavaniya
• Jun 30, 2024
• Other Artcile

Learn how to efficiently handle null values in C# using the null-coalescing operator. This guide covers the syntax, practical applications, and advanced techniques to enhance your programming skills.

Handling null values efficiently is a common requirement in software development. C# offers powerful tools to manage nulls, including the null-coalescing operator (??). This article explores the null-coalescing operator, its benefits, and how it can simplify and enhance your code.

Table of Contents

• Introduction to Null-Coalescing Operator

Basic Usage of Null-Coalescing Operator

Combining with null-conditional operator, chaining null-coalescing operators, the null-coalescing assignment operator, practical examples.

• Traditional Null Handling vs. Null-Coalescing Operator

Introduction

The null-coalescing operator (??) in C# allows you to provide a default value for an expression that might be null. This operator simplifies the handling of null values, making your code more readable and less error-prone.

The syntax of the null-coalescing operator is straightforward.

In this example, displayName is assigned the value "Guest" because the name is null.

The null-conditional operator (?.) can be used with the null-coalescing operator to safely navigate through potential null references.

In this example, a person.Address?.The city evaluates to null, so "Unknown" is returned.

You can chain multiple null-coalescing operators to provide multiple fallback values.

In this example, firstNonNullName is assigned the first non-null value in the chain, which is "John".

Introduced in C# 8.0, the null-coalescing assignment operator (??=) assigns a value to a variable if it is currently null.

Here, the name is assigned "Default Name" because it was initially null.

Example 1. Default Configuration.

Example 2. Safe Navigation with Fallback

Traditional Null Handling vs. Null-Coalescing Operator  

Traditional approach.

Before these operators were available, handling null values required explicit null checks, which could be verbose and cumbersome.

Modern Approach

With the null-coalescing operator and null-conditional operator, the same logic becomes much simpler and more readable.

The null-coalescing operator (??) and its companion, the null-coalescing assignment operator (??=), provide powerful and concise ways to handle null values in C#. They significantly reduce the boilerplate code needed for null checks and make your code more readable and maintainable. By mastering these operators, you can write cleaner, more robust C# code that efficiently handles null values.

• .NET Programming
• C# Operators
• C# Programming
• Null-Coalescing
• Null-Coalescing Operator

The SOLID Principles

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

Expressions and operators

This chapter describes JavaScript's expressions and operators, including assignment, comparison, arithmetic, bitwise, logical, string, ternary and more.

At a high level, an expression is a valid unit of code that resolves to a value. There are two types of expressions: those that have side effects (such as assigning values) and those that purely evaluate .

The expression x = 7 is an example of the first type. This expression uses the = operator to assign the value seven to the variable x . The expression itself evaluates to 7 .

The expression 3 + 4 is an example of the second type. This expression uses the + operator to add 3 and 4 together and produces a value, 7 . However, if it's not eventually part of a bigger construct (for example, a variable declaration like const z = 3 + 4 ), its result will be immediately discarded — this is usually a programmer mistake because the evaluation doesn't produce any effects.

As the examples above also illustrate, all complex expressions are joined by operators , such as = and + . In this section, we will introduce the following operators:

Assignment operators

Comparison operators, arithmetic operators, bitwise operators, logical operators, bigint operators, string operators, conditional (ternary) operator, comma operator, unary operators, relational operators.

These operators join operands either formed by higher-precedence operators or one of the basic expressions . A complete and detailed list of operators and expressions is also available in the reference .

The precedence of operators determines the order they are applied when evaluating an expression. For example:

Despite * and + coming in different orders, both expressions would result in 7 because * has precedence over + , so the * -joined expression will always be evaluated first. You can override operator precedence by using parentheses (which creates a grouped expression — the basic expression). To see a complete table of operator precedence as well as various caveats, see the Operator Precedence Reference page.

JavaScript has both binary and unary operators, and one special ternary operator, the conditional operator. A binary operator requires two operands, one before the operator and one after the operator:

For example, 3 + 4 or x * y . This form is called an infix binary operator, because the operator is placed between two operands. All binary operators in JavaScript are infix.

A unary operator requires a single operand, either before or after the operator:

For example, x++ or ++x . The operator operand form is called a prefix unary operator, and the operand operator form is called a postfix unary operator. ++ and -- are the only postfix operators in JavaScript — all other operators, like ! , typeof , etc. are prefix.

An assignment operator assigns a value to its left operand based on the value of its right operand. The simple assignment operator is equal ( = ), which assigns the value of its right operand to its left operand. That is, x = f() is an assignment expression that assigns the value of f() to x .

There are also compound assignment operators that are shorthand for the operations listed in the following table:

Assigning to properties

If an expression evaluates to an object , then the left-hand side of an assignment expression may make assignments to properties of that expression. For example:

For more information about objects, read Working with Objects .

If an expression does not evaluate to an object, then assignments to properties of that expression do not assign:

In strict mode , the code above throws, because one cannot assign properties to primitives.

It is an error to assign values to unmodifiable properties or to properties of an expression without properties ( null or undefined ).

Destructuring

For more complex assignments, the destructuring assignment syntax is a JavaScript expression that makes it possible to extract data from arrays or objects using a syntax that mirrors the construction of array and object literals.

Without destructuring, it takes multiple statements to extract values from arrays and objects:

With destructuring, you can extract multiple values into distinct variables using a single statement:

Evaluation and nesting

In general, assignments are used within a variable declaration (i.e., with const , let , or var ) or as standalone statements.

However, like other expressions, assignment expressions like x = f() evaluate into a result value. Although this result value is usually not used, it can then be used by another expression.

Chaining assignments or nesting assignments in other expressions can result in surprising behavior. For this reason, some JavaScript style guides discourage chaining or nesting assignments . Nevertheless, assignment chaining and nesting may occur sometimes, so it is important to be able to understand how they work.

By chaining or nesting an assignment expression, its result can itself be assigned to another variable. It can be logged, it can be put inside an array literal or function call, and so on.

The evaluation result matches the expression to the right of the = sign in the "Meaning" column of the table above. That means that x = f() evaluates into whatever f() 's result is, x += f() evaluates into the resulting sum x + f() , x **= f() evaluates into the resulting power x ** f() , and so on.

In the case of logical assignments, x &&= f() , x ||= f() , and x ??= f() , the return value is that of the logical operation without the assignment, so x && f() , x || f() , and x ?? f() , respectively.

When chaining these expressions without parentheses or other grouping operators like array literals, the assignment expressions are grouped right to left (they are right-associative ), but they are evaluated left to right .

Note that, for all assignment operators other than = itself, the resulting values are always based on the operands' values before the operation.

For example, assume that the following functions f and g and the variables x and y have been declared:

Consider these three examples:

Evaluation example 1

y = x = f() is equivalent to y = (x = f()) , because the assignment operator = is right-associative . However, it evaluates from left to right:

• The y on this assignment's left-hand side evaluates into a reference to the variable named y .
• The x on this assignment's left-hand side evaluates into a reference to the variable named x .
• The function call f() prints "F!" to the console and then evaluates to the number 2 .
• That 2 result from f() is assigned to x .
• The assignment expression x = f() has now finished evaluating; its result is the new value of x , which is 2 .
• That 2 result in turn is also assigned to y .
• The assignment expression y = x = f() has now finished evaluating; its result is the new value of y – which happens to be 2 . x and y are assigned to 2 , and the console has printed "F!".

Evaluation example 2

y = [ f(), x = g() ] also evaluates from left to right:

• The y on this assignment's left-hand evaluates into a reference to the variable named y .
• The function call g() prints "G!" to the console and then evaluates to the number 3 .
• That 3 result from g() is assigned to x .
• The assignment expression x = g() has now finished evaluating; its result is the new value of x , which is 3 . That 3 result becomes the next element in the inner array literal (after the 2 from the f() ).
• The inner array literal [ f(), x = g() ] has now finished evaluating; its result is an array with two values: [ 2, 3 ] .
• That [ 2, 3 ] array is now assigned to y .
• The assignment expression y = [ f(), x = g() ] has now finished evaluating; its result is the new value of y – which happens to be [ 2, 3 ] . x is now assigned to 3 , y is now assigned to [ 2, 3 ] , and the console has printed "F!" then "G!".

Evaluation example 3

x[f()] = g() also evaluates from left to right. (This example assumes that x is already assigned to some object. For more information about objects, read Working with Objects .)

• The x in this property access evaluates into a reference to the variable named x .
• Then the function call f() prints "F!" to the console and then evaluates to the number 2 .
• The x[f()] property access on this assignment has now finished evaluating; its result is a variable property reference: x[2] .
• Then the function call g() prints "G!" to the console and then evaluates to the number 3 .
• That 3 is now assigned to x[2] . (This step will succeed only if x is assigned to an object .)
• The assignment expression x[f()] = g() has now finished evaluating; its result is the new value of x[2] – which happens to be 3 . x[2] is now assigned to 3 , and the console has printed "F!" then "G!".

Avoid assignment chains

Chaining assignments or nesting assignments in other expressions can result in surprising behavior. For this reason, chaining assignments in the same statement is discouraged .

In particular, putting a variable chain in a const , let , or var statement often does not work. Only the outermost/leftmost variable would get declared; other variables within the assignment chain are not declared by the const / let / var statement. For example:

This statement seemingly declares the variables x , y , and z . However, it only actually declares the variable z . y and x are either invalid references to nonexistent variables (in strict mode ) or, worse, would implicitly create global variables for x and y in sloppy mode .

A comparison operator compares its operands and returns a logical value based on whether the comparison is true. The operands can be numerical, string, logical, or object values. Strings are compared based on standard lexicographical ordering, using Unicode values. In most cases, if the two operands are not of the same type, JavaScript attempts to convert them to an appropriate type for the comparison. This behavior generally results in comparing the operands numerically. The sole exceptions to type conversion within comparisons involve the === and !== operators, which perform strict equality and inequality comparisons. These operators do not attempt to convert the operands to compatible types before checking equality. The following table describes the comparison operators in terms of this sample code:

Note: => is not a comparison operator but rather is the notation for Arrow functions .

An arithmetic operator takes numerical values (either literals or variables) as their operands and returns a single numerical value. The standard arithmetic operators are addition ( + ), subtraction ( - ), multiplication ( * ), and division ( / ). These operators work as they do in most other programming languages when used with floating point numbers (in particular, note that division by zero produces Infinity ). For example:

In addition to the standard arithmetic operations ( + , - , * , / ), JavaScript provides the arithmetic operators listed in the following table:

A bitwise operator treats their operands as a set of 32 bits (zeros and ones), rather than as decimal, hexadecimal, or octal numbers. For example, the decimal number nine has a binary representation of 1001. Bitwise operators perform their operations on such binary representations, but they return standard JavaScript numerical values.

The following table summarizes JavaScript's bitwise operators.

Bitwise logical operators

Conceptually, the bitwise logical operators work as follows:

• The operands are converted to thirty-two-bit integers and expressed by a series of bits (zeros and ones). Numbers with more than 32 bits get their most significant bits discarded. For example, the following integer with more than 32 bits will be converted to a 32-bit integer: Before: 1110 0110 1111 1010 0000 0000 0000 0110 0000 0000 0001 After: 1010 0000 0000 0000 0110 0000 0000 0001
• Each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on.
• The operator is applied to each pair of bits, and the result is constructed bitwise.

For example, the binary representation of nine is 1001, and the binary representation of fifteen is 1111. So, when the bitwise operators are applied to these values, the results are as follows:

Note that all 32 bits are inverted using the Bitwise NOT operator, and that values with the most significant (left-most) bit set to 1 represent negative numbers (two's-complement representation). ~x evaluates to the same value that -x - 1 evaluates to.

Bitwise shift operators

The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.

Shift operators convert their operands to thirty-two-bit integers and return a result of either type Number or BigInt : specifically, if the type of the left operand is BigInt , they return BigInt ; otherwise, they return Number .

The shift operators are listed in the following table.

Logical operators are typically used with Boolean (logical) values; when they are, they return a Boolean value. However, the && and || operators actually return the value of one of the specified operands, so if these operators are used with non-Boolean values, they may return a non-Boolean value. The logical operators are described in the following table.

Examples of expressions that can be converted to false are those that evaluate to null, 0, NaN, the empty string (""), or undefined.

The following code shows examples of the && (logical AND) operator.

The following code shows examples of the || (logical OR) operator.

The following code shows examples of the ! (logical NOT) operator.

Short-circuit evaluation

As logical expressions are evaluated left to right, they are tested for possible "short-circuit" evaluation using the following rules:

• false && anything is short-circuit evaluated to false.
• true || anything is short-circuit evaluated to true.

The rules of logic guarantee that these evaluations are always correct. Note that the anything part of the above expressions is not evaluated, so any side effects of doing so do not take effect.

Note that for the second case, in modern code you can use the Nullish coalescing operator ( ?? ) that works like || , but it only returns the second expression, when the first one is " nullish ", i.e. null or undefined . It is thus the better alternative to provide defaults, when values like '' or 0 are valid values for the first expression, too.

Most operators that can be used between numbers can be used between BigInt values as well.

One exception is unsigned right shift ( >>> ) , which is not defined for BigInt values. This is because a BigInt does not have a fixed width, so technically it does not have a "highest bit".

BigInts and numbers are not mutually replaceable — you cannot mix them in calculations.

This is because BigInt is neither a subset nor a superset of numbers. BigInts have higher precision than numbers when representing large integers, but cannot represent decimals, so implicit conversion on either side might lose precision. Use explicit conversion to signal whether you wish the operation to be a number operation or a BigInt one.

You can compare BigInts with numbers.

In addition to the comparison operators, which can be used on string values, the concatenation operator (+) concatenates two string values together, returning another string that is the union of the two operand strings.

For example,

The shorthand assignment operator += can also be used to concatenate strings.

The conditional operator is the only JavaScript operator that takes three operands. The operator can have one of two values based on a condition. The syntax is:

If condition is true, the operator has the value of val1 . Otherwise it has the value of val2 . You can use the conditional operator anywhere you would use a standard operator.

This statement assigns the value "adult" to the variable status if age is eighteen or more. Otherwise, it assigns the value "minor" to status .

The comma operator ( , ) evaluates both of its operands and returns the value of the last operand. This operator is primarily used inside a for loop, to allow multiple variables to be updated each time through the loop. It is regarded bad style to use it elsewhere, when it is not necessary. Often two separate statements can and should be used instead.

For example, if a is a 2-dimensional array with 10 elements on a side, the following code uses the comma operator to update two variables at once. The code prints the values of the diagonal elements in the array:

A unary operation is an operation with only one operand.

The delete operator deletes an object's property. The syntax is:

where object is the name of an object, property is an existing property, and propertyKey is a string or symbol referring to an existing property.

If the delete operator succeeds, it removes the property from the object. Trying to access it afterwards will yield undefined . The delete operator returns true if the operation is possible; it returns false if the operation is not possible.

Deleting array elements

Since arrays are just objects, it's technically possible to delete elements from them. This is, however, regarded as a bad practice — try to avoid it. When you delete an array property, the array length is not affected and other elements are not re-indexed. To achieve that behavior, it is much better to just overwrite the element with the value undefined . To actually manipulate the array, use the various array methods such as splice .

The typeof operator returns a string indicating the type of the unevaluated operand. operand is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.

Suppose you define the following variables:

The typeof operator returns the following results for these variables:

For the keywords true and null , the typeof operator returns the following results:

For a number or string, the typeof operator returns the following results:

For property values, the typeof operator returns the type of value the property contains:

For methods and functions, the typeof operator returns results as follows:

For predefined objects, the typeof operator returns results as follows:

The void operator specifies an expression to be evaluated without returning a value. expression is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them to avoid precedence issues.

A relational operator compares its operands and returns a Boolean value based on whether the comparison is true.

The in operator returns true if the specified property is in the specified object. The syntax is:

where propNameOrNumber is a string, numeric, or symbol expression representing a property name or array index, and objectName is the name of an object.

The following examples show some uses of the in operator.

The instanceof operator returns true if the specified object is of the specified object type. The syntax is:

where objectName is the name of the object to compare to objectType , and objectType is an object type, such as Date or Array .

Use instanceof when you need to confirm the type of an object at runtime. For example, when catching exceptions, you can branch to different exception-handling code depending on the type of exception thrown.

For example, the following code uses instanceof to determine whether theDay is a Date object. Because theDay is a Date object, the statements in the if statement execute.

Basic expressions

All operators eventually operate on one or more basic expressions. These basic expressions include identifiers and literals , but there are a few other kinds as well. They are briefly introduced below, and their semantics are described in detail in their respective reference sections.

Use the this keyword to refer to the current object. In general, this refers to the calling object in a method. Use this either with the dot or the bracket notation:

Suppose a function called validate validates an object's value property, given the object and the high and low values:

You could call validate in each form element's onChange event handler, using this to pass it to the form element, as in the following example:

Grouping operator

The grouping operator ( ) controls the precedence of evaluation in expressions. For example, you can override multiplication and division first, then addition and subtraction to evaluate addition first.

You can use the new operator to create an instance of a user-defined object type or of one of the built-in object types. Use new as follows:

The super keyword is used to call functions on an object's parent. It is useful with classes to call the parent constructor, for example.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Using std::enable_if to avoid ambiguous templated binary operator overloading [closed]

I want to use std::enable_if to avoid ambiguous overloaded operator*(T,U) (or redefinitions) from MyClass*otherT vs otherT*MyClass vs MyClassT*MyClassT .

Let's say MyClass declaration is:

Then in global scope:

But, this code still can't find the overloaded operator for it:

I need help, what's wrong?

• operator-overloading

• 4 Always post complete error along with your question with a minimal reproducible example –  user12002570 Commented Jun 27 at 11:56
• 2 ... is not valid c++. Post real code only. I've seen people(askers) change their question after an answer has been posted saying that was just an example but not the real code. So always post real code. That edit then invalidates the already posted answers. –  user12002570 Commented Jun 27 at 11:57
• @user12002570 its just an example of code snippet, and the body of the function is not relevant for the question –  uray Commented Jun 27 at 12:04
• @wohlstad the second one should with T=double , and U=double the MyClassT<double> is not the same as ` double` , so declaration would valid (notice ! std::is_same_v –  uray Commented Jun 27 at 12:06
• @uray You don't need to use enable_if here at all. See my answer below. –  user12002570 Commented Jun 27 at 12:07

You don't need to use enable_if and default argument here as shown below.

Working demo

• try with int b –  uray Commented Jun 27 at 12:09
• 2 @uray this is why we ask for a minimal reproducible example you should show all the code that you want to work otherwise people will make assumptions –  Alan Birtles Commented Jun 27 at 12:13
• @user12002570 following the comments under the question - can you explain why the second overload (with T=double, and U=double) does not fit the case of c = a * b in the OP's code ? (despite the usage of !std::is_same_v<MyClassT<T>, U> ). –  wohlstad Commented Jun 27 at 12:36
• @wohlstad It does work actually. See demo –  user12002570 Commented Jun 27 at 12:46
• Oh... I see. So this means the whole question was actually wrong, isn't it ? (I mean in the sense that the original code was actually working) –  wohlstad Commented Jun 27 at 12:51

Not the answer you're looking for? Browse other questions tagged c++ c++17 operator-overloading enable-if is-same or ask your own question .

• Featured on Meta
• Upcoming sign-up experiments related to tags
• Policy: Generative AI (e.g., ChatGPT) is banned
• The [lib] tag is being burninated
• What makes a homepage useful for logged-in users

Hot Network Questions

• A 90s (maybe) made-for-TV movie (maybe) about a group of trainees on a spaceship. There is some kind of emergency and all experienced officers die
• Simple Container Class
• What is the term for when a hyperlink maliciously opens different URL from URL displayed when hovered over?
• Could space habitats have large transparent roofs?
• How to Pick Out Strings of a Specified Length
• Is arxiv strictly for new stuff?
• How would I say the exclamation "What a [blank]" in Latin?
• Can I get a refund for ICE due to cancelled regional bus service?
• Is there a way to non-destructively test whether an Ethernet cable is pure copper or copper-clad aluminum (CCA)?
• How do guitarists remember what note each string represents when fretting?
• SMTP Header confusion - Delivered-To: and To: are different
• Why was the animal "Wolf" used in the title "The Wolf of Wall Street (2013)"?
• Can you help me to identify the aircraft in a 1920s photograph?
• Does "*some of the town council*" mean the same as "*some of the **members** of the town council*"?
• Is there any other reason to stockpile minerals aside preparing for war?
• How to Draw Gabriel's Horn
• What was the first game to intentionally use letterboxing to indicate a cutscene?
• Where can I access records of the 1947 Superman copyright trial?
• Is the FOCAL syntax for Alphanumeric Numbers ("0XYZ") documented anywhere?
• DSP Puzzle: Advanced Signal Forensics
• How are "pursed" and "rounded" synonymous?
• Both my adult kids and their father (ex husband) dual citizens
• Integration of the product of two exponential functions
• Can front gear be replaced on a Retrospec Judd folding bicycle?