Severity: Notice
Message: Undefined offset: 1
Filename: infosekolah/leftmenudasboard.php
Line Number: 33
Line Number: 34
This is a list of operators in the C and C++ programming languages.
All listed operators are in C++ and lacking indication otherwise, in C as well. Some tables include a "In C" column that indicates whether an operator is also in C. Note that C does not support operator overloading.
When not overloaded, for the operators &&, ||, and , (the comma operator), there is a sequence point after the evaluation of the first operand.
&&
||
,
Most of the operators available in C and C++ are also available in other C-family languages such as C#, D, 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, += and -= are often called "plus equal(s)" and "minus equal(s)", instead of the more verbose "assignment by addition" and "assignment by subtraction".
+=
-=
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.
a
b
R
S
T
K
C and C++ have the same arithmetic operators and all can be overloaded in C++.
a + b
R K::operator +(S b);
R operator +(K a, S b);
a - b
R K::operator -(S b);
R operator -(K a, S b);
+a
R K::operator +();
R operator +(K a);
-a
R K::operator -();
R operator -(K a);
a * b
R K::operator *(S b);
R operator *(K a, S b);
a / b
R K::operator /(S b);
R operator /(K a, S b);
a % b
R K::operator %(S b);
R operator %(K a, S b);
++a
R& K::operator ++();
R& operator ++(K& a);
a++
R K::operator ++(int);
R operator ++(K& a, int);
--a
R& K::operator --();
R& operator --(K& a);
a--
R K::operator --(int);
R operator --(K& a, int);
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.[1]
operator==
operator<=>
a == b
bool K::operator ==(S const& b) const;
bool operator ==(K const& a, S const& b);
a != b
bool K::operator !=(S const& b) const;
bool operator !=(K const& a, S const& b);
a > b
bool K::operator >(S const& b) const;
bool operator >(K const& a, S const& b);
a < b
bool K::operator <(S const& b) const;
bool operator <(K const& a, S const& b);
a >= b
bool K::operator >=(S const& b) const;
bool operator >=(K const& a, S const& b);
a <= b
bool K::operator <=(S const& b) const;
bool operator <=(K const& a, S const& b);
a <=> b
auto K::operator <=>(const S &b);
auto operator <=>(const K &a, const S &b);
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.[2]
!a
bool K::operator !();
bool operator !(K a);
a && b
bool K::operator &&(S b);
bool operator &&(K a, S b);
a || b
bool K::operator ||(S b);
bool operator ||(K a, S b);
C and C++ have the same bitwise operators and all can be overloaded in C++.
~a
R K::operator ~();
R operator ~(K a);
a & b
R K::operator &(S b);
R operator &(K a, S b);
a | b
R K::operator |(S b);
R operator |(K a, S b);
a ^ b
R K::operator ^(S b);
R operator ^(K a, S b);
a << b
R K::operator <<(S b);
R operator <<(K a, S b);
a >> b
R K::operator >>(S b);
R operator >>(K a, S b);
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.
a ⊚= b
⊚
a = a ⊚ b
a = b
R& K::operator =(S b);
a += b
R& K::operator +=(S b);
R& operator +=(K& a, S b);
a -= b
R& K::operator -=(S b);
R& operator -=(K& a, S b);
a *= b
R& K::operator *=(S b);
R& operator *=(K& a, S b);
a /= b
R& K::operator /=(S b);
R& operator /=(K& a, S b);
a %= b
R& K::operator %=(S b);
R& operator %=(K& a, S b);
a &= b
R& K::operator &=(S b);
R& operator &=(K& a, S b);
a |= b
R& K::operator |=(S b);
R& operator |=(K& a, S b);
a ^= b
R& K::operator ^=(S b);
R& operator ^=(K& a, S b);
a <<= b
R& K::operator <<=(S b);
R& operator <<=(K& a, S b);
a >>= b
R& K::operator >>=(S b);
R& operator >>=(K& a, S b);
a[b]
a<:b:>
R& K::operator [](S b);
R& K::operator [](S b, ...);
*a
R& K::operator *();
R& operator *(K a);
&a
R* K::operator &();
R* operator &(K a);
a->b
R* K::operator ->();
a.b
a->*b
R& K::operator ->*(S b);
R& operator ->*(K a, S b);
a.*b
a(a1, a2)
R K::operator ()(S a, T b, ...);
a, b
R K::operator ,(S b);
R operator ,(K a, S b);
a ? b : c
a::b
"a"_b
R operator "" _b(T a)
sizeof a
sizeof (R)
sizeof...(Args)
alignof(R)
_Alignof(R)
decltype (a)
decltype (R)
typeid(a)
typeid(R)
(R)a
K::operator R();
R(a)
R{a}
auto(a)
auto{a}
static_cast<R>(a)
explicit K::operator R();
dynamic_cast<R>(a)
const_cast<R>(a)
reinterpret_cast<R>(a)
new R
void* K::operator new(size_t x);
void* operator new(size_t x);
new R[n]
void* K::operator new[](size_t a);
void* operator new[](size_t a);
delete a
void K::operator delete(void* a);
void operator delete(void* a);
delete[] a
void K::operator delete[](void* a);
void operator delete[](void* a);
noexcept(a)
C++ defines keywords to act as aliases for a number of operators:[7]
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).
(a > 0 and not flag)
(a > 0 && !flag)
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.
iso646.h
ciso646
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).[8][9][10]
Operator precedence is not affected by overloading.
highest
::
++
--
()
[]
.
->
typeid()
const_cast
dynamic_cast
reinterpret_cast
static_cast
+
-
(type)
*
sizeof
_Alignof
new
new[]
delete
delete[]
.*
->*
/
%
<<
>>
<=>
<
<=
>
>=
==
co_await
co_yield
?:
=
*=
/=
%=
<<=
>>=
throw
lowest
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).
a ? b, c : d
a ? (b, c) : d
(a ? b), (c : d)
?
:
sizeof (int) * x
(sizeof(int)) * x
sizeof ((int) * x)
The precedence table determines the order of binding in chained expressions, when it is not expressly specified by parentheses.
++x*3
x*3
++x
3*x++
3*x
tmp=x++
3*tmp
tmp=3*x
tmp
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.[11][12]
To use the comma operator in a function call argument expression, variable assignment, or a comma-separated list, use of parentheses is required.[13][14] For example,
int a = 1, b = 2, weirdVariable = (++a, b), d = 4;
The precedence of the bitwise logical operators has been criticized.[15] 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.
a & b == 7
a & (b == 7)
a + b == 7
(a + b) == 7
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.[16]
&& ||
& |
if (a==b & c) {...}
c = a & b
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.
fmod
int
std::weak_ordering
std::strong_ordering
std::partial_ordering
operator &
std::addressof
operator->()
x
C
x->y
x.operator->()->y
alignof
auto
auto x(a);
auto x{a};
operator auto()
operator decltype(auto)()
new auto
