Other operators

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

C++ language

General topics
Preprocessor Comments Keywords	ASCII chart Escape sequences History of C++
Flow control
Conditional execution statements
if statement	switch statement
Iteration statements
for loop range-for loop (C++11)	while loop do-while loop
Jump statements
continue statement break statement	goto statement return statement
Functions
function declaration
lambda function declaration
function template
inline specifier
exception specifications (deprecated)
noexcept specifier (C++11)
Exceptions
throw expression	try-catch block
Namespaces
namespace declaration	namespace aliases
Types
fundamental types compound types enumeration types	union types function types
decltype specifier (C++11)
Specifiers
cv specifiers
storage duration specifiers
constexpr specifier (C++11)
auto specifier (C++11)
alignas specifier (C++11)
Initialization
default initialization value initialization zero initialization copy initialization direct initialization	aggregate initialization list initialization (C++11) constant initialization reference initialization

Literals
integer literals character literals floating-point literals string literals	boolean literals nullptr (C++11) user-defined (C++11)
Expressions
value categories order of evaluation	operators operator precedence
alternative representations
Utilities
Types
typedef declaration
type alias declaration (C++11)
attributes (C++11)
Casts
implicit conversions
const_cast conversion
static_cast conversion
dynamic_cast conversion
reinterpret_cast conversion
C-style and functional cast
Memory allocation
new expression	delete expression
Classes
class declaration this pointer access specifiers	friend specifier initializer lists
Class-specific function properties
virtual function override specifier (C++11) final specifier (C++11)	explicit (C++11) static
Special member functions
default constructor copy constructor move constructor (C++11)	copy assignment move assignment (C++11) destructor
Templates
class template
function template
template specialization
parameter packs (C++11)
Miscellaneous
Inline assembly

 

Operator name	Syntax	Over​load​able	Prototype examples (for class T)
			Inside class definition	Outside class definition
function call	a(a1, a2)	Yes	R T::operator()(Arg1 &a1, Arg2 &a2, ... ...);	N/A
comma	a, b	Yes	T2& T::operator,(T2 &b);	T2& operator,(const T &a, T2 &b);
conversion	(type) a	Yes	operator type()	N/A
ternary conditional	a ? b : c	No	N/A	N/A

Explanation

function call operator provides function semantics for any object.

conversion operator converts given type to another type. The name of the operator must be the same as the type intended to be returned.

ternary conditional operator checks the boolean value of the first expression and replaces entire operator clause with the second or the third expression depending on the resulting value.

Built-in function call operator

A function call expression, such as E(A1, A2, A3), consists of an expression that names the function, E, followed by a possibly empty list of expressions A1, A2, A3, ..., in parentheses.

The expression that names the function can be

a) lvalue expression that refers to a function

b) pointer to function

c) explicit class member access expression that selects a member function

d) implicit class member access expression, e.g. member function name used within another member function.

The function (or member) name specified by E can be overloaded, overload resolution rules used to decide which overload is to be called.

If E specifies a member function, it may be virtual, in which case the final overrider of that function will be called, using dynamic dispatch at runtime.

To call the function, all expressions A1, A2, A3, etc, provided as arguments are evaluated in arbitrary order, and each function parameter is initialized with its corresponding argument after implicit conversion if neccessary. If the call is made to a member function, then the this pointer to current object is converted as if by explicit cast to the this pointer expected by the function. The initialization and destruction of each parameter occurs in the context of the caller, which means, for example, that if constructor of a parameter throws an exception, the exception handlers defined within the function, even as a function-try block, are not considered. If the function is a variadic function, default argument promotions are applied to all arguments matched by the ellipsis parameter.

The return type of a function call expression is the return type of the chosen function, decided using static binding (ignoring the virtual) keyword), even if the overriding function that's actually called returns a different type. This allows the overriding functions to return pointers or references to classes that are derived from the return type returned by the base function, i.e. C++ supports covariant return types). If E specifies a destructor, the return type is void.

The value category of a function call expression is lvalue if the function returns an lvalue reference or an rvalue reference to function, is an xvalue if the function returns an rvalue reference to object, and is a prvalue otherwise. If the function call expression is a prvalue of object type, it must have complete type except when used as an operand to decltype.

Function call expression is similar in syntax to value initialization T(), to function-style cast expression T(A1), and to direct initialization of a temporary T(A1, A2, A3, ...), where T is the name of a type.

run this code

#include <cstdio>
struct S
{
    int f1(double d) {
        printf("%f \n", d); // variable argument function call
    }
    int f2() {
        f1(7); // member function call, same as this->f1()
               // integer argument converted to double
    }
};
void f() {
   puts("function called"); // function call
}
int main()
{
    f(); // function call
    S s;
    s.f2(); // member function call
}

Output:

function called
7.000000

Built-in comma operator

In a comma expression E1, E2, the expression E1 is evaluated, its return value is discarded, and its side effects are completed before evaluation of the expression E2 begins (note that this ability is lost with user-defined operator,).

The return type and value category of the comma operator are exactly the return type and the value category of the second operand, E2.

The comma in various comma-separated lists, such as function argument lists (f(a, b, c)), initializer lists int a[] = {1,2,3}, or initialization statements (int i, j;) is not the comma operator. If the comma operator needs to be used in that context, it has to be parenthesized: f(a, (n++, n+b), c)

run this code

#include <iostream>
int main()
{
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2*n);
    std::cout << "m = " << (++m, m) << '\n';
}

Output:

n = 2
m = 7

Built-in conversion operator

The built-in conversion operator (T)expr evaluates the expression expr and performs explicit cast to the type T.

See explicit cast for detailed description.

Conditional operator

For every pair of promoted arithmetic types L and R and for every type P, where P is a pointer, pointer-to-member, or scoped enumeration type, the following function signatures participate in overload resolution:

LR operator?:(bool, L, R );
T operator?:(bool, T, T );

where LR is the result of usual arithmetic conversions performed on L and R. The operator “?:” cannot be overloaded, these function signatures only exist for the purpose of overload resolution.

The first operand of the conditional operator is evaluated and contextually converted to bool. After both the value evaluation and all side effects of the first operand are completed, if the result was true, the second operand is evaluated. If the result was false, the third operand is evaluated.

In the conditional expression E1 ? E2 : E3, the following rules and limitations apply:

1) If either E2 or E3 (or both) is a throw-expression, the result of the conditional operator is the result of the other (not throw) expression, and is a prvalue (after lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion). Such conditional operator is commonly used in constexpr programming.

2) If both E2 or E3 are of type void, the result is a prvalue of type void.

3) E2 and E3 have different class types (or same type with different cv-qualification) and the same value category. In this case, an attempt is made to convert one (and only one) of the operands to the type of the other, as follows:

a) If they are lvalues, an implicit conversion to the lvalue reference type is attempted

b) If they are xvalues, an implicit conversion to the rvalue reference type is attempted

c) If they are rvalues, and have the same base class (or one is a base class of the other), the operand(s) are converted to the base type by copy-initializing a temporary object of the base type.

d) If they are rvalues, and have no common base class, then an implicit conversion is attempted to the type of the other operand.

4) Both E2 or E3 are glvalues of the same type. In this case, the result has the same type and value category.

5) If all cases listed above fail, and either E2 or E3 has class type: overload resolution is attempted to select the best conversion from one type to the other.

6) If all cases listed above fail, and neither E2 nor E3 have class type: first, lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are applied. Then,

a) if both E2 and E3 now have the same type, the result is a prvalue temporary of that type, copy-initialized from whatever operand was selected after evaluating E1

b) E2 and E3 have arithmetic or enumeration type: usual arithmetic conversions are applied to bring them to common type, that type is the result.

c) E2 and E3 are pointers, or a pointer and a null constant, or a both null pointer constants, one of which is a std::nullptr_t, then pointer conversions and qualification convrsions are applied to bring them to common type, that type is the result.

d) E2 and E3 are pointers to members, or a pointer to member and a null constant: then pointer-to-member conversions and qualification convrsions are applied to bring them to common type, that type is the result.

The return type of a conditional operator is also accessible as the binary type trait std::common_type

run this code

#include <string>
#include <stdexcept>
struct Node
{
    Node* next;
    int data;
    // deep-copying copy constructor
    Node(const Node& other)
      : next(other.next ? new Node(*other.next) : NULL)
      , data(other.data)
    {}
    Node(int d) : next(NULL), data(d) {}
    ~Node() { delete next ; }
};
int main()
{   
    // simple rvalue example
    int n = 1>2 ? 10 : 11;  // 1>2 is false, so n = 11
    // simple lvalue example
    int m = 10; 
    (n == m ? n : m) = 7; // n == m is false, so m = 7
    // throw example
    std::string str = 2+2==4 ? "ok" : throw std::logic_error("2+2 != 4");
}

Standard library

Many classes in the standard library override operator() to be used as function objects.

operator()	deletes the object or array (public member function of std::default_delete)
operator()	compares its arguments using owner-based semantics (function)
operator()	returns the sum of two arguments (public member function of std::plus)
operator()	returns the difference between two arguments (public member function of std::minus)
operator()	returns the product of two arguments (public member function of std::multiplies)
operator()	returns the result of the division of the first argument by the second argument (public member function of std::divides)
operator()	returns the remainder from the division of the first argument by the second argument (public member function of std::modulus)
operator()	returns the negation of the argument (public member function of std::negate)
operator()	checks if the arguments are equal (public member function of std::equal_to)
operator()	checks if the arguments are not equal (public member function of std::not_equal_to)
operator()	checks if the first argument is greater than the second (public member function of std::greater)
operator()	checks if the first argument is less than the second (public member function of std::less)
operator()	checks if the first argument is greater than or equal to the second (public member function of std::greater_equal)
operator()	checks if the first argument is less than or equal to the second (public member function of std::less_equal)
operator()	returns the logical AND of the two arguments (public member function of std::logical_and)
operator()	returns the logical OR of the two arguments (public member function of std::logical_or)
operator()	returns the logical NOT of the argument (public member function of std::logical_not)
operator()	returns the result of bitwise AND of two arguments (public member function of std::bit_and)
operator()	returns the result of bitwise OR of two arguments (public member function of std::bit_or)
operator()	returns the result of bitwise XOR of two arguments (public member function of std::bit_xor)
operator()	returns the logical complement of the result of a call to the stored predicate (public member function of std::unary_negate)
operator()	returns the logical complement of the result of a call to the stored predicate (public member function of std::binary_negate)
operator()	calls the stored function (public member function of std::reference_wrapper)
operator()	invokes the target (public member function of std::function)
operator()	lexicographically compares two strings using this locale's collate facet (public member function of std::locale)
operator()	compares two values of type value_type (public member function of std::map::value_compare)
operator()	compares two values of type value_type (public member function of std::multimap::value_compare)
operator()	executes the function (public member function of std::packaged_task)
operator()	advances the engine's state and returns the generated value (public member function of std::linear_congruential_engine)
operator()	generates the next random number in the distribution (public member function of std::uniform_int_distribution)

Several standard library classes provide user-defined conversion functions

operator bool	checks if the value is non-zero (public member function of std::error_code)
operator bool	checks if the value is non-zero (public member function of std::error_condition)
operator bool	returns the referenced bit (public member function of std::bitset::reference)
operator bool	returns the referenced bit (public member function of std::vector<bool>::reference)
operator bool	checks if there is associated managed object (public member function of std::unique_ptr)
operator bool	checks if there is associated managed object (public member function of std::shared_ptr)
get operator T&	accesses the stored reference (public member function of std::reference_wrapper)
operator bool	checks if a valid target is contained (public member function of std::function)
operator value_type	converts the object to value_type, returns value (public member function of std::integral_constant)
operator void* operator bool (until C++11) (since C++11)	checks if no error has occurred (synonym of !fail()) (public member function of std::basic_ios)
str operator string_type	converts to the underlying string type (public member function of std::sub_match)
operator T	loads a value from an atomic object (public member function of std::atomic)
operator bool	tests whether the lock owns its associated mutex (public member function of std::unique_lock)
operator auto_ptr<Y>	converts the managed pointer to a pointer to different type (public member function of std::auto_ptr)

The comma operator is not overloaded by any class in the standard library. The boost library uses operator, in boost.assign, boost.spirit, and other libraries.

See also

Operator precedence

Common operators
assignment	increment decrement	arithmetic	logical	comparison	member access	other
a = b a = rvalue a += b a -= b a *= b a /= b a %= b a &= b a |= b a ^= b a <<= b a >>= b	++a --a a++ a--	+a -a a + b a - b a * b a / b a % b ~a a & b a | b a ^ b a << b a >> b	!a a && b a || b	a == b a != b a < b a > b a <= b a >= b	a[b] *a &a a->b a.b a->*b a.*b	a(...) a, b (type) a ? :
Special operators
static_cast converts one type to another compatible type dynamic_cast converts virtual base class to derived class const_cast converts type to compatible type with different cv qualifiers reinterpret_cast converts type to incompatible type new allocates memory delete deallocates memory sizeof queries the size of a type sizeof... queries the size of a parameter pack (since C++11) typeid queries the type information of a type noexcept checks if an expression can throw an exception (since C++11) alignof queries alignment requirements of a type (since C++11)