Operátoři v C a C ++ - Operators in C and C++
Toto je seznam operátory v C a C ++ programovací jazyky. Všichni uvedení operátoři existují v C ++; čtvrtý sloupec „Zahrnuto do C“ uvádí, zda je operátor také přítomen v C. Všimněte si, že C nepodporuje přetížení operátora.
Pokud není přetížen, pro operátory &&
, ||
, a ,
(dále jen operátor čárky ), tady je bod posloupnosti po vyhodnocení prvního operandu.
C ++ také obsahuje převod typu operátory const_cast
, static_cast
, dynamic_cast
, a reinterpret_cast
. Formátování těchto operátorů znamená, že úroveň jejich priority není důležitá.
Většina operátorů dostupných v C a C ++ je k dispozici také v jiných C-rodina jazyky jako C#, D, Jáva, Perl, a PHP se stejnou prioritou, asociativitou a sémantikou.
Stůl
Pro účely těchto tabulek A
, b
, a C
představují platné hodnoty (literály, hodnoty z proměnných nebo návratovou hodnotu), názvy objektů nebo lvalue, podle potřeby. R
, S
a T
stojan pro jakýkoli typ (typy) a K.
pro typ třídy nebo výčtový typ.
Aritmetické operátory
Jméno operátora | Syntax | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů C ++ | ||
---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | |||||
Základní zadání | A = b | Ano | Ano | R& K.::operátor =(S b); | N / A | |
Přidání | A + b | Ano | Ano | R K.::operátor +(S b); | R operátor +(K. A, S b); | |
Odčítání | A - b | Ano | Ano | R K.::operátor -(S b); | R operátor -(K. A, S b); | |
Unární Plus (celočíselná propagace ) | +A | Ano | Ano | R K.::operátor +(); | R operátor +(K. A); | |
Unární mínus (aditivní inverzní ) | -A | Ano | Ano | R K.::operátor -(); | R operátor -(K. A); | |
Násobení | A * b | Ano | Ano | R K.::operátor *(S b); | R operátor *(K. A, S b); | |
Divize | A / b | Ano | Ano | R K.::operátor /(S b); | R operátor /(K. A, S b); | |
Modulo (zbytek celého čísla)[A] | A % b | Ano | Ano | R K.::operátor %(S b); | R operátor %(K. A, S b); | |
Přírůstek | Předpona | ++A | Ano | Ano | R& K.::operátor ++(); | R& operátor ++(K.& A); |
Postfix | A++ | Ano | Ano | R K.::operátor ++(int); | R operátor ++(K.& A, int); | |
Poznámka: C ++ používá nepojmenovaný fiktivní parametr int rozlišovat mezi operátory přírůstku předpony a postfixu. | ||||||
Snížení | Předpona | --A | Ano | Ano | R& K.::operátor --(); | R& operátor --(K.& A); |
Postfix | A-- | Ano | Ano | R K.::operátor --(int); | R operátor --(K.& A, int); | |
Poznámka: C ++ používá nepojmenovaný fiktivní parametr int rozlišovat mezi operátory dekódování prefixů a postfixů. |
Porovnávací operátoři / relační operátoři
Jméno operátora | Syntax | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů | ||
---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | |||||
Rovná | A == b | Ano | Ano | bool K.::operátor ==(S konst& b) konst; | bool operátor ==(K. konst& A, S konst& b); | |
Nerovná se | A != b A not_eq b [b] | Ano | Ano | bool K.::operátor !=(S konst& b); bool K.::operátor !=(S konst& b) konst; | bool operátor !=(K. konst& A, S konst& b); | |
Větší než | A > b | Ano | Ano | bool K.::operátor >(S konst& b) konst; | bool operátor >(K. konst& A, S konst& b); | |
Méně než | A < b | Ano | Ano | bool K.::operátor <(S konst& b) konst; | bool operátor <(K. konst& A, S konst& b); | |
Větší než nebo rovno | A >= b | Ano | Ano | bool K.::operátor >=(S konst& b) konst; | bool operátor >=(K. konst& A, S konst& b); | |
Méně než nebo rovno | A <= b | Ano | Ano | bool K.::operátor <=(S konst& b) konst; | bool operátor <=(K. konst& A, S konst& b); | |
Třícestné srovnání[C] | A <=> b | Ano | Ne | std::slabá_rovnost K.::operátor <=>(konst S &b); | std::slabá_rovnost operátor <=>(konst K. &A, konst S &b); | |
Poznámka: Provozovatel má celkem 6 typů vrácení: std :: slabá_rovnost , std :: strong_equality , std :: částečné_objednávání , std :: slabé_objednávání , std :: strong_ordering , a std :: common_comparison_category |
Logické operátory
Jméno operátora | Syntax | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů C ++ | ||
---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | |||||
Logická negace (NE) | !A ne A [b] | Ano | Ano | bool K.::operátor !(); | bool operátor !(K. A); | |
Logické AND | A && b A a b [b] | Ano | Ano | bool K.::operátor &&(S b); | bool operátor &&(K. A, S b); | |
Logické NEBO | A || b A nebo b [b] | Ano | Ano | bool K.::operátor ||(S b); | bool operátor ||(K. A, S b); |
Bitové operátory
Jméno operátora | Syntax | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů | ||
---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | |||||
Bitové NENÍ | ~A kompl A [b] | Ano | Ano | R K.::operátor ~(); | R operátor ~(K. A); | |
Bitové AND | A & b A bitand b [b] | Ano | Ano | R K.::operátor &(S b); | R operátor &(K. A, S b); | |
Bitové NEBO | A | b A Bitor b [b] | Ano | Ano | R K.::operátor |(S b); | R operátor |(K. A, S b); | |
Bitový XOR | A ^ b A xor b [b] | Ano | Ano | R K.::operátor ^(S b); | R operátor ^(K. A, S b); | |
Bitový posun vlevo[d] | A << b | Ano | Ano | R K.::operátor <<(S b); | R operátor <<(K. A, S b); | |
Bitový posun doprava[d][E] | A >> b | Ano | Ano | R K.::operátor >>(S b); | R operátor >>(K. A, S b); |
Složené operátory přiřazení
Jméno operátora | Syntax | Význam | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů C ++ | ||
---|---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | ||||||
Přiřazení sčítání | A += b | A = A + b | Ano | Ano | R& K.::operátor +=(S b); | R& operátor +=(K.& A, S b); | |
Přiřazení odčítání | A -= b | A = A - b | Ano | Ano | R& K.::operátor -=(S b); | R& operátor -=(K.& A, S b); | |
Přiřazení násobení | A *= b | A = A * b | Ano | Ano | R& K.::operátor *=(S b); | R& operátor *=(K.& A, S b); | |
Přiřazení divize | A /= b | A = A / b | Ano | Ano | R& K.::operátor /=(S b); | R& operátor /=(K.& A, S b); | |
Přiřazení modulo | A %= b | A = A % b | Ano | Ano | R& K.::operátor %=(S b); | R& operátor %=(K.& A, S b); | |
Bitové a přiřazení | A &= b A a_ekv b [b] | A = A & b | Ano | Ano | R& K.::operátor &=(S b); | R& operátor &=(K.& A, S b); | |
Bitové NEBO přiřazení | A |= b A or_eq b [b] | A = A | b | Ano | Ano | R& K.::operátor |=(S b); | R& operátor |=(K.& A, S b); | |
Bitové přiřazení XOR | A ^= b A xor_eq b [b] | A = A ^ b | Ano | Ano | R& K.::operátor ^=(S b); | R& operátor ^=(K.& A, S b); | |
Přiřazení bitového posunu vlevo | A <<= b | A = A << b | Ano | Ano | R& K.::operátor <<=(S b); | R& operátor <<=(K.& A, S b); | |
Přiřazení bitového posunu doprava[E] | A >>= b | A = A >> b | Ano | Ano | R& K.::operátor >>=(S b); | R& operátor >>=(K.& A, S b); |
Provozovatelé členů a ukazatelů
Jméno operátora | Syntax | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů C ++ | ||
---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | |||||
Dolní index | A[b] | Ano | Ano | R& K.::operátor [](S b); | N / A | |
Indirection ("objekt, na který ukazuje A") | *A | Ano | Ano | R& K.::operátor *(); | R& operátor *(K. A); | |
Address-of ("adresa A") | &A | Ano | Ano | R* K.::operátor &(); | R* operátor &(K. A); | |
Struktura dereference ("člen b objektu, na který ukazuje A") | A->b | Ano | Ano | R* K.::operátor ->(); [F] | N / A | |
Odkaz na strukturu ("člen b objektu A") | A.b | Ne | Ano | N / A | ||
Člen vybraný uživatelem ukazatel na člena b objektu, na který ukazuje A[G] | A->*b | Ano | Ne | R& K.::operátor ->*(S b); | R& operátor ->*(K. A, S b); | |
Člen objektu A vybráno uživatelem ukazatel na člena b | A.*b | Ne | Ne | N / A |
Ostatní operátoři
Jméno operátora | Syntax | Může přetížit v C ++ | Zahrnuta v C | Příklady prototypů | ||
---|---|---|---|---|---|---|
Jako člen K. | Definice mimo třídu | |||||
Funkce volání Vidět Funkční objekt. | A(a1, a2) | Ano | Ano | R K.::operátor ()(S A, T b, ...); | N / A | |
Čárka | A, b | Ano | Ano | R K.::operátor ,(S b); | R operátor ,(K. A, S b); | |
Ternární podmíněné | A ? b : C | Ne | Ano | N / A | ||
Rozlišení rozsahu | A::b | Ne | Ne | N / A | ||
Uživatelem definované literály[h] od C ++ 11 | „a“ _b | Ano | Ne | N / A | R operátor "" _b(T A) | |
Velikost | velikost(A) [i]velikost(typ) | Ne | Ano | N / A | ||
Velikost balíček parametrů od C ++ 11 | velikost...(Args) | Ne | Ne | N / A | ||
Alignof od C ++ 11 | alignof(typ) nebo _Alignof(typ) [j] | Ne | Ano | N / A | ||
Identifikace typu | psí typ(A) psí typ(typ) | Ne | Ne | N / A | ||
Konverze (Obsazení ve stylu C) | (typ)A | Ano | Ano | K.::operátor R(); [2] | N / A | |
Konverze | typ(A) | Ne | Ne | Poznámka: chová se jako const_cast / static_cast / reinterpret_cast[3] | ||
static_cast konverze | static_cast<typ> (a) | Ano | Ne | K.::operátor R(); explicitní K.::operátor R(); od C ++ 11 | N / A | |
Poznámka: pro uživatelem definované převody se návratový typ implicitně a nutně shoduje s názvem operátora. | ||||||
dynamické obsazení konverze | dynamic_cast<typ> (a) | Ne | Ne | N / A | ||
const_cast konverze | const_cast<typ> (a) | Ne | Ne | N / A | ||
reinterpret_cast konverze | reinterpret_cast<typ> (a) | Ne | Ne | N / A | ||
Přidělte úložiště | Nový typ | Ano | Ne | prázdnota* K.::operátor Nový(size_t X); | prázdnota* operátor Nový(size_t X); | |
Přidělit úložiště (pole) | Nový typ[n] | Ano | Ne | prázdnota* K.::operátor Nový[](size_t A); | prázdnota* operátor Nový[](size_t A); | |
Přidělit úložiště | vymazat A | Ano | Ne | prázdnota K.::operátor vymazat(prázdnota* A); | prázdnota operátor vymazat(prázdnota* A); | |
Deallocate storage (array) | vymazat[] A | Ano | Ne | prázdnota K.::operátor vymazat[](prázdnota* A); | prázdnota operátor vymazat[](prázdnota* A); | |
Kontrola výjimek od C ++ 11 | noexcept(A) | Ne | Ne | N / A |
Poznámky:
- ^ Operátor modulu pracuje pouze s celočíselnými operandy, pro čísla s plovoucí desetinnou čárkou musí být místo toho použita funkce knihovny (jako
fmod
). - ^ A b C d E F G h i j k Vyžaduje
iso646.h
v C. Viz Synonyma operátorů C ++ - ^ O C ++ 20 třícestné srovnání
- ^ A b V kontextu proudy, na které se spisovatelé často budou odvolávat
<<
a>>
jako operátory „put-to“ nebo „stream streaming“ a „get-from“ nebo „stream mining“. - ^ A b Podle standardu C99 je definován pravý posun záporného čísla. Většina implementací, např. GCC,[1] použít aritmetický posun (tj. přípona znaménka), ale a logický posun je možné.
- ^ Návratový typ
operátor->()
musí být typ, pro který->
lze použít operaci, například typ ukazatele. LiX
je typuC
kdeC
přetíženíoperátor->()
,X->y
se rozšíří naX.operátor->()->y
. - ^ Meyers, Scott (říjen 1999), „Implementující operátor -> * pro inteligentní ukazatele“ (PDF), Dr. Dobb's Journal, Aristeia.
- ^ O C ++ 11 Uživatelem definované literály
- ^ Závorky nejsou nutné, když vezmete velikost hodnoty, pouze když vezmete velikost typu. Obvykle se však používají bez ohledu na to.
- ^ C ++ definuje
alignof
operátor, zatímco C definuje_Alignof
. Oba operátoři mají stejnou sémantiku.
Priorita operátora
Následuje tabulka se seznamem přednost a asociativita všech operátorů v C a C ++ jazyky (pokud operátoři existují také v Jáva, Perl, PHP a mnoho dalších nedávných jazyků je priorita stejná jako daná[Citace je zapotřebí ]). Operátory jsou uvedeny shora dolů, v sestupném pořadí. Klesající priorita odkazuje na prioritu seskupení operátorů a operandů. Vzhledem k výrazu bude operátor, který je uveden na nějakém řádku, seskupen před jakýmkoli operátorem, který je uveden na řádku dále pod ním. Operátory, které jsou ve stejné buňce (v buňce může být několik řádků operátorů), jsou seskupeny se stejnou prioritou v daném směru. Přednost operátora není ovlivněna přetížením.
Syntaxe výrazů v C a C ++ je specifikována a frázová struktura gramatiky.[4] Tabulka zde uvedená byla odvozena z gramatiky.[Citace je zapotřebí ] Pro normu ISO C 1999, část 6.5.6, poznámka 71 uvádí, že gramatika C poskytovaná specifikací definuje prioritu operátorů C, a také uvádí, že priorita operátorů vyplývající z gramatiky úzce sleduje pořadí sekce specifikace:
"Syntaxe [C] [tj. gramatika] určuje prioritu operátorů při hodnocení výrazu, která je stejná jako pořadí hlavních článků této kapitoly, nejvyšší priorita jako první. “[5]
Tabulka priorit, i když je většinou adekvátní, nemůže vyřešit několik podrobností. Zejména si všimněte, že ternární operátor umožňuje jakýkoli libovolný výraz jako jeho prostřední operand, přestože má vyšší prioritu než operátory přiřazení a čárky. Tím pádem a? b, c: d
je interpretován jako a? (b, c): d
, a ne jako nesmyslné (abeceda)
. Takže výraz uprostřed podmíněného operátoru (mezi ?
a :
) je analyzován, jako by byl uveden v závorkách. Všimněte si také, že okamžitý, neidentifikovaný výsledek výrazu C cast nemůže být operandem velikost
. Proto, sizeof (int) * x
je interpretován jako (sizeof (int)) * x
a ne sizeof ((int) * x)
.
Přednost | Operátor | Popis | Asociativita |
---|---|---|---|
1 nejvyšší | :: | Rozlišení rozsahu (Pouze C ++) | Žádný |
2 | ++ | Přírůstek Postfixu | Zleva do prava |
-- | Snížení Postfixu | ||
() | Volání funkce | ||
[] | Pole indexování | ||
. | Výběr prvku odkazem | ||
-> | Výběr prvku ukazatelem | ||
psací stroj () | Informace o typu běhu (Pouze C ++) (viz psí typ ) | ||
const_cast | Zadejte cast (pouze C ++) (viz const_cast ) | ||
dynamic_cast | Zadejte cast (pouze C ++) (viz dynamické obsazení ) | ||
reinterpret_cast | Zadejte cast (pouze C ++) (viz reinterpret_cast ) | ||
static_cast | Zadejte cast (pouze C ++) (viz static_cast ) | ||
3 | ++ | Přírůstek předpony | Zprava doleva |
-- | Snížení předpony | ||
+ | Unární plus | ||
- | Unární mínus | ||
! | Logické NE | ||
~ | Bitový NOT (doplněk) | ||
(typ) | Typ obsazení | ||
* | Indirection (dereference) | ||
& | Adresa | ||
velikost | Velikost | ||
_Alignof | Požadavek vyrovnání (od C11) | ||
Nový , Nový[] | Dynamické přidělování paměti (pouze C ++) | ||
vymazat , vymazat[] | Dynamické uvolnění paměti (pouze C ++) | ||
4 | .* | Ukazatel na člena (pouze C ++) | Zleva do prava |
->* | Ukazatel na člena (pouze C ++) | ||
5 | * | Násobení | Zleva do prava |
/ | Divize | ||
% | Modulo (zbytek) | ||
6 | + | Přidání | Zleva do prava |
- | Odčítání | ||
7 | << | bitový levý Shift | Zleva do prava |
>> | bitový pravý posun | ||
8 | <=> | Třícestné srovnání (Představeno v C ++ 20 - pouze C ++) | Zleva do prava |
9 | < | Méně než | Zleva do prava |
<= | Méně než nebo rovno | ||
> | Větší než | ||
>= | Větší než nebo rovno | ||
10 | == | Rovná | Zleva do prava |
!= | Nerovná se | ||
11 | & | Bitové AND | Zleva do prava |
12 | ^ | Bitový XOR (exkluzivní nebo) | Zleva do prava |
13 | | | Bitový OR (včetně nebo) | Zleva do prava |
14 | && | Logické AND | Zleva do prava |
15 | || | Logické NEBO | Zleva do prava |
16 | ?: | Trojice podmíněné (viz ?: ) | Zprava doleva |
= | Přímé přiřazení | ||
+= | Přiřazení podle částky | ||
-= | Přiřazení rozdílem | ||
*= | Přiřazení podle produktu | ||
/= | Přiřazení kvocientem | ||
%= | Přiřazení do konce | ||
<<= | Přiřazení bitovým posunem doleva | ||
>>= | Přiřazení bitovým posunem doprava | ||
&= | Přiřazení bitovým AND | ||
^= | Přiřazení bitovým XOR | ||
|= | Přiřazení po bitech NEBO | ||
házet | Operátor vyvolání (vyvolání výjimek, pouze C ++) | ||
17 Nejnižší | , | Čárka | Zleva do prava |
Poznámky
Tabulka priorit určuje pořadí vazby v zřetězených výrazech, pokud není výslovně uvedeno v závorkách.
- Například,
++ x * 3
je nejednoznačný bez nějakých pravidel priority. Tabulka priorit nám říká, že: X je „pevně vázán“ na ++ než do *, takže cokoli ++ dělá (nyní nebo později - viz níže), dělá to POUZE X (a nex * 3
); je ekvivalentní k (++ x
,x * 3
). - Podobně s
3 * x ++
, kde ačkoli post-fix ++ je navržen tak, aby fungoval PO VYHODNOCENÍ celého výrazu, z tabulky priorit je jasné, že POUZE X se zvýší (a NE3 * x
). Ve skutečnosti je výraz (tmp = x ++
,3 * tmp
) se hodnotí pomocí tmp být dočasnou hodnotou. Je funkčně ekvivalentní něčemu jako (tmp = 3 * x
,++ x
,tmp
).

- Při abstrahování problému priority nebo vazby zvažte výše uvedený diagram pro výraz 3 + 2 * y [i] ++. Úkolem překladače je vyřešit diagram do výrazu, ve kterém několik unárních operátorů (říkejte jim 3+ (.), 2 * (.), (.) ++ a (.) [I]) soutěží o vazbu do r. Tabulka pořadí priorit řeší konečný podvýraz, na který každý působí: (.) [I] působí pouze na y, (.) ++ působí pouze na y [i], 2 * (.) Působí pouze na y [ i] ++ a 3+ (.) působí „pouze“ na 2 * ((y [i]) ++). Je důležité si uvědomit, že NA KTERÝ podvýraz, se kterým každý operátor jedná, je zřejmé z tabulky priorit, ale KDY každý operátor jedná není podle tabulky priorit vyřešen; v tomto příkladu operátor (.) ++ působí pouze na y [i] podle pravidel priority, ale samotné úrovně vazby nenaznačují načasování postfix ++ (operátor (.) ++ jedná až po y [i ] je hodnocena ve výrazu).
Mnoho operátorů obsahujících víceznakové sekvence dostává „jména“ vytvořená z názvu operátora každého znaku. Například, +=
a -=
jsou často nazývány plus rovná se a minus rovná (s), namísto podrobnějšího „přiřazení přidáním“ a „přiřazení odečtením“. Vazba operátorů v C a C ++ je specifikována (v odpovídajících standardech) gramatikou faktorizovaného jazyka, spíše než tabulkou priorit. To vytváří jemné konflikty. Například v jazyce C je syntaxe podmíněného výrazu:
logický-NEBO-výraz ? výraz : podmiňovací způsob-výraz
zatímco v C ++ je:
logický-NEBO-výraz ? výraz : úkol-výraz
Proto je výraz:
e = a
je ve dvou jazycích analyzován odlišně. V jazyce C je tento výraz syntaktickou chybou, protože syntaxe pro přiřazovací výraz v jazyce C je:
unární-výraz '=' úkol-výraz
V C ++ se analyzuje jako:
E = (A < d ? A++ : (A = d))
Pokud chcete použít čárku jako operátor v rámci jediného argumentu funkce, přiřazení proměnné nebo jiného seznamu odděleného čárkami, musíte použít závorky,[11][12] např.:
int A = 1, b = 2, divná proměnná = (++A, b), d = 4;
Kritika priorit bitových operátorů a operátorů rovnosti
Byla kritizována priorita bitových logických operátorů.[13] Koncepčně & a | jsou aritmetické operátory jako * a +.
Výraz A & b == 7
je syntakticky analyzován jako A & (b == 7)
zatímco výraz A + b == 7
je analyzován jako (A + b) == 7
. To vyžaduje, aby se závorky používaly častěji, než by byly jinak.
Historicky neexistoval žádný syntaktický rozdíl mezi bitovými a logickými operátory. v BCPL, B a brzy C, operátoři && ||
neexistoval. Namísto & |
měly odlišný význam v závislosti na tom, zda se používají v kontextu „pravdivostní hodnoty“ (tj. kdy se očekávala logická hodnota, například v -li (A==b & C) {...}
choval se jako logický operátor, ale v C = A & b
choval se jako bitový). Byla zachována, aby byla zachována zpětná kompatibilita se stávajícími instalacemi.[14]
Navíc v C ++ (a novějších verzích C) operace rovnosti, s výjimkou operátoru třícestného porovnání, přinášejí bool zadejte hodnoty, které jsou koncepčně jediným bitem (1 nebo 0) a jako takové nepatří správně do „bitových“ operací.
Synonyma operátorů C ++
C ++ definuje[15] určitá klíčová slova, která fungují jako aliasy pro řadu operátorů:
Klíčové slovo | Operátor |
---|---|
a | && |
a_ekv | &= |
bitand | & |
Bitor | | |
kompl | ~ |
ne | ! |
not_eq | != |
nebo | || |
or_eq | |= |
xor | ^ |
xor_eq | ^= |
Ty lze použít přesně stejným způsobem jako interpunkční symboly, které nahrazují, protože se nejedná o stejný operátor pod jiným názvem, ale spíše o jednoduché nahrazení tokenů název (řetězec znaků) příslušného operátora. To znamená, že výrazy (a> 0 a ne příznak)
a (a> 0 &&! vlajka)
mají stejné významy. To také znamená, že například bitand
klíčové slovo lze použít nejen k nahrazení bitové - a operátor, ale také adresa operátor a lze jej dokonce použít k určení referenčních typů (např. int bitand ref = n
). Specifikace ISO C umožňuje těmto klíčovým slovům jako makra preprocesoru v souboru záhlaví iso646.h
. Pro kompatibilitu s C poskytuje záhlaví C ++ ciso646
, jehož zahrnutí nemá žádný účinek.
Viz také
- Bitové operace v C
- Manipulace s bitem
- Logický operátor
- Booleova algebra (logika)
- Tabulka logických symbolů
- Digrafy a trigrafy v jazyce C. a v C ++
Reference
- ^ "Implementace celých čísel", GCC 4.3.3, GNU.
- ^ „uživatelem definovaná konverze“. Citováno 5. dubna 2020.
- ^ Explicitní převod typu v C ++
- ^ ISO / IEC 9899: 201x Programming Languages - C. open-std.org - Výbor pro standardy C. 19. prosince 2011. s. 465.
- ^ norma ISO C 1999, část 6.5.6, poznámka 71 (Technická zpráva). ISO. 1999.
- ^ „Preference operátora C - cppreference.com“. en.cppreference.com. Citováno 16. července 2019.
- ^ „Integrovaní operátoři C ++, přednost a asociativita“. docs.microsoft.com. Citováno 11. května 2020.
- ^ „Preference operátora C ++ - cppreference.com“. en.cppreference.com. Citováno 16. července 2019.
- ^ „Preference operátora C - cppreference.com“. en.cppreference.com. Citováno 10. dubna 2020.
- ^ "Má ternární operátor C / C ++ ve skutečnosti stejnou prioritu jako operátory přiřazení?". Přetečení zásobníku. Citováno 22. září 2019.
- ^ „Ostatní operátoři - cppreference.com“. en.cppreference.com. Citováno 10. dubna 2020.
- ^ „c ++ - Jak funguje operátor čárky“. Přetečení zásobníku. Citováno 1. dubna 2020.
- ^ C historie § Novorozenci C Bell Bells.
- ^ „Re ^ 10: další, pokud není podmínka“. www.perlmonks.org. Citováno 23. března 2018.
- ^ ISO / IEC 14882: 1998 (E) Programming Language C ++. open-std.org - Výbor pro standardy C ++. 1. září 1998. s. 40–41.
externí odkazy
- "Provozovatelé", C ++ reference (wiki).
- Přednost operátora C.
- Operátoři přírůstku a snížení Postfixu: ++ a - (Vývojářská síť), Microsoft.