Operators in C and C++: Difference between revisions

Revision as of 14:14, 30 January 2025

Latest revision as of 02:44, 23 April 2025

(40 intermediate revisions by 4 users not shown)

Line 7:

When not overloaded, for the operators <code>&&</code>, <code>||</code>, and <code>,</code> (the [[comma operator]]), there is a [[sequence point]] after the evaluation of the first operand.

C++ alone contains the [[type conversion]] operators <code>const_cast</code>, <code>static_cast</code>, <code>dynamic_cast</code>, and <code>reinterpret_cast</code>.

Most of the operators available in C and C++ are also available in other [[C-family]] languages such as [[C Sharp (programming language)|C#]], [[D (programming language)|D]], [[Java (programming language)|Java]], [[Perl]], and [[PHP]] with the same precedence, associativity, and semantics.

Many operators specified by a sequence of symbols are commonly referred to by a name that consists of the name of each symbol. For example, <code>+=</code> and <code>-=</code> are often called "plus equal(s)" and "minus equal(s)", instead of the more verbose "assignment by addition" and "assignment by subtraction".

==Operators==

In the following tables, lower case letters such as <code>a</code> and <code>b</code> represent literal values, object/variable names, or l-values, as appropriate. <code>R</code>, <code>S</code> and <code>T</code> stand for a data type, and <code>K</code> for a class or enumeration type. Some operators have alternative spellings using [[digraphs and trigraphs (programming)|digraphs and trigraphs]] or [[#C++ operator synonymsSynonyms|operator synonyms]].

===Arithmetic operators===

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

{| class="wikitable" style="width:100%"

! colspan="2" rowspan="2" | NameOperation

! rowspan="2" | Syntax

! colspan="2" | C++ prototype

Line 28:

|-

| {{rh}} colspan="2" | [[Addition]]

| stylealign="text-align:center;" | {{nowrap| 1=<code>a '''+''' b</code>}}

| {{cpp|1=R K::operator +(S b);}}

| {{cpp|1=R operator +(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Subtraction]]

| stylealign="text-align:center;" | <code>a '''-''' b</code>

| {{cpp|1=R K::operator -(S b);}}

| {{cpp|1=R operator -(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Unary operation|Unary]] plus; ([[Type conversion#Type promotion|integer promotion]])

| stylealign="text-align:center;" | <code>'''+'''a</code>

| {{cpp|1=R K::operator +();}}

| {{cpp|1=R operator +(K a);}}

|-

| {{rh}} colspan="2" | [[Unary operation|Unary]] minus; ([[additive inverse]])

| stylealign="text-align:center;" | <code>'''-'''a</code>

| {{cpp|1=R K::operator -();}}

| {{cpp|1=R operator -(K a);}}

|-

| {{rh}} colspan="2" | [[Multiplication]]

| stylealign="text-align:center;" | <code>a '''*''' b</code>

| {{cpp|1=R K::operator *(S b);}}

| {{cpp|1=R operator *(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Division (mathematics)|Division]]

| stylealign="text-align:center;" | <code>a '''/''' b</code>

| {{cpp|1=R K::operator /(S b);}}

| {{cpp|1=R operator /(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Modulo operation|Modulo]] (integer remainder)<ref name="modulo" group="lower-alpha" />

| stylealign="text-align:center;" | <code>a '''%''' b</code>

| {{cpp|1=R K::operator %(S b);}}

| {{cpp|1=R operator %(K a, S b);}}

|-

| width="15%" {{rh}} rowspancolspan="32" | Prefix [[Increment and decrement operators|Incrementincrement]]

| align="center" | <code>'''++'''a</code>

| width="8%" {{rh}} | Prefix

| {{cpp|1=R& K::operator ++();}}

| width="11%" align="center" | <code>'''++'''a</code>

| width="25%" | {{cpp|1=R& K::operator ++(K& a);}}

| width="25%" | {{cpp|1=R& operator ++(K& a);}}

|-

| {{rh}} rowspancolspan="2" | Postfix increment

| rowspanalign="2" style="text-align:center;" | <code>a'''++'''</code>

| {{cpp|1=R K::operator ++(int);}}{{efn|name=dummy-int|The {{cpp|int}} is a dummy parameter to differentiate between prefix and postfix.}}

| {{cpp|1=R operator ++(K& a, int);}}{{efn|name=dummy-int}}

|-

| {{rh}} colspan="2" style="font-size:smaller;" | Note:Prefix [[C++]] uses the unnamed dummy-parameter {{cpp|int}} to differentiate between prefixIncrement and postfix incrementdecrement operators.|decrement]]

| align="center" | <code>'''--'''a</code>

|-

| {{rh}} rowspan="3" | [[Increment and decrement operators|Decrement]]

| {{rh}} | Prefix

| style="text-align:center;" | <code>'''--'''a</code>

| {{cpp|1=R& K::operator --();}}

| {{cpp|1=R& operator --(K& a);}}

|-

| {{rh}} rowspancolspan="2" | Postfix decrement

| rowspanalign="2" style="text-align:center;" | <code>a'''--'''</code>

| {{cpp|1=R K::operator --(int);}}{{efn|name=dummy-int}}

| {{cpp|1=R operator --(K& a, int);}}{{efn|name=dummy-int}}

|-

| {{rh}} colspan="2" style="font-size:smaller;" | Note: [[C++]] uses the unnamed dummy-parameter {{cpp|int}} to differentiate between prefix and postfix decrement operators.

|}

===Relational operators===

All [[Relational operator|relational]] (comparison) operators can be overloaded in C++. Since [[C++20]], the inequality operator is automatically generated if <code>operator==</code> is defined and all four relational operators are automatically generated if <code>operator<=></code> is defined.<ref>{{cite web|url=https://en.cppreference.com/w/cpp/language/operators#Comparison_operators|title=Operator overloading§Comparison operators|website=cppreference.com}}</ref>

{| class="wikitable" style="width:100%"

! colspan="2" rowspan="2" | NameOperation

! rowspan="2" | Syntax

! rowspan="2" | In C

Line 102 ⟶ 96:

! outside class

|-

| width="23%" {{rh}} colspan="2" | Equal to

| width="11%" align="center" | <code>a '''==''' b</code>

| width="8%" {{yes}}

| width="25%" |{{cpp|1=bool K::operator ==(S const& b) const;}}

| width="25%" |{{cpp|1=bool operator ==(K const& a, S const& b);}}

|-

| {{rh}} colspan="2" | Not equal to

Line 133 ⟶ 127:

| {{cpp|1=bool operator <=(K const& a, S const& b);}}

|-

| {{rh}} colspan="2" rowspan="2" | [[Three-way comparison]]<ref name="threewaycomparison" group="lower-alpha"/>{{efn|Possible return types: <code>std::weak_ordering</code>, <code>std::strong_ordering</code> and <code>std::partial_ordering</code> to which they all are convertible to.}}

| rowspan="2" style="text-align:center;" | <code>a '''&lt;=&gt;''' b</code> || rowspan="2"{{no}}

| {{cpp|1=auto K::operator <=>(const S &b);}}

| {{cpp|1=auto operator <=>(const K &a, const S &b);}}

|-

| {{rh}} colspan="2" style="font-size:smaller;" | The operator has a total of 3 possible return types: <code>std::weak_ordering</code>, <code>std::strong_ordering</code> and <code>std::partial_ordering</code> to which they all are convertible to.

|}

===Logical operators===

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

Line 148 ⟶ 140:

{| class="wikitable" style="width:100%"

! colspan="2" rowspan="2" | NameOperation

! rowspan="2" | Syntax

! colspan="2" | C++ prototype

Line 155 ⟶ 147:

! outside class

|-

| width="23%" {{rh}} colspan="2" | [[Negation|Logical negation (NOT)]]

| width="11%" align="center" | <code>'''!'''a</code>

| width="25%" |{{cpp|1=bool K::operator !();}}

| width="25%" |{{cpp|1=bool operator !(K a);}}

|-

| {{rh}} colspan="2" | [[Logical conjunction|Logical AND]]

| style="text-align:center;" | <code>a '''&&''' b</code>

| {{cpp|1=bool K::operator &&(S b);}}

| {{cpp|1=bool operator &&(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Logical disjunction|Logical OR]]

| style="text-align:center;" | <code>a '''<nowiki>||</nowiki>''' b</code>

| {{code|1=bool K::operator {{!!}}(S b);|lang=cpp}}

Line 171 ⟶ 163:

|}

===Bitwise operators===

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

{| class="wikitable" style="width:100%"

! colspan="2" rowspan="2" | NameOperation

! rowspan="2" | Syntax

! colspan="2" | C++ prototype

Line 183 ⟶ 175:

! outside class

|-

| width="23%" {{rh}} colspan="2" | [[Bitwise operation#NOT|Bitwise NOT]]

| width="11%" align="center" | <code>'''~'''a</code><br/>

| width="25%" |{{cpp|1=R K::operator ~();}}

| width="25%" |{{cpp|1=R operator ~(K a);}}

|-

| {{rh}} colspan="2" | [[Bitwise operation#AND|Bitwise AND]]

| style="text-align:center;" | <code>a '''&''' b</code>

| {{cpp|1=R K::operator &(S b);}}

| {{cpp|1=R operator &(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Bitwise operation#OR|Bitwise OR]]

| style="text-align:center;" | <code>a '''<nowiki>|</nowiki>''' b</code>

| {{cpp|1=R K::operator {{!}}(S b);|lang=cpp}}

| {{cpp|1=R operator {{!}}(K a, S b);|lang=cpp}}

|-

| {{rh}} colspan="2" | [[Bitwise operation#XOR|Bitwise XOR]]

| style="text-align:center;" | <code>a '''^''' b</code>

| {{cpp|1=R K::operator ^(S b);}}

| {{cpp|1=R operator ^(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Bitwise shift|BitwiseShift]] left shift]]<ref name="bitshift" group="lower-alpha" />

| style="text-align:center;" | <code>a '''<<''' b</code>

| {{cpp|1=R K::operator <<(S b);}}

| {{cpp|1=R operator <<(K a, S b);}}

|-

| {{rh}} colspan="2" | [[Bitwise shift|BitwiseShift right shift]]<ref name="bitshift" group="lower-alpha" />{{Refn | nameOperation="rightbitshift" | group="lower-alpha" | According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,<ref name="Integers">{{Citation | contribution = Integers implementation | url = //gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Integers-implementation.html#Integers-implementation | title = GCC 4.3.3 | publisher = GNU}}.</ref> use an [[arithmetic shift]] (i.e., sign extension), but a [[logical shift]] is possible.}}

| style="text-align:center;" | <code>a '''>>''' b</code>

| {{cpp|1=R K::operator >>(S b);}}

Line 214 ⟶ 206:

|}

===Assignment operators===

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

For the givencombination operators the semantic of the built-in combined assignment expression, <code>a ⊚= b</code> (where <code>⊚</code> represents an operation) is equivalent to <code>a = a ⊚ b</code>, except that <code>a</code> is evaluated only once.

{| class="wikitable" style="width:100%"

! rowspan="2" | NameOperation

! rowspan="2" | Syntax

! colspan="2" | C++ prototype

Line 228 ⟶ 220:

! outside class

|-

! {{rh}} | [[Assignment operator in (C++)|Direct assignmentAssignment]]

| style="text-align:center;" | {{nowrap| 1=<code>a '''=''' b</code>}}

| {{cpp|1=R& K::operator =(S b);}}

| {{n/a}}

|-

! {{rh}} | Addition assignmentcombination

| align="center" | <code>a '''+=''' b</code>

| {{cpp|1=R& K::operator +=(S b);}}

| {{cpp|1=R& operator +=(K& a, S b);}}

|-

! {{rh}} | Subtraction assignmentcombination

| style="text-align:center;" | <code>a '''-=''' b</code>

| {{cpp|1=R& K::operator -=(S b);}}

| {{cpp|1=R& operator -=(K& a, S b);}}

|-

! {{rh}} | Multiplication assignmentcombination

| style="text-align:center;" | <code>a '''*=''' b</code>

| {{cpp|1=R& K::operator *=(S b);}}

| {{cpp|1=R& operator *=(K& a, S b);}}

|-

! {{rh}} | Division assignmentcombination

| style="text-align:center;" | <code>a '''/=''' b</code>

| {{cpp|1=R& K::operator /=(S b);}}

| {{cpp|1=R& operator /=(K& a, S b);}}

|-

! {{rh}} | Modulo assignmentcombination

| style="text-align:center;" | <code>a '''%=''' b</code>

| {{cpp|1=R& K::operator %=(S b);}}

| {{cpp|1=R& operator %=(K& a, S b);}}

|-

! {{rh}} | Bitwise AND assignmentcombination

| style="text-align:center;" | <code>a '''&=''' b</code>

| {{cpp|1=R& K::operator &=(S b);}}

| {{cpp|1=R& operator &=(K& a, S b);}}

|-

! {{rh}} | Bitwise OR assignmentcombination

| style="text-align:center;" | <code>a '''<nowiki>|</nowiki>=''' b</code>

| {{cpp|1=R& K::operator {{!}}=(S b);|lang=cpp}}

| {{cpp|1=R& operator {{!}}=(K& a, S b);|lang=cpp}}

|-

! {{rh}} | Bitwise XOR assignmentcombination

| style="text-align:center;" | <code>a '''^=''' b</code>

| {{cpp|1=R& K::operator ^=(S b);}}

| {{cpp|1=R& operator ^=(K& a, S b);}}

|-

! {{rh}} | Bitwise left shift assignmentcombination

| style="text-align:center;" | <code>a '''<<=''' b</code>

| {{cpp|1=R& K::operator <<=(S b);}}

| {{cpp|1=R& operator <<=(K& a, S b);}}

|-

! {{rh}} | Bitwise right shift combination{{Refn | name="rightbitshift" | group="lower-alpha" | According to the C99 standard, the right shift of a negative number is implementation defined. Most implementations, e.g., the GCC,<ref name="Integers">{{Citation | contribution = Integers implementation | url = //gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Integers-implementation.html#Integers-implementation | title = GCC 4.3.3 | publisher = GNU}}.</ref> use an [[arithmetic shift]] (i.e., sign extension), but a [[logical shift]] is possible.}}

! Bitwise right shift assignment<ref name="rightbitshift" group="lower-alpha" />

| style="text-align:center;" | <code>a '''>>=''' b</code>

| {{cpp|1=R& K::operator >>=(S b);}}

Line 284 ⟶ 276:

|}

===Member and pointer operators===

{| class="wikitable" style="width:100%"

! colspan="2" rowspan="2" | NameOperation

! rowspan="2" | Syntax

! rowspan="2" | Can overload in C++

! rowspan="2" | In C

! colspan="2" | C++ prototype

Line 295 ⟶ 287:

! outside class

|-

| width="23%" {{rh}} colspan="2" | [[Indexer (programming)|Subscript]]

| width="11%" align="center" | <code>a'''['''b''']'''</code><code>a'''<:'''b''':>'''</code><ref>{{Cite web |title=ISO/IEC 9899:1999 specification, TC3 |url=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 |at=p. 64, § 6.4.6 ''Ponctuators'' para. 3}}</ref>

| width="8%" {{yes}}

| width="8%" {{yes}}

| {{cpp|1=R& K::operator [](S b);}}<br/>{{cpp|1=R& K::operator [](S b, ...); // since C++23}}<brref name="sinceCXX23" group="lower-alpha" />

| width="25%" {{n/a}}

|-

| {{rh}} colspan="2" | Indirection <br>{{small|("object pointed to by ''a''")}}

| style="text-align:center;" | <code>'''*'''a</code> || {{yes}} || {{yes}}

| {{cpp|1=R& K::operator *();}}

| {{cpp|1=R& operator *(K a);}}

|-

| {{rh}} colspan="2" | Address-of <br>{{small|("address of ''a''")}}

| style="text-align:center;" | <code>'''&'''a</code> || {{yes}}<ref name="addressof2" group="lower-alpha"/> || {{yes}}

| {{cpp|1=R* K::operator &();}}

| {{cpp|1=R* operator &(K a);}}

|-

| {{rh}} colspan="2" | Structure dereference <br>{{small|("member ''b'' of object pointed to by ''a''")}}

| style="text-align:center;" | <code>a'''->'''b</code> || {{yes}} || {{yes}}

| {{cpp|1=R* K::operator ->();}}<ref name="arrowptr" group="lower-alpha" /><br />

| {{n/a}}

|-

| {{rh}} colspan="2" | Structure reference <br>{{small|("member ''b'' of object ''a''")}}

| style="text-align:center;" | <code>a'''.'''b</code> || {{no}} || {{yes}}

| {{rh}} colspan="2" {{n/a}}

Line 331 ⟶ 323:

|}

===Other operators===

{| class="wikitable" style="width:100%"

! colspan="2" rowspan="2" | NameOperation

! rowspan="2" | Syntax

! rowspan="2" | Can overload in C++

! rowspan="2" | In C

! colspan="2" | C++ prototype

Line 342 ⟶ 334:

! outside class

|-

| width="12%" {{rh}} colspan="2" | [[function (programming)|Function]] call<br/>''See [[Function object]]''.

| width="22%" align="center" | <code>a'''('''a1, a2''')'''</code>

| width="8%" {{yes}}

| width="8%" {{yes}}

| {{cpp|1=R K::operator ()(S a, T b, ...);}}<!--Overload'operator' mayshows acceptas zeroblue oreven morethough argumentsother prototypes shows it as green; seems to be a bug in the cpp template; unknown how to workaround.-->

| width="25%" {{n/a}}

|-

| {{rh}} colspan="2" | [[comma operator|Comma]]

Line 362 ⟶ 354:

| colspan="2" {{n/a}}

|-

| {{rh}} colspan="2" | User-defined literals<ref name="ud-literal" group="lower-alpha" /><brref name="sinceCXX11" group="lower-alpha" />''since C++11''

| style="text-align: center;" | <code><nowiki>"a"_b</nowiki></code> || {{yes}} || {{no}}

| {{n/a}}

Line 371 ⟶ 363:

| colspan="2" {{n/a}}

|-

| {{rh}} colspan="2" | Size of [[variadic template|parameter pack]]<br>''sinceref C++11''name="sinceCXX11" group="lower-alpha" />

| style="text-align:center;" | <code>'''sizeof...'''(Args)</code> || {{no}} || {{no}}

| colspan="2" {{n/a}}

|-

| {{rh}} colspan="2" | [[Alignof]]<br>''sinceref C++11''name="sinceCXX11" group="lower-alpha" />

| style="text-align:center;" | <code>'''alignof'''(R)</code> <br> or <code>'''_Alignof'''(R)</code><ref name="alignof" group="lower-alpha"/> || {{no}} || {{yes}}

| colspan="2" {{n/a}}

|-

| {{rh}} colspan="2" | [[Decltype]]<brref name="sinceCXX11" group="lower-alpha" />''since C++11''

| style="text-align:center;" | <code>'''decltype''' (a)</code><br/><code>'''decltype''' (R)</code> || {{no}} || {{no}}

| colspan="2" {{n/a}}

Line 387 ⟶ 379:

| colspan="2" {{n/a}}

|-

| {{rh}} colspan="2" | [[type conversion|Conversion]] <br>{{small|(C-style cast)}}

| style="text-align:center;" | <code>(R)a</code> || {{yes}} || {{yes}}

| {{cpp|1=K::operator R();}}<ref>{{cite web|url=https://en.cppreference.com/w/cpp/language/cast_operator|title=user-defined conversion|access-date=5 April 2020}}</ref>

| {{n/a}}

|-

| {{rh}} colspan="2" | [[type conversion|Conversion]]{{efn|Behaves like const_cast/static_cast/reinterpret_cast. In the last two cases, the <code>auto</code> specifier is replaced with the type of the invented variable x declared with <code>auto x(a);</code> (which is never interpreted as a function declaration) or <code>auto x{a};</code>, respectively.}}<ref>[https://en.cppreference.com/w/cpp/language/explicit_cast Explicit type conversion] in C++</ref>

| {{rh}} colspan="2" | [[type conversion|Conversion]]

| style="text-align:center;" | <code>R(a)</code><br><code>R{a}</code>^{sinceref name="sinceCXX11" group="lower-alpha" C++11}<br><code>auto(a)</code>^{sinceref name="sinceCXX23" group="lower-alpha" C++23}<br><code>auto{a}</code>^{sinceref name="sinceCXX23" group="lower-alpha" C++23} || {{no}} || {{no}}

| {{rh}} colspan="2" {{n/a}}

| {{rh}} style=font-size:smaller colspan="2" | Note: behaves like const_cast/static_cast/reinterpret_cast. In the last two cases the <code>auto</code> specifier is replaced with the type of the invented variable x declared with <code>auto x(a);</code> (which is never interpreted as a function declaration) or <code>auto x{a};</code>, respectively. <ref>[https://en.cppreference.com/w/cpp/language/explicit_cast Explicit type conversion] in C++</ref>

|-

| {{rh}} colspan="2" | [[static_cast]] conversion{{efn|For user-defined conversions, the return type implicitly and necessarily matches the operator name unless the type is inferred (e.g. {{cpp|1=operator auto()}}, {{cpp|1=operator decltype(auto)()}} etc.).}}

| {{rh}} rowspan="2" colspan="2" | [[static_cast]] conversion

| rowspan="2" style="text-align:center;" | <code>'''static_cast'''<R>(a)</code> || rowspan="2" {{yes}} || rowspan="2" {{no}}

| {{cpp|1=K::operator R();}}<br>{{cpp|1=explicit K::operator R();}}<ref ''sincename="sinceCXX11" C++11''group="lower-alpha" />

| {{n/a}}

|-

| {{rh}} colspan="2" style="font-size:smaller;" | Note: for user-defined conversions, the return type implicitly and necessarily matches the operator name unless the type is inferred (e.g. {{cpp|1=operator auto()}}, {{cpp|1=operator decltype(auto)()}} etc.).

|-

| {{rh}} colspan="2" | [[dynamic cast]] conversion

Line 420 ⟶ 410:

| {{cpp|1=void* operator new(size_t x);}}

|-

| {{rh}} colspan="2" | Allocate storage (array)

| style="text-align:center;" | <code>'''new''' R'''['''n''']'''</code><ref name="infer2" group="lower-alpha"/> || {{yes}} || {{no}}

| {{cpp|1=void* K::operator new[](size_t a);}}

Line 430 ⟶ 420:

| {{cpp|1=void operator delete(void* a);}}

|-

| {{rh}} colspan="2" | Deallocate storage (array)

| style="text-align:center;" | <code>'''delete[]''' a</code> || {{yes}} || {{no}}

| {{cpp|1=void K::operator delete[](void* a);}}

| {{cpp|1=void operator delete[](void* a);}}

|-

| {{rh}} colspan="2" | Exception check<br>''sinceref C++11''name="sinceCXX11" group="lower-alpha" />

| style="text-align:center;" | <code>'''noexcept'''(a)</code> || {{no}} || {{no}}

| colspan="2" {{n/a}}

|}

=== Synonyms ===

Notes:

C++ defines keywords to act as aliases for a number of operators:<ref name="Committee">{{cite book | title = ISO/IEC 14882:1998(E) Programming Language C++ | date = 1 September 1998 | publisher = open-std.org – The C++ Standards Committee | pages = 40–41}}</ref>

{{reflist |group="lower-alpha"|refs=

{| class="wikitable" style="width:30%; text-align:center;"

<ref name="modulo" group="lower-alpha">The modulus operator works just with integer operands, for floating point numbers a library function must be used instead (like [[math.h|{{code|fmod|cpp}}]]).</ref>

! Keyword || Operator

<ref name="bitshift" group="lower-alpha">In the context of [[iostream]]s in C++, writers often will refer to {{cpp|<<}} and {{cpp|>>}} as the "put-to" or "stream insertion" and "get-from" or "stream extraction" operators, respectively.</ref>

|-

<ref name="addressof2" group="lower-alpha">The actual address of an object with an overloaded <code>operator &</code> can be obtained with [https://en.cppreference.com/w/cpp/memory/addressof <code>std::addressof</code>]</ref>

| {{code|and}} || <code>&&</code>

<ref name="arrowptr" group="lower-alpha">The return type of {{cpp|operator->()}} must be a type for which the {{cpp |->}} operation can be applied, such as a pointer type. If {{cpp|x}} is of type {{cpp |C}} where {{cpp |C}} overloads {{cpp|operator->()}}, {{cpp|x->y}} gets expanded to {{cpp|x.operator->()->y}}.</ref>

|-

<ref name="arrowstar" group= "lower-alpha">{{Citation | publisher = Aristeia | url = http://aristeia.com/Papers/DDJ_Oct_1999.pdf | title = Implementing operator-&gt;* for Smart Pointers | first = Scott | last = Meyers | journal = Dr. Dobb's Journal |date=Oct 1999}}.</ref>

| {{code|and_eq}} || <code>&=</code>

<ref name="scopal" group="lower-alpha">Although a <code>::</code> punctuator exists in C as of C23, it is not used as a scope resolution operator.</ref>

|-

<ref name="ud-literal" group="lower-alpha">About [http://en.cppreference.com/w/cpp/language/user_literal C++11 User-defined literals]</ref>

| {{code|bitand}} || <code>&</code>

<ref name="sizeof" group="lower-alpha">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|date=July 2024}}</ref>

|-

<ref name="alignof" group = "lower-alpha">C++ defines <code>alignof</code> operator, whereas C defines <code>_Alignof</code> (C23 defines both). Both operators have the same semantics.</ref>

| {{code|bitor}} || <code>&#x7C;</code>

<ref name="threewaycomparison" group="lower-alpha">About [https://en.cppreference.com/w/cpp/language/operator_comparison#Three-way_comparison C++20 three-way comparison]</ref>

|-

| {{code|compl}} || <code>~</code>

<ref name="infer" group="lower-alpha">The type name can also be inferred (e.g <code>new auto</code>) if an initializer is provided.</ref>

|-

<ref name="infer2" group="lower-alpha">The array size can also be inferred if an initializer is provided.</ref>

| {{code|not}} || <code>!</code>

}}

|-

| {{code|not_eq}} || <code>!=</code>

|-

| {{code|or}} || <code>&#x7C;&#x7C;</code>

|-

| {{code|or_eq}} || <code>&#x7C;=</code>

|-

| {{code|xor}} || <code>^</code>

|-

| {{code|xor_eq}} || <code>^=</code>

|}

Each keyword is a different way to specify an operator and as such can be used instead of the corresponding symbolic variation. For example, {{code|1=(a > 0 and not flag)}} and {{code|1=(a > 0 && !flag)}} specify the same behavior. As another example, the <code>bitand</code> 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., {{code|1=int bitand ref = n}}).

==Operator precedence==

The following is a table that lists the [[order of operations|precedence]] and [[operator associativity|associativity]] of all the operators in the [[C (programming language)|C]] and [[C++]] languages. Operators are listed top to bottom, in descending precedence. Descending precedence refers to the priority of the grouping of operators and operands. Considering an expression, an operator which is listed on some row will be grouped prior to any operator that is listed on a row further below it. Operators that are in the same cell (there may be several rows of operators listed in a cell) are grouped with the same precedence, in the given direction. An operator's precedence is unaffected by overloading.

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

The syntax of expressions in C and C++ is specified by a [[phrase structure grammar]].<ref>{{cite book | title = ISO/IEC 9899:201x Programming Languages - C | date = 19 December 2011 | publisher = open-std.org – The C Standards Committee | pages = 465}}</ref> The table given here has been inferred from the grammar.{{Citation needed| date = January 2009}} For the ISO C 1999 standard, section 6.5.6 note 71 states that the C grammar provided by the specification defines the precedence of the C operators, and also states that the operator precedence resulting from the grammar closely follows the specification's section ordering:

==Expression evaluation order==

"[[C syntax|The [C] syntax]] [i.e., grammar] specifies the precedence of operators in the evaluation of an expression, which is the same as the order of the major subclauses of this subclause, highest precedence first."<ref>{{cite tech report |title=the ISO C 1999 standard, section 6.5.6 note 71 |institution=ISO |year=1999 }}</ref>

During expression evaluation, the order in which sub-expressions are evaluated is determined by [[order of operations|precedence]] and [[operator associativity|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).<ref>{{cite book | title = ISO/IEC 9899:201x Programming Languages - C | date = 19 December 2011 | publisher = open-std.org – The C Standards Committee | pages = 465}}</ref><ref>{{cite tech report |title=the ISO C 1999 standard, section 6.5.6 note 71 |institution=ISO |year=1999 }}</ref><ref>{{cite web |title=C++ Built-in Operators, Precedence and Associativity |url=https://docs.microsoft.com/en-US/cpp/cpp/cpp-built-in-operators-precedence-and-associativity |website=docs.microsoft.com |access-date=11 May 2020 |language=en-us}}</ref>

Operator precedence is not affected by overloading.

A precedence table, while mostly adequate, cannot resolve a few details. In particular, note that 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 <code>a ? b, c : d</code> is interpreted as <code>a ? (b, c) : d</code>, and not as the meaningless <code>(a ? b), (c : d)</code>. So, the expression in the middle of the conditional operator (between <code>'''?'''</code> and <code>''':'''</code>) is parsed as if parenthesized. Also, note that the immediate, unparenthesized result of a C cast expression cannot be the operand of <code>sizeof</code>. Therefore, <code>sizeof (int) * x</code> is interpreted as <code>(sizeof(int)) * x</code> and not <code>sizeof ((int) * x)</code>.

{| class="wikitable"

|-

! style="text-align: left" | PrecedenceOrder

! style="text-align: left" | Operator

! style="text-align: left" | Description

Line 696 ⟶ 697:

| Left-to-right

|}

<ref>{{cite web |title=C++ Built-in Operators, Precedence and Associativity |url=https://docs.microsoft.com/en-US/cpp/cpp/cpp-built-in-operators-precedence-and-associativity |website=docs.microsoft.com |access-date=11 May 2020 |language=en-us}}</ref>

===NotesDetails===

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 <code>a ? b, c : d</code> is interpreted as <code>a ? (b, c) : d</code>, and not as the meaningless <code>(a ? b), (c : d)</code>. So, the expression in the middle of the conditional operator (between <code>'''?'''</code> and <code>''':'''</code>) is parsed as if parenthesized. Also, the immediate, un-parenthesized result of a C cast expression cannot be the operand of <code>sizeof</code>. Therefore, <code>sizeof (int) * x</code> is interpreted as <code>(sizeof(int)) * x</code> and not <code>sizeof ((int) * x)</code>.

===Chained expressions===

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

* For example, <code>++x*3</code> is ambiguous without some precedence rule(s). The precedence table tells us that: {{mono|x}} is 'bound' more tightly to {{mono|++}} than to {{mono|*}}, so that whatever {{mono|++}} does (now or later—see below), it does it ONLY to {{mono|x}} (and not to <code>x*3</code>); it is equivalent to (<code>++x</code>, <code>x*3</code>).

Line 705 ⟶ 708:

* 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===

Many of the operators containing multi-character sequences are given "names" built from the operator name of each character. For example, <code>+=</code> and <code>-=</code> are often called ''plus equal(s)'' and ''minus equal(s)'', instead of the more verbose "assignment by addition" and "assignment by subtraction".

The binding of operators in C and C++ is specified (in the corresponding Standards) 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:

<syntaxhighlight lang="c">logical-OR-expression ? expression : conditional-expression</syntaxhighlight>

while in C++ it is:

Line 718 ⟶ 721:

which is a valid expression.<ref>{{cite web |title=C Operator Precedence - cppreference.com |url=https://en.cppreference.com/w/c/language/operator_precedence |website=en.cppreference.com |access-date=10 April 2020}}</ref><ref>{{Cite web|url=https://stackoverflow.com/questions/13515434/does-the-c-c-ternary-operator-actually-have-the-same-precedence-as-assignment/13515505|title=Does the C/C++ ternary operator actually have the same precedence as assignment operators?|website=Stack Overflow|access-date=2019-09-22}}</ref>

IfTo youuse wantthe tocomma use comma-as-operator withinin a single function call argument expression, variable assignment, or othera comma-separated list, youuse needof toparentheses useis parentheses,required.<ref>{{cite web |title=Other operators - cppreference.com |url=https://en.cppreference.com/w/c/language/operator_other |website=en.cppreference.com |access-date=10 April 2020}}</ref><ref>{{cite web |title=c++ - How does the Comma Operator work |url=https://stackoverflow.com/questions/54142/how-does-the-comma-operator-work/ |website=Stack Overflow |access-date=1 April 2020}}</ref> e.g.:For example,

<syntaxhighlight lang="cpp">
int a = 1, b = 2, weirdVariable = (++a, b), d = 4;
</syntaxhighlight>

===Criticism of bitwise and equality operators precedence===

Line 729 ⟶ 736:

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

==Notes==

=== C++ operator synonyms ===

{{reflist |group="lower-alpha"|refs=

C++ defines<ref name="Committee">{{cite book | title = ISO/IEC 14882:1998(E) Programming Language C++ | date = 1 September 1998 | publisher = open-std.org – The C++ Standards Committee | pages = 40–41}}</ref> certain keywords to act as aliases for a number of operators:

<ref name="sinceCXX11" group="lower-alpha">since C++11</ref>

{| class="wikitable" style="width:30%; text-align:center;"

<ref name="sinceCXX23" group="lower-alpha">since C++23</ref>

! Keyword || Operator

<ref name="modulo" group="lower-alpha">The modulus operator only supports integer operands; for floating point, a function such as [[math.h|{{code|fmod|cpp}}]] can be used.</ref>

|-

<ref name="bitshift" group="lower-alpha">In the context of [[iostream]]s in C++, writers often will refer to {{cpp|<<}} and {{cpp|>>}} as the "put-to" or "stream insertion" and "get-from" or "stream extraction" operators, respectively.</ref>

| {{code|and}} || <code>&&</code>

<ref name="addressof2" group="lower-alpha">The actual address of an object with an overloaded <code>operator &</code> can be obtained with [https://en.cppreference.com/w/cpp/memory/addressof <code>std::addressof</code>]</ref>

|-

<ref name="arrowptr" group="lower-alpha">The return type of {{cpp|operator->()}} must be a type for which the {{cpp |->}} operation can be applied, such as a pointer type. If {{cpp|x}} is of type {{cpp |C}} where {{cpp |C}} overloads {{cpp|operator->()}}, {{cpp|x->y}} gets expanded to {{cpp|x.operator->()->y}}.</ref>

| {{code|and_eq}} || <code>&=</code>

<ref name="arrowstar" group= "lower-alpha">{{Citation | publisher = Aristeia | url = http://aristeia.com/Papers/DDJ_Oct_1999.pdf | title = Implementing operator-&gt;* for Smart Pointers | first = Scott | last = Meyers | journal = Dr. Dobb's Journal |date=Oct 1999}}.</ref>

|-

<ref name="scopal" group="lower-alpha">Although a <code>::</code> punctuator exists in C as of C23, it is not used as a scope resolution operator.</ref>

| {{code|bitand}} || <code>&</code>

<ref name="ud-literal" group="lower-alpha">About [http://en.cppreference.com/w/cpp/language/user_literal C++11 User-defined literals]</ref>

|-

<ref name="sizeof" group="lower-alpha">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|date=July 2024}}</ref>

| {{code|bitor}} || <code>&#x7C;</code>

<ref name="alignof" group = "lower-alpha">C++ defines <code>alignof</code> operator, whereas C defines <code>_Alignof</code> (C23 defines both). Both operators have the same semantics.</ref>

|-

<ref name="threewaycomparison" group="lower-alpha">About [https://en.cppreference.com/w/cpp/language/operator_comparison#Three-way_comparison C++20 three-way comparison]</ref>

| {{code|compl}} || <code>~</code>

|-

| {{code|not}} || <code>!</code>

|-

| {{code|not_eq}} || <code>!=</code>

|-

| {{code|or}} || <code>&#x7C;&#x7C;</code>

|-

| {{code|or_eq}} || <code>&#x7C;=</code>

|-

| {{code|xor}} || <code>^</code>

|-

| {{code|xor_eq}} || <code>^=</code>

|}

<ref name="infer" group="lower-alpha">The type name can also be inferred (e.g <code>new auto</code>) if an initializer is provided.</ref>

These can be used exactly the same way as the punctuation symbols they replace, as they are not the same operator under a different name, but rather simple token replacements for the ''name'' (character string) of the respective operator. This means that the expressions {{code|1=(a > 0 and not flag)}} and {{code|1=(a > 0 && !flag)}} have identical meanings. It also means that, for example, the <code>bitand</code> keyword may be used to replace not only the ''bitwise-and'' operator but also the ''address-of'' operator, and it can even be used to specify reference types (e.g., {{code|1=int bitand ref = n}}). The ISO C specification makes allowance for these keywords as preprocessor macros in the header file [[iso646.h|{{code|iso646.h}}]]. For compatibility with C, C++ also provides the header {{code|iso646.h}}, the inclusion of which has no effect. Until C++20, it also provided the corresponding header [[ciso646|{{code|ciso646}}]] which had no effect as well.

<ref name="infer2" group="lower-alpha">The array size can also be inferred if an initializer is provided.</ref>

}}

==See also==

*[[ {{Annotated link|Bitwise operations in C]]}}

*[[ {{Annotated link|Bit manipulation]]}}

*[[ {{Annotated link|Logical operator]]}}

*[[ {{Annotated link|Boolean algebra (logic)]]}}

*[[ {{Annotated link|Table of logic symbols]]}}

*[[Digraphs and trigraphs (programming)#C|Digraphs and trigraphs in C]] and [[Digraphs and trigraphs (programming)#C.2B.2B|in C++]]

== References ==