• Images
• Videos
• Documents
• Books
• Articles

Operators

In the following tables, lower case letters such as a and b represent literal values, object/variable names, or l-values, as appropriate. R, S and T stand for a data type, and K for a class or enumeration type. Some operators have alternative spellings using digraphs and trigraphs or operator synonyms.

Arithmetic

C and C++ have the same arithmetic operators and all can be overloaded in C++.

Operation		Syntax	C++ prototype
			in class K	outside class
Addition		a + b	R K::operator +(S b);	R operator +(K a, S b);
Subtraction		a - b	R K::operator -(S b);	R operator -(K a, S b);
Unary plus; integer promotion		+a	R K::operator +();	R operator +(K a);
Unary minus; additive inverse		-a	R K::operator -();	R operator -(K a);
Multiplication		a * b	R K::operator *(S b);	R operator *(K a, S b);
Division		a / b	R K::operator /(S b);	R operator /(K a, S b);
Modulo1		a % b	R K::operator %(S b);	R operator %(K a, S b);
Prefix increment		++a	R& K::operator ++();	R& operator ++(K& a);
Postfix increment		a++	R K::operator ++(int);2	R operator ++(K& a, int);3
Prefix decrement		--a	R& K::operator --();	R& operator --(K& a);
Postfix decrement		a--	R K::operator --(int);4	R operator --(K& a, int);5

Relational

All relational (comparison) operators can be overloaded in C++. Since C++20, the inequality operator is automatically generated if operator== is defined and all four relational operators are automatically generated if operator<=> is defined.⁶

Operation		Syntax	In C	C++ prototype
				in class K	outside class
Equal to		a == b	Yes	bool K::operator ==(S const& b) const;	bool operator ==(K const& a, S const& b);
Not equal to		a != b	Yes	bool K::operator !=(S const& b) const;	bool operator !=(K const& a, S const& b);
Greater than		a > b	Yes	bool K::operator >(S const& b) const;	bool operator >(K const& a, S const& b);
Less than		a < b	Yes	bool K::operator <(S const& b) const;	bool operator <(K const& a, S const& b);
Greater than or equal to		a >= b	Yes	bool K::operator >=(S const& b) const;	bool operator >=(K const& a, S const& b);
Less than or equal to		a <= b	Yes	bool K::operator <=(S const& b) const;	bool operator <=(K const& a, S const& b);
Three-way comparison78		a <=> b	No	auto K::operator <=>(const S &b);	auto operator <=>(const K &a, const S &b);

Logical

C and C++ have the same logical operators and all can be overloaded in C++.

Note that overloading logical AND and OR is discouraged, because as overloaded operators they always evaluate both operands instead of providing the normal semantics of short-circuit evaluation.⁹

Operation		Syntax	C++ prototype
			in class K	outside class
NOT		!a	bool K::operator !();	bool operator !(K a);
AND		a && b	bool K::operator &&(S b);	bool operator &&(K a, S b);
OR		a || b	bool K::operator ||(S b);	bool operator ||(K a, S b);

Bitwise

C and C++ have the same bitwise operators and all can be overloaded in C++.

Operation		Syntax	C++ prototype
			in class K	outside class
NOT		~a	R K::operator ~();	R operator ~(K a);
AND		a & b	R K::operator &(S b);	R operator &(K a, S b);
OR		a | b	R K::operator |(S b);	R operator |(K a, S b);
XOR		a ^ b	R K::operator ^(S b);	R operator ^(K a, S b);
Shift left10		a << b	R K::operator <<(S b);	R operator <<(K a, S b);
Shift right1112		a >> b	R K::operator >>(S b);	R operator >>(K a, S b);

Assignment

C and C++ have the same assignment operators and all can be overloaded in C++.

For the combination operators, a ⊚= b (where ⊚ represents an operation) is equivalent to a = a ⊚ b, except that a is evaluated only once.

Operation	Syntax	C++ prototype
		in class K	outside class
Assignment	a = b	R& K::operator =(S b);	—
Addition combination	a += b	R& K::operator +=(S b);	R& operator +=(K& a, S b);
Subtraction combination	a -= b	R& K::operator -=(S b);	R& operator -=(K& a, S b);
Multiplication combination	a *= b	R& K::operator *=(S b);	R& operator *=(K& a, S b);
Division combination	a /= b	R& K::operator /=(S b);	R& operator /=(K& a, S b);
Modulo combination	a %= b	R& K::operator %=(S b);	R& operator %=(K& a, S b);
Bitwise AND combination	a &= b	R& K::operator &=(S b);	R& operator &=(K& a, S b);
Bitwise OR combination	a |= b	R& K::operator |=(S b);	R& operator |=(K& a, S b);
Bitwise XOR combination	a ^= b	R& K::operator ^=(S b);	R& operator ^=(K& a, S b);
Bitwise left shift combination	a <<= b	R& K::operator <<=(S b);	R& operator <<=(K& a, S b);
Bitwise right shift combination13	a >>= b	R& K::operator >>=(S b);	R& operator >>=(K& a, S b);

Member and pointer

Operation		Syntax	Can overload	In C	C++ prototype
					in class K	outside class
Subscript		a[b]a<:b:>14	Yes	Yes	R& K::operator [](S b);R& K::operator [](S b, ...);15	—
Indirection (object pointed to by a)		*a	Yes	Yes	R& K::operator *();	R& operator *(K a);
Address-of (address of a)		&a	Yes16	Yes	R* K::operator &();	R* operator &(K a);
Structure dereference (member b of object pointed to by a)		a->b	Yes	Yes	R* K::operator ->();17	—
Structure reference (member b of object a)		a.b	No	Yes	—
Member selected by pointer-to-member b of object pointed to by a18		a->*b	Yes	No	R& K::operator ->*(S b);	R& operator ->*(K a, S b);
Member of object a selected by pointer-to-member b		a.*b	No	No	—

Other

Operation		Syntax	Can overload	In C	C++ prototype
					in class K	outside class
Function call		a(a1, a2)	Yes	Yes	R K::operator ()(S a, T b, ...);	—
Comma		a, b	Yes	Yes	R K::operator ,(S b);	R operator ,(K a, S b);
Ternary conditional		a ? b : c	No	Yes	—
Scope resolution		a::b19	No	No	—
User-defined literals2021		"a"_b	Yes	No	—	R operator "" _b(T a)
Sizeof		sizeof a22sizeof (R)	No	Yes	—
Size of parameter pack23		sizeof...(Args)	No	No	—
Alignof24		alignof(R) or _Alignof(R)25	No	Yes	—
Decltype26		decltype (a)decltype (R)	No	No	—
Type identification		typeid(a)typeid(R)	No	No	—
Conversion(C-style cast)		(R)a	Yes	Yes	K::operator R();27	—
Conversion2829		R(a)R{a}30auto(a)31auto{a}32	No	No	—
static_cast conversion33		static_cast<R>(a)	Yes	No	K::operator R();explicit K::operator R();34	—
dynamic cast conversion		dynamic_cast<R>(a)	No	No	—
const_cast conversion		const_cast<R>(a)	No	No	—
reinterpret_cast conversion		reinterpret_cast<R>(a)	No	No	—
Allocate storage		new R35	Yes	No	void* K::operator new(size_t x);	void* operator new(size_t x);
Allocate array		new R[n]36	Yes	No	void* K::operator new[](size_t a);	void* operator new[](size_t a);
Deallocate storage		delete a	Yes	No	void K::operator delete(void* a);	void operator delete(void* a);
Deallocate array		delete[] a	Yes	No	void K::operator delete[](void* a);	void operator delete[](void* a);
Exception check37		noexcept(a)	No	No	—

Synonyms

C++ defines keywords to act as aliases for a number of operators:³⁸

Keyword	Operator
and	&&
and_eq	&=
bitand	&
bitor	|
compl	~
not	!
not_eq	!=
or	||
or_eq	|=
xor	^
xor_eq	^=

Each keyword is a different way to specify an operator and as such can be used instead of the corresponding symbolic variation. For example, (a > 0 and not flag) and (a > 0 && !flag) specify the same behavior. As another example, the bitand keyword may be used to replace not only the bitwise-and operator but also the address-of operator, and it can be used to specify reference types (e.g., int bitand ref = n).

The ISO C specification makes allowance for these keywords as preprocessor macros in the header file iso646.h. For compatibility with C, C++ also provides the header iso646.h, the inclusion of which has no effect. Until C++20, it also provided the corresponding header ciso646 which had no effect as well.

Expression evaluation order

During expression evaluation, the order in which sub-expressions are evaluated is determined by precedence and associativity. An operator with higher precedence is evaluated before a operator of lower precedence and the operands of an operator are evaluated based on associativity. The following table describes the precedence and associativity of the C and C++ operators. Operators are shown in groups of equal precedence with groups ordered in descending precedence from top to bottom (lower order is higher precedence).³⁹⁴⁰⁴¹

Operator precedence is not affected by overloading.

Order	Operator	Description	Associativity
1 highest	::	Scope resolution (C++ only)	None
2	++	Postfix increment	Left-to-right
	--	Postfix decrement
	()	Function call
	[]	Array subscripting
	.	Element selection by reference
	->	Element selection through pointer
	typeid()	Run-time type information (C++ only) (see typeid)
	const_cast	Type cast (C++ only) (see const_cast)
	dynamic_cast	Type cast (C++ only) (see dynamic cast)
	reinterpret_cast	Type cast (C++ only) (see reinterpret_cast)
	static_cast	Type cast (C++ only) (see static_cast)
3	++	Prefix increment	Right-to-left
	--	Prefix decrement
	+	Unary plus
	-	Unary minus
	!	Logical NOT
	~	Bitwise NOT (ones' complement)
	(type)	Type cast
	*	Indirection (dereference)
	&	Address-of
	sizeof	Sizeof
	_Alignof	Alignment requirement (since C11)
	new, new[]	Dynamic memory allocation (C++ only)
	delete, delete[]	Dynamic memory deallocation (C++ only)
4	.*	Pointer to member (C++ only)	Left-to-right
	->*	Pointer to member (C++ only)
5	*	Multiplication	Left-to-right
	/	Division
	%	Modulo (remainder)
6	+	Addition	Left-to-right
	-	Subtraction
7	<<	Bitwise left shift	Left-to-right
	>>	Bitwise right shift
8	<=>	Three-way comparison (Introduced in C++20 - C++ only)	Left-to-right
9	<	Less than	Left-to-right
	<=	Less than or equal to
	>	Greater than
	>=	Greater than or equal to
10	==	Equal to	Left-to-right
	!=	Not equal to
11	&	Bitwise AND	Left-to-right
12	^	Bitwise XOR (exclusive or)	Left-to-right
13	|	Bitwise OR (inclusive or)	Left-to-right
14	&&	Logical AND	Left-to-right
15	||	Logical OR	Left-to-right
16	co_await	Coroutine processing (C++ only)	Right-to-left
	co_yield
17	?:	Ternary conditional operator	Right-to-left
	=	Direct assignment
	+=	Assignment by sum
	-=	Assignment by difference
	*=	Assignment by product
	/=	Assignment by quotient
	%=	Assignment by remainder
	<<=	Assignment by bitwise left shift
	>>=	Assignment by bitwise right shift
	&=	Assignment by bitwise AND
	^=	Assignment by bitwise XOR
	|=	Assignment by bitwise OR
	throw	Throw operator (exceptions throwing, C++ only)
18 lowest	,	Comma	Left-to-right

Details

Although this table is adequate for describing most evaluation order, it does not describe a few details. The ternary operator allows any arbitrary expression as its middle operand, despite being listed as having higher precedence than the assignment and comma operators. Thus a ? b, c : d is interpreted as a ? (b, c) : d, and not as the meaningless (a ? b), (c : d). So, the expression in the middle of the conditional operator (between ? and :) is parsed as if parenthesized. Also, the immediate, un-parenthesized result of a C cast expression cannot be the operand of sizeof. Therefore, sizeof (int) * x is interpreted as (sizeof(int)) * x and not sizeof ((int) * x).

Chained expressions

The precedence table determines the order of binding in chained expressions, when it is not expressly specified by parentheses.

• For example, ++x*3 is ambiguous without some precedence rule(s). The precedence table tells us that: x is 'bound' more tightly to ++ than to *, so that whatever ++ does (now or later—see below), it does it ONLY to x (and not to x*3); it is equivalent to (++x, x*3).
• Similarly, with 3*x++, where though the post-fix ++ is designed to act AFTER the entire expression is evaluated, the precedence table makes it clear that ONLY x gets incremented (and NOT 3*x). In fact, the expression (tmp=x++, 3*tmp) is evaluated with tmp being a temporary value. It is functionally equivalent to something like (tmp=3*x, ++x, tmp).

• Abstracting the issue of precedence or binding, consider the diagram above for the expression 3+2*y[i]++. The compiler's job is to resolve the diagram into an expression, one in which several unary operators (call them 3+( . ), 2*( . ), ( . )++ and ( . )[ i ]) are competing to bind to y. The order of precedence table resolves the final sub-expression they each act upon: ( . )[ i ] acts only on y, ( . )++ acts only on y[i], 2*( . ) acts only on y[i]++ and 3+( . ) acts 'only' on 2*((y[i])++). It is important to note that WHAT sub-expression gets acted on by each operator is clear from the precedence table but WHEN each operator acts is not resolved by the precedence table; in this example, the ( . )++ operator acts only on y[i] by the precedence rules but binding levels alone do not indicate the timing of the postfix ++ (the ( . )++ operator acts only after y[i] is evaluated in the expression).

Binding

The binding of operators in C and C++ is specified by a factored language grammar, rather than a precedence table. This creates some subtle conflicts. For example, in C, the syntax for a conditional expression is:

logical-OR-expression ? expression : conditional-expression

while in C++ it is:

logical-OR-expression ? expression : assignment-expression

Hence, the expression:

e = a < d ? a++ : a = d

is parsed differently in the two languages. In C, this expression is a syntax error, because the syntax for an assignment expression in C is:

unary-expression '=' assignment-expression

In C++, it is parsed as:

e = (a < d ? a++ : (a = d))

which is a valid expression.⁴²⁴³

To use the comma operator in a function call argument expression, variable assignment, or a comma-separated list, use of parentheses is required.⁴⁴⁴⁵ For example,

int a = 1, b = 2, weirdVariable = (++a, b), d = 4;

Criticism of bitwise and equality operators precedence

The precedence of the bitwise logical operators has been criticized.⁴⁶ Conceptually, & and | are arithmetic operators like * and +.

The expression a & b == 7 is syntactically parsed as a & (b == 7) whereas the expression a + b == 7 is parsed as (a + b) == 7. This requires parentheses to be used more often than they otherwise would.

Historically, there was no syntactic distinction between the bitwise and logical operators. In BCPL, B and early C, the operators && || didn't exist. Instead & | had different meaning depending on whether they are used in a 'truth-value context' (i.e. when a Boolean value was expected, for example in if (a==b & c) {...} it behaved as a logical operator, but in c = a & b it behaved as a bitwise one). It was retained so as to keep backward compatibility with existing installations.⁴⁷

Moreover, in C++ (and later versions of C) equality operations, with the exception of the three-way comparison operator, yield bool type values which are conceptually a single bit (1 or 0) and as such do not properly belong in "bitwise" operations.

Notes

See also

• Bitwise operations in C – Operations transforming individual bits of integral data types
• Bit manipulation – Algorithmically modifying data below the word level
• Logical operator – Symbol connecting sentential formulas in logicPages displaying short descriptions of redirect targets
• Boolean algebra (logic) – Algebraic manipulation of "true" and "false"Pages displaying short descriptions of redirect targets
• Table of logic symbols – List of symbols used to express logical relationsPages displaying short descriptions of redirect targets

External links

• "Operators", C++ reference (wiki).
• C Operator Precedence
• Postfix Increment and Decrement Operators: ++ and -- (Developer network), Microsoft, 17 August 2021.

References

1. The modulus operator only supports integer operands; for floating point, a function such as fmod can be used. /wiki/Math.h ↩

2. The int is a dummy parameter to differentiate between prefix and postfix. ↩

3. The int is a dummy parameter to differentiate between prefix and postfix. ↩

4. The int is a dummy parameter to differentiate between prefix and postfix. ↩

5. The int is a dummy parameter to differentiate between prefix and postfix. ↩

6. "Operator overloading§Comparison operators". cppreference.com. https://en.cppreference.com/w/cpp/language/operators#Comparison_operators ↩

7. About C++20 three-way comparison https://en.cppreference.com/w/cpp/language/operator_comparison#Three-way_comparison ↩

8. Possible return types: std::weak_ordering, std::strong_ordering and std::partial_ordering to which they all are convertible to. ↩

9. "Standard C++". https://isocpp.org/wiki/faq/operator-overloading ↩

10. In the context of iostreams in C++, writers often will refer to << and >> as the "put-to" or "stream insertion" and "get-from" or "stream extraction" operators, respectively. /wiki/Iostream ↩

11. In the context of iostreams in C++, writers often will refer to << and >> as the "put-to" or "stream insertion" and "get-from" or "stream extraction" operators, respectively. /wiki/Iostream ↩

12. According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,[3] use an arithmetic shift (i.e., sign extension), but a logical shift is possible. ↩

13. According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,[3] use an arithmetic shift (i.e., sign extension), but a logical shift is possible. ↩

14. "ISO/IEC 9899:1999 specification, TC3" (PDF). p. 64, § 6.4.6 Ponctuators para. 3. https://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf#%5B%7B%22num%22%3A148%2C%22gen%22%3A0%7D%2C%7B%22name%22%3A%22XYZ%22%7D%2C-27%2C816%2Cnull%5D ↩

15. since C++23 ↩

16. The actual address of an object with an overloaded operator & can be obtained with std::addressof https://en.cppreference.com/w/cpp/memory/addressof ↩

17. The return type of operator->() must be a type for which the -> operation can be applied, such as a pointer type. If x is of type C where C overloads operator->(), x->y gets expanded to x.operator->()->y. ↩

18. Meyers, Scott (October 1999), "Implementing operator->* for Smart Pointers" (PDF), Dr. Dobb's Journal, Aristeia. http://aristeia.com/Papers/DDJ_Oct_1999.pdf ↩

19. Although a :: punctuator exists in C as of C23, it is not used as a scope resolution operator. ↩

20. About C++11 User-defined literals http://en.cppreference.com/w/cpp/language/user_literal ↩

21. since C++11 ↩

22. The parentheses are not necessary when taking the size of a value, only when taking the size of a type. However, they are usually used regardless.[citation needed] /wiki/Wikipedia:Citation_needed ↩

23. since C++11 ↩

24. since C++11 ↩

25. C++ defines alignof operator, whereas C defines _Alignof (C23 defines both). Both operators have the same semantics. ↩

26. since C++11 ↩

27. "user-defined conversion". Retrieved 5 April 2020. https://en.cppreference.com/w/cpp/language/cast_operator ↩

28. Behaves like const_cast/static_cast/reinterpret_cast. In the last two cases, the auto specifier is replaced with the type of the invented variable x declared with auto x(a); (which is never interpreted as a function declaration) or auto x{a};, respectively. ↩

29. Explicit type conversion in C++ https://en.cppreference.com/w/cpp/language/explicit_cast ↩

30. since C++11 ↩

31. since C++23 ↩

32. since C++23 ↩

33. For user-defined conversions, the return type implicitly and necessarily matches the operator name unless the type is inferred (e.g. operator auto(), operator decltype(auto)() etc.). ↩

34. since C++11 ↩

35. The type name can also be inferred (e.g new auto) if an initializer is provided. ↩

36. The array size can also be inferred if an initializer is provided. ↩

37. since C++11 ↩

38. ISO/IEC 14882:1998(E) Programming Language C++. open-std.org – The C++ Standards Committee. 1 September 1998. pp. 40–41. ↩

39. ISO/IEC 9899:201x Programming Languages - C. open-std.org – The C Standards Committee. 19 December 2011. p. 465. ↩

40. the ISO C 1999 standard, section 6.5.6 note 71 (Technical report). ISO. 1999. ↩

41. "C++ Built-in Operators, Precedence and Associativity". docs.microsoft.com. Retrieved 11 May 2020. https://docs.microsoft.com/en-US/cpp/cpp/cpp-built-in-operators-precedence-and-associativity ↩

42. "C Operator Precedence - cppreference.com". en.cppreference.com. Retrieved 10 April 2020. https://en.cppreference.com/w/c/language/operator_precedence ↩

43. "Does the C/C++ ternary operator actually have the same precedence as assignment operators?". Stack Overflow. Retrieved 22 September 2019. https://stackoverflow.com/questions/13515434/does-the-c-c-ternary-operator-actually-have-the-same-precedence-as-assignment/13515505 ↩

44. "Other operators - cppreference.com". en.cppreference.com. Retrieved 10 April 2020. https://en.cppreference.com/w/c/language/operator_other ↩

45. "c++ - How does the Comma Operator work". Stack Overflow. Retrieved 1 April 2020. https://stackoverflow.com/questions/54142/how-does-the-comma-operator-work/ ↩

46. C history § Neonatal C, Bell labs. https://www.bell-labs.com/usr/dmr/www/chist.html ↩

47. "Re^10: next unless condition". www.perlmonks.org. Retrieved 23 March 2018. https://www.perlmonks.org/?node_id=1159769 ↩