Operatori u programskim jezicima C i C++
Operatori u programskim jezicima C i C++ su konstrukcije koje se ponašaju na sličan način poput funkcija, ali se razlikuju sintaksno ili semantički od uobičajenih funkcija. Svi operatori navedeni u tabelama ispod postoje u programskom jeziku C++; četvrta kolona „Uključeno u C”, navodi da li je operator takođe prisutan u programskom jeziku C. Treba imati na umu da C ne podržava preklapanje operatora.
Kada nisu preklopljeni, za operatore &&
, ||
, i ,
(operator zareza), postoji tačka sekvence nakon procjene prvog operanda.
C++ takođe sadrži operatore konverzije tipa const_cast
, static_cast
, dynamic_cast
i reinterpret_cast
. Formatiranje ovih operatora znači da je njihov nivo prioriteta nevažan.
Većina operatora dostupnih u C i C++ su takođe dostupni i u drugim jezicima kao što su C#, D, Java, Perl i PHP sa istim prioritetom, asocijativnošću i semantikom.
Spisak operatora[uredi | uredi izvor]
Za potrebe ovih tabela, a
, b
i c
predstavljaju važeće vrijednosti (literale, vrijednosti varijabli ili povratne vrijednosti), nazive objekata ili vrijednosti, po potrebi. R
, S
i T
mogu biti bilo koji tip(ovi), a K
je klasa ili nabrojivi tip.
Aritmetički operatori[uredi | uredi izvor]
Naziv operatora | Sintaksa | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | ||||||
Operator dodjele | a '''=''' b |
Da | Da | R& K::operator =(S b);
|
N/D | [1] | |
Sabiranje | a '''+''' b |
Da | Da | R K::operator +(S b);
|
R operator +(K a, S b);
|
[2] | |
Oduzimanje | a '''-''' b |
Da | Da | R K::operator -(S b);
|
R operator -(K a, S b);
|
[2] | |
Unarno sabiranje | '''+'''a |
Da | Da | R K::operator +();
|
R operator +(K a);
|
[3] | |
Unarno oduzimanje | '''-'''a |
Da | Da | R K::operator -();
|
R operator -(K a);
|
[3] | |
Množenje | a '''*''' b |
Da | Da | R K::operator *(S b);
|
R operator *(K a, S b);
|
[4] | |
Dijeljenje | a '''/''' b |
Da | Da | R K::operator /(S b);
|
R operator /(K a, S b);
|
[4] | |
Moduo (ostatak pri dijeljenju) | a '''%''' b |
Da | Da | R K::operator %(S b);
|
R operator %(K a, S b);
|
[4] | |
Inkrement | Prefiks | '''++'''a
|
Da | Da | R& K::operator ++();
|
R& operator ++(K& a);
|
[5] |
Postfiks | a'''++'''
|
Da | Da | R K::operator ++(int);
|
R operator ++(K& a, int);
|
[6] | |
Napomena: C++ koristi neimenovani lažni parametar int kako bi se razlikovali prefiksni i postfiksni operatori za inkrementaciju.
| |||||||
Dekrement | Prefiks | '''--'''a |
Da | Da | R& K::operator --();
|
R& operator --(K& a);
|
[5] |
Postfiks | a'''--''' |
Da | Da | R K::operator --(int);
|
R operator --(K& a, int);
|
[6] | |
Napomena: C++ koristi neimenovani lažni parametar int kako bi se razlikovali prefiksni i postfiksni operatori za dekrementaciju.
|
Operatori poređenja/relacioni operatori[uredi | uredi izvor]
Naziv operatora | Sintaksa | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | ||||||
Jednakost | a '''==''' b
|
Da | Da | bool K::operator ==(S const& b) const
|
bool operator ==(K const& a, S const& b)
|
[7] | |
Nejednakost | a '''!=''' b a '''not_eq''' b |
Da | Da | bool K::operator !=(S const& b) bool K::operator !=(S const& b) const
|
bool operator !=(K const& a, S const& b)
|
[7] | |
Veće od | a '''>''' b |
Da | Da | bool K::operator >(S const& b) const
|
bool operator >(K const& a, S const& b)
|
[7] | |
Manje od | a '''<''' b |
Da | Da | bool K::operator <(S const& b)const
|
bool operator <(K const& a, S const& b)
|
[7] | |
Veće ili jednako od | a '''>=''' b |
Da | Da | bool K::operator >=(S const& b) const
|
bool operator >=(K const& a, S const& b)
|
[7] | |
Manje ili jednako od | a '''<=''' b |
Da | Da | bool K::operator <=(S const& b)
|
bool operator <=(K const& a, S const& b)
|
[7] | |
Trostepeno poređenje | a '''<=>''' b |
Da | Ne | std::weak_equality K::operator <=>(const S &b)
|
std::weak_equality operator <=>(const K &a, const S &b)
|
[7] | |
Napomena: Operator ima ukupno 6 povratnih vrijednosti: std::weak_equality , std::strong_equality , std::partial_ordering , std::weak_ordering , std::strong_ordering , and std::common_comparison_category
|
[8] |
Logički operatori[uredi | uredi izvor]
Naziv operatora | Sintaksa | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | ||||||
Logička negacija | '''!'''a '''not''' a
|
Da | Da | bool K::operator !();
|
bool operator !(K a);
|
[9] | |
Logička konjunkcija | a '''&&''' b a '''and''' b |
Da | Da | bool K::operator &&(S b);
|
bool operator &&(K a, S b);
|
[10] | |
Logička disjunkcija | a '''||''' b a '''or''' b |
Da | Da | bool K::operator ||(S b);
|
bool operator ||(K a, S b);
|
[11] |
Operatori nad bitovima[uredi | uredi izvor]
Naziv operatora | Sintaksa | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | ||||||
Negacija | ~a compl a
|
Da | Da | R K::operator ~();
|
R operator ~(K a);
|
[12] | |
Konjunkcija | a & b a bitand b |
Da | Da | R K::operator &(S b);
|
R operator &(K a, S b);
|
[13] | |
Disjunkcija | a | b a bitor b |
Da | Da | R K::operator |(S b);
|
R operator |(K a, S b);
|
[14] | |
Isključiva disjunkcija | a ^ b a xor b |
Da | Da | R K::operator ^(S b);
|
R operator ^(K a, S b);
|
[15] | |
Pomjeranje ulijevo | a << b |
Da | Da | R K::operator <<(S b);
|
R operator <<(K a, S b);
|
[16] | |
Pomjeranje udesno | a >> b |
Da | Da | R K::operator >>(S b);
|
R operator >>(K a, S b);
|
[16] |
Operatori složene dodjele[uredi | uredi izvor]
Naziv operatora | Sintaksa | Značenje | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | |||||||
Sabiranje i dodjela | a += b
|
a = a + b
|
Da | Da | R& K::operator +=(S b);
|
R& operator +=(K& a, S b);
|
[17] | |
Oduzimanje i dodjela | a -= b
|
a = a - b
|
Da | Da | R& K::operator -=(S b);
|
R& operator -=(K& a, S b);
|
[17] | |
Množenje i dodjela | a *= b
|
a = a * b
|
Da | Da | R& K::operator *=(S b);
|
R& operator *=(K& a, S b);
|
[17] | |
Dijeljenje i dodjela | a /= b
|
a = a / b
|
Da | Da | R& K::operator /=(S b);
|
R& operator /=(K& a, S b);
|
[17] | |
Moduo i dodjela | a %= b
|
a = a % b
|
Da | Da | R& K::operator %=(S b);
|
R& operator %=(K& a, S b);
|
[17] | |
Konjunkcija nad bitovima i dodjela | a &= b a and_eq b
|
a = a & b
|
Da | Da | R& K::operator &=(S b);
|
R& operator &=(K& a, S b);
|
[17] | |
Disjunkcija nad bitovima i dodjela | a |= b a or_eq b
|
a = a | b
|
Da | Da | R& K::operator |=(S b);
|
R& operator |=(K& a, S b);
|
[17] | |
Isključiva disjunkcija nad bitovima i dodjela | a ^= b a xor_eq b
|
a = a ^ b
|
Da | Da | R& K::operator ^=(S b);
|
R& operator ^=(K& a, S b);
|
[17] | |
Pomjeranje bitova ulijevo i dodjela | a <<= b
|
a = a << b
|
Da | Da | R& K::operator <<=(S b);
|
R& operator <<=(K& a, S b);
|
[17] | |
Pomjeranje bitova udesno i dodjela | a >>= b
|
a = a >> b
|
Da | Da | R& K::operator >>=(S b);
|
R& operator >>=(K& a, S b);
|
[17] |
Operatori članova i pokazivača[uredi | uredi izvor]
Naziv operatora | Sintaksa | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | ||||||
Indeksiranje | a[b]
|
Da | Da | R& K::operator [](S b); |
N/D | [18] | |
Dereferenciranje („objekat na koji pokazuje a”) | *a |
Da | Da | R& K::operator *();
|
R& operator *(K a);
|
[19] | |
Adresiranje („adresa od a”) | &a |
Da | Da | R* K::operator &();
|
R* operator &(K a);
|
[20] | |
Strukturno dereferenciranje („član b objekta na koji pokazuje a”) | a->b |
Da | Da | R* K::operator ->();
|
N/D | [21] | |
Strukturno pokazivanje („član b objekta a”) | a.b |
Ne | Da | N/D | [21] | ||
Član izabran pokazivačem člana b objekta na koji pokazuje a | a->*b |
Da | Ne | R& K::operator ->*(S b);
|
R& operator ->*(K a, S b);
|
[22] | |
Član objekta a izabran pokazivačem člana b | a.*b |
Ne | Ne | N/D | [22] |
Ostali operatori[uredi | uredi izvor]
Naziv operatora | Sintaksa | Može biti preklopljen u C++ | Uključeno u C |
Primjeri C++ prototipa | Ref. | ||
---|---|---|---|---|---|---|---|
Kao član klase K | Definicije izvan klase | ||||||
Poziv funkcije | a(a1, a2)
|
Da | Da | R K::operator ()(S a, T b, ...);
|
N/D | [23] | |
Zarez | a, b |
Da | Da | R K::operator ,(S b);
|
R operator ,(K a, S b);
|
[24] | |
Ternarni operator | a ? b : c |
Ne | Da | N/D | [25] | ||
Rezolucija dosega | a::b |
Ne | Ne | N/D | [26] | ||
Korisnički definisani literali od C++11 |
"a"_b |
Da | Ne | N/D | R operator "" _b(T a)
|
[27] | |
Sizeof | sizeof(a) sizeof(type) |
Ne | Da | N/D | [28] | ||
veličina generičkog parametra od C++11 |
sizeof...(Args) |
Ne | Ne | N/D | [29] | ||
Alignof od C++11 |
alignof(type) or _Alignof(type) |
Ne | Da | N/D | [30] | ||
Identifikacija tipa | typeid(a) typeid(type) |
Ne | Ne | N/D | [31] | ||
Konverzija tipa (konverzija u C-stilu) | (type)a |
Ne | Da | N/D | [32] | ||
Konverzija tipa | type(a) |
Ne | Ne | Napomena: ponaša se kao const_cast/static_cast/reinterpret_cast[33] | [34] | ||
static_cast konverzija | static_cast<type>(a) |
Da | Ne | K::operator R(); explicit K::operator R(); since C++11
|
N/D | [35] | |
Napomena: za korisnički definisane konverzije, povratna vrijednost se implicitno i obavezno podudara sa nazivom operatora. | |||||||
dynamic cast konverzija | dynamic_cast<type>(a) |
Ne | Ne | N/D | [36] | ||
const_cast konverzija | const_cast<type>(a) |
Ne | Ne | N/D | [37] | ||
reinterpret_cast konverzija | reinterpret_cast<type>(a) |
Ne | Ne | N/D | [38] | ||
Alokacija memorije | new type |
Da | Ne | void* K::operator new(size_t x);
|
void* operator new(size_t x);
|
[39] | |
Alokacija memorije (niz) | new type[n] |
Da | Ne | void* K::operator new[](size_t a);
|
void* operator new[](size_t a);
|
[39] | |
Oslobađanje memorije | delete a |
Da | Ne | void K::operator delete(void *a);
|
void operator delete(void *a);
|
[40] | |
Oslobađanje memorije (niz) | delete[] a |
Da | Ne | void K::operator delete[](void *a);
|
void operator delete[](void *a);
|
[40] | |
Provjera izuzetaka od C++11 |
noexcept(a) |
Ne | Ne | N/D | [41] |
Redoslijed operacija[uredi | uredi izvor]
U tabeli ispod prikazani su redoslijed i asocijativnost svih operatora u programskim jezicima C i C++ (kada operator postoji i u programskim jezicima Java, Perl, PHP i mnogim drugim novijim programskim jezicima, redoslijed izvršavanja je isti kao što je navedeno). Redoslijed operatora je naveden tako što su na vrhu operatori koji se prvi izvršavaju. Grupa operatora koja je napisana u određenom redu će se izvršiti prije operatora koji su navedeni u redovima ispod. Operatori koji su navedeni u istoj ćeliji (može biti više redova operatora napisanih u istoj ćeliji) imaju jednak prioritet u izvršavanju. Redoslijed izvršavanja operatora je nezavisan od preklapanja.
Redoslijed | Operator | Opis | Asocijativnost |
---|---|---|---|
1
najviši |
::
|
Rezolucija dosega (samo u C++) | nema |
2 | ++
|
Postfiksni inkrement | slijeva nadesno |
--
|
Postfiksni dekrement | ||
()
|
Poziv funkcije | ||
[]
|
Indeksiranje niza | ||
.
|
Selekcija elementa referencom | ||
->
|
Selekcija elementa pokazivačem | ||
typeid()
|
Informacije o tipu za vrijeme izvršavanja (samo C++) | ||
const_cast
|
Konverzija tipa (samo u C++) | ||
dynamic_cast
|
Konverzija tipa (samo u C++) | ||
reinterpret_cast
|
Konverzija tipa (samo u C++) | ||
static_cast
|
Konverzija tipa (samo u C++) | ||
3 | ++
|
Prefiksni inkrement | zdesna nalijevo |
--
|
Prefiksni dekrement | ||
+
|
Unarni plus | ||
-
|
Unarni minus | ||
!
|
Logička negacija | ||
~
|
Negacija nad bitovima | ||
(type)
|
Konverzija tipa | ||
*
|
Dereferenciranje | ||
&
|
Adresiranje | ||
sizeof
|
Sizeof | ||
_Alignof
|
Alignof (od C11) | ||
new , new[]
|
Dinamička alokacija memorije (samo u C++) | ||
delete , delete[]
|
Dinamičko oslobađanje memorije (samo u C++) | ||
4 | .*
|
Pokazivač na član (samo u C++) | slijeva nadesno |
->*
|
Pokazivač na član (samo u C++) | ||
5 | *
|
Množenje | slijeva nadesno |
/
|
Dijeljenje | ||
%
|
Moduo (ostatak) | ||
6 | +
|
Sabiranje | slijeva nadesno |
-
|
Oduzimanje | ||
7 | <<
|
Pomjeranje ulijevo | slijeva nadesno |
>>
|
Pomjeranje udesno | ||
8 | <=>
|
Trostepeno poređenje (od C++20 — samo u C++) | slijeva nadesno |
9 | <
|
Manje od | slijeva nadesno |
<=
|
Manje ili jednako od | ||
>
|
Veće od | ||
>=
|
Veće ili jednako od | ||
10 | ==
|
Jednakost | slijeva nadesno |
!=
|
Nejednakost | ||
11 | &
|
Konjunkcija nad bitovima | slijeva nadesno |
12 | ^
|
Isključiva disjunkcija nad bitovima | slijeva nadesno |
14 | |
|
Disjunkcija nad bitovima | slijeva nadesno |
14 | &&
|
Logička konjunkcija | slijeva nadesno |
15 | ||
|
Logička disjunkcija | slijeva nadesno |
16 | ?:
|
Ternarni operator | zdesna nalijevo |
=
|
Direktna dodjela | ||
+=
|
Sabiranje i dodjela | ||
-=
|
Oduzimanje i dodjela | ||
*=
|
Množenje i dodjela | ||
/=
|
Dijeljenje i dodjela | ||
%=
|
Moduo i dodjela | ||
<<=
|
Pomjeranje bitova ulijevo i dodjela | ||
>>=
|
Pomjeranje bitova udesno i dodjela | ||
&=
|
Konjunkcija nad bitovima i dodjela | ||
^=
|
Disjunkcija nad bitovima i dodjela | ||
|=
|
Negacija nad bitovima i dodjela | ||
throw
|
Operator throw (bacanje izuzetaka, samo u C++) | ||
17
najniži |
,
|
Zarez | slijeva nadesno |
Napomene[uredi | uredi izvor]
Tabela redoslijeda operacija određuje redoslijed vezanja u lančanim izrazima, kada zagrade nisu izričito određene.
- Na primjer, izraz
++x*3
je dvosmislen bez nekih pravila vezanih za redoslijed. Tabela redoslijeda operacija nam kaže: x je čvršće 'vezano' za ++ nego za *, tako da šta god ++ radi, ono to radi samo promjenjivoj x (a ne čitavom izrazux*3
); ovo je ekvivalentno (++x
,x*3
). - Slično tome, u izrazu
3*x++
, gdje, iako je operator ++ dizajniran da djeluje nakon što je čitav izraz izračunat, tabela redoslijeda operacija daje do znanja da samo x biva inkrementovano (a ne cijeli izraz3*x
). Ovo se može zapisati uz korišćenje pomoćne promjenjive tmp kao (tmp=x++
,3*tmp
), što je funkcionalno ekvivalentno izrazima (tmp=3*x
,++x
,tmp
).
- Za apstrahovanje pitanja redoslijeda ili vezivanja, razmotrimo dijagram iznad koji se tiče izraza 3+2*y[i]++. Posao kompajlera je da rastavi dijagram u izraz u kojem će nekoliko unarnih operacija (nazovimo ih 3+( . ), 2*( . ), ( . )++ i ( . )[ i ]) da se takmiče koja će se vezati za y. Tabela redoslijeda operacija nam kaže da se ovaj izraz rastavlja na sljedeće: ( . )[ i ] se vezuje direktno na y, ( . )++ se vezuje na y[i], 2*( . ) se vezuje na y[i]++, a 3+( . ) se vezuje za čitav izraz 2*((y[i])++).
Mnogim operatorima koji sadrže niz više karaktera dodijeljena su „imena” sastavljena od imena operatora svakog karaktera. Na primjer, +=
i -=
često se zovu plus jednako i minus jednako, umjesto „dodjela sabiranjem” i „dodjela oduzimanjem”.
Vezivanje operatora u C i C++ je specificirano nekom gramatikom jezika, a ne redoslijedom izvršavanja. Ovo stvara neke blage konflikte. Na primjer, u programskom jeziku C, sintaksa za kondicionalni izraz je:
logical-OR-expression ? expression : conditional-expression
dok u C++ to izgleda ovako:
logical-OR-expression ? expression : assignment-expression
Zbog toga se izraz:
e = a < d ? a++ : a = d
parsira različito u ova dva jezika. U C, ovaj izraz bi „bacio” sintaksnu grešku, jer bi sintaksa za ovaj izraz u C bila:
unary-expression '=' assignment-expression
U C++ se parsira kao:
e = (a < d ? a++ : (a = d))
što je validan izraz.[45]
Kritika redoslijeda operatora jednakosti i logičkih operatora nad bitovima[uredi | uredi izvor]
Kritikovan je redoslijed izvršavanja logičkih operacija nad bitovima.[46] Konceptualno, & i | su aritmetičke operacije poput * i +.
Izraz a & b == 7
je sintaksno parsiran kao a & (b == 7)
gdje je izraz a + b == 7
parsiran kao (a + b) == 7
. Ovo zahtijeva češću upotrebu zagrada nego što je to obično slučaj.
Istorijski, nije postojala sintaksna razlika između operatora nad bitovima i logičkih operatora. U ranom programskom jeziku C, BCPL-u i programskom jeziku B, operatori && ||
nisu postojali. Umjesto toga, operatori & |
su imali drugačije značenje u zavisnosti od toga da li se koriste u kontekstu istinite vrijednosti (npr. kada se očekuje vrijednost Bulovog tipa, kao u izrazu if (a==b & c) {...}
on se ponaša kao logički operator, ali u c = a & b
se ponaša kao operator nad bitovima). Zadržan je tako da zadrži povratnu kompatibilnost s postojećim instalacijama.[47]
Pored toga, u C++ (i kasnijim verzijama C) operatori jednakosti, za izuzetkom operatora trostepenog poređenja, daju vrijednosti Bulovog tipa koje su konceptualno jedan bit (1 ili 0) i kao takvi ne pripadaju operacijama nad bitovima.
Sinonimi operatora u C++[uredi | uredi izvor]
C++ definiše[48] određene ključne riječi koje se ponašaju kao alijasi za brojne operacije:
Ključna riječ | Operator |
---|---|
and |
&&
|
and_eq |
&=
|
bitand |
&
|
bitor |
|
|
compl |
~
|
not |
!
|
not_eq |
!=
|
or |
||
|
or_eq |
|=
|
xor |
^
|
xor_eq |
^=
|
Oni se mogu koristiti na isti način poput interpunkcijskih znakova koje zamjenjuju, kako nisu isti operator pod različitim imenom, nego jednostavne zamjene tokena za ime (niz karaktera) odgovarajućeg operatora. Ovo znači da izrazi (a > 0 and not flag)
i (a > 0 && !flag)
imaju isto značenje. To takođe znači da, na primjer, ključna riječ bitand
može da se koristi ne samo prilikom zamjene bitwise-and operatora, nego i za operator adresiranja, a takođe može da se koristi za određivanje referentnih tipova (npr. int bitand ref = n
). Specifikacija ISO C dozvoljava ove ključne riječi u pretprocesorskim makroima u datoteci zaglavlja iso646.h
. Radi kompatibilnosti sa programskim jezikom C, C++ sadrži datoteku zaglavlja ciso646
, čije uključivanje nema efekta.
Vidi još[uredi | uredi izvor]
Reference[uredi | uredi izvor]
- ^ „The Anatomy of the Assignment Operator”. icu-project.org. Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Additive Operators: + and -”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Unary Plus and Negation Operators: + and -”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b v „Operators - C++ Tutorials”. www.cplusplus.com. Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Prefix Increment and Decrement Operators: ++ and --”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Postfix Increment and Decrement Operators: ++ and --”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b v g d đ e „Comparison operators - cppreference.com”. en.cppreference.com. Pristupljeno 31. 10. 2019.
- ^ „Mathematics behind Comparison #4: Three-Way Comparison”. foonathan.net (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Logical Negation Operator: !”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Logical AND Operator: &&”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Logical OR operator:”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „One's Complement Operator: ~”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Bitwise AND Operator: &”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Bitwise inclusive OR operator:”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Bitwise Exclusive OR Operator: ^”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Left Shift and Right Shift Operators (>> and”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b v g d đ e ž z i „IBM Knowledge Center”. www.ibm.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Subscript Operator []”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Indirection Operator: *”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Address-of Operator: &”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Member Access Operators: . and ->”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „Pointer-to-Member Operators: .* and ->*”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Function Call Operator: ()”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Comma Operator: ,”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Conditional Operator: ? :”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Scope Resolution Operator: ::”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ „User-defined literals (since C++11) - cppreference.com”. en.cppreference.com. Pristupljeno 31. 10. 2019.
- ^ mikeblome. „sizeof Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ „Parameter pack(since C++11) - cppreference.com”. en.cppreference.com. Pristupljeno 31. 10. 2019.
- ^ mikeblome. „__alignof Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „typeid Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Cast Operator: ()”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ „Explicit type conversion - cppreference.com”. en.cppreference.com. Pristupljeno 31. 10. 2019.
- ^ mikeblome. „Explicit Type Conversion Operator: ()”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „static_cast Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „dynamic_cast Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „const_cast Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „reinterpret_cast Operator”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „new Operator (C++)”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ a b mikeblome. „delete Operator (C++)”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ mikeblome. „noexcept (C++)”. docs.microsoft.com (na jeziku: engleski). Pristupljeno 31. 10. 2019.
- ^ „C Operator Precedence - cppreference.com”. en.cppreference.com. Pristupljeno 16. 7. 2019.
- ^ „Visual Studio 2005 Retired documentation”. Microsoft Download Center. Pristupljeno 23. 3. 2018.
- ^ „C++ Operator Precedence - cppreference.com”. en.cppreference.com. Pristupljeno 16. 7. 2019.
- ^ „Does the C/C++ ternary operator actually have the same precedence as assignment operators?”. Stack Overflow. Pristupljeno 22. 9. 2019.
- ^ C history § Neonatal C, Bell labs.
- ^ „Re^10: next unless condition”. www.perlmonks.org. Pristupljeno 5. 11. 2019.
- ^ ISO/IEC 14882:1998(E) Programming Language C++. www.open-std.org — The C++ Standards Committee. 1. 9. 1998. str. 40—41.
Spoljašnje veze[uredi | uredi izvor]
- „Operators”, C++ reference (wiki).
- C Operator Precedence
- Postfix Increment and Decrement Operators: ++ and -- (Developer network), Microsoft.