Operatori in C e C++: differenze tra le versioni

Da Wikipedia, l'enciclopedia libera.
Vai alla navigazione Vai alla ricerca
Naviga nella cronologia in modo interattivo
← Differenza precedenteDifferenza successiva →
Contenuto cancellato Contenuto aggiunto
VisualeWikitesto
Riga 265: Riga 265:


=== Operatori membro e puntatore ===
=== Operatori membro e puntatore ===
{| class="wikitable" style="width:100%"
{| class="wikitable"
|+
! colspan="2" rowspan="2" |Operator name
! rowspan="2" |Nome operatore<ref>{{Cita libro|autore=Andrea Domenici|autore2=Graziano Frosini|titolo=Introduzione alla programmazione ed elementi di strutture dati con il linguaggio [[C++]]|edizione=VIII edizione|collana="Informatica", diretta da A. L. Frisiani|città=[[Milano]]/[[Pisa]]|ISBN=978-8846462022}}</ref>
! rowspan="2" |Syntax
! rowspan="2" |Can overload in C++
! rowspan="2" |Sintassi
! rowspan="2" |Included<br /><br />in [[C (linguaggio di programmazione)|C]]
! rowspan="2" |Ammette overload (sovraccarico) in C++
! colspan="2" |C++ prototype examples
! rowspan="2" |Implementabile in C
! colspan="2" |Esempi di implementazione in C++
|-
|-
!Come membro della classe K
!As member of K
!Fuori dalla classe
!Outside class definitions
|-
|-
!Indicizzazione
| class="table-rh" colspan="2" {{rh}} width="23%" |[[Indexer (programming)|Subscript]]
| align="center" width="11%" |<code>a'''['''b''']'''</code>
|<code>a'''['''b''']'''</code>
| width="8%" {{Sit}}
|{{Sit}}
| width="8%" {{Sit}}
|{{Sit}}
|{{cpp|R& K::operator [](S b);}}<br /><br />{{cpp|R& K::operator [](S b, ...); // since C++23}}<br /><br />
|<code>R& K::operator [](S b);</code>
<code>R& K::operator [](S b, ...); // since C++23</code>
| width="25%" {{ND}}
|{{ND}}
|-
|-
!Deferenziazione
| class="table-rh" colspan="2" {{rh}} |Indirection ("object pointed to by ''a''")
| style="text-align:center;" |<code>'''*'''a</code>|| {{Sit}} || {{Sit}}
|<code>'''*'''a</code>
|{{Sit}}
⚫
|{{cpp|R& K::operator *();}}
|{{Sit}}
⚫
|{{cpp|R& operator *(K a);}}
⚫
|R& K::'''operator''' *();
⚫
|R& '''operator''' *(K a);
|-
|-
!Indirizzo
| class="table-rh" colspan="2" {{rh}} |Address-of ("address of ''a''")
|<code>'''&'''a</code>
| style="text-align:center;" |<code>'''&'''a</code>|| {{Sit}}<ref name="addressof2" group="lower-alpha"/> || {{Sit}}
|{{Sit}}
⚫
|{{cpp|R* K::operator &();}}
|{{Sit}}
⚫
|{{cpp|R* operator &(K a);}}
⚫
|R* K::'''operator''' &();
⚫
|R* '''operator''' &(K a);
|-
|-
!Deferenziazione e selezione
| class="table-rh" colspan="2" {{rh}} |Structure dereference ("member ''b'' of object pointed to by ''a''")
| style="text-align:center;" |<code>a'''->'''b</code>|| {{Sit}} || {{Sit}}
|<code>a'''->'''b</code>
|{{Sit}}
⚫
|{{cpp|R* K::operator ->();}}<br /><br />
| {{ND}}
|{{Sit}}
⚫
|R* K::'''operator''' ->();
|{{ND}}
|-
|-
!Selezione (object.member)
| class="table-rh" colspan="2" {{rh}} |Structure reference ("member ''b'' of object ''a''")
| style="text-align:center;" |<code>a'''.'''b</code>|| {{Not}} || {{Sit}}
|<code>a'''.'''b</code>
| {{rh}} colspan="2" {{ND}}
|{{Not}}
|{{Sit}}
| colspan="2" |{{ND}}
|-
|-
!Deferenziazione e selezione con puntatore a membro
| class="table-rh" colspan="2" {{rh}} |Member selected by [[pointer-to-member]] ''b'' of object pointed to by ''a''<ref name="arrowstar" group="lower-alpha" />
| style="text-align:center;" |<code>a'''->*'''b</code>|| {{Sit}} || {{Not}}
|<code>a'''->*'''b</code>
|{{Sit}}
⚫
|{{cpp|R& K::operator ->*(S b);}}
|{{Not}}
⚫
|{{cpp|R& operator ->*(K a, S b);}}
⚫
|R& K::'''operator''' ->*(S b);
⚫
|R& '''operator''' ->*(K a, S b);
|-
|-
!Selezione con puntatore a membro
| class="table-rh" colspan="2" {{rh}} |Member of object ''a'' selected by [[pointer-to-member]] ''b''
| style="text-align:center;" |<code>a'''.*'''b</code>|| {{Not}} || {{Not}}
|<code>a'''.*'''b</code>
| {{rh}} colspan="2" {{ND}}
|{{Not}}
|{{Not}}
| colspan="2" |{{ND}}
|}
|}


<nowiki>
<nowiki>
[[Categoria:C++]]
[[Categoria:C++]]
[[Categoria:C]]</nowiki>
[[Categoria:C]]</nowiki>
<references group="lower-alpha" />

Versione delle 12:29, 30 ago 2024

Questa è una lista degli operatori nei linguaggi di programmazione C e C++. Tutti gli operatori elencati di seguito (eccetto typeof) esistono nel linguaggio C++, mentre in C solo quelli indicati nella colonna “Incluso in C”.

C++ include inoltre gli operatori type conversion (): const_cast, static_cast, dynamic_cast, e reinterpret_cast. La formattazione di questi operatori intende che il livello di precedenza è irrilevante.

Molti degli operatori disponibili in C e C++ sono implementabili anche in altri linguaggi della “C family”, quali C#, D, ma anche Java, Perl e PHP, con le medesime caratteristiche mostrate (precedenze, associatività e semantica).

Overloading degli operatori

C++ possiede molti operatori già predefiniti in grado di operare su vari tipi di dato, perciò si può parlare di “operatori già sovraccaricati”. Per esempio l’operatore + può essere implementato per sommare sia due variabili di tipo int (interi), sia due variabili di tipo float o double (variabili a virgola mobile).

Oltre a quando detto in precedenza, il programmatore può anche “estendere” l’operatività di ciascuno di essi; per esempio operandi complessi definiti con le classi, si potrebbero trattare anche come se fossero dati semplici.

In C++ è possibile sovraccaricare tutti gli operatori predifiniti, con l’eccezione su accesso al membro (.), indirezione di accesso al membro (.*) e risoluzione di ambito (::).

Nel caso degli operatori, il numero degli operandi e la priorità dell’operatore sovraccaricato sono le stesse dell’operatore predefinito, mentre il nuovo operatore può essere definito come una funzione membro oppure come una funzione friend (funzione amica).

Tabelle degli operatori

Nelle tabelle seguenti, a, b e c rappresentano valori validi qualsiasi (literals, valori da variabili, oppure return value) o, in alcuni casi specifici, nomi di oggetti o lvalues. R, S e T indicano qualsiasi tipo, mentre K indica un tipo di classe o un tipo enum.

Operatori aritmetici

Tutti gli operatori aritmetici esistono sia in C e C++ e possono essere, come già indicato, sovraccaricati solo in C++.

Nome operatore Sintassi Esempi di implementazione in C++
Come membro della classe K Fuori dalla classe
Addizione a+b R K::operator +(S b); R operator +(K a, S b);
Sottrazione a-b R K::operator -(S b); R operator -(K a, S b);
Unario più +a R K::operator +(); R operator +(K a);
Unario meno -a R K::operator -(); R operator -(K a);
Moltiplicazione a * b R K::operator *(S b); R operator *(K a, S b);
Divisione a / b R K::operator /(S b); R operator /(K a, S b);
Modulo a % b R K::operator %(S b); R operator %(K a, S b);
Incremento Prefisso ++a R& K::operator ++(); R& operator ++(K& a);
Postfisso a++ R K::operator ++(int); R operator ++(K& a, int);
Il C++ utilizza il parametro fittizio senza nome int per differenziare gli operatori di incremento prefisso e postfisso.
Decremento Prefisso --a R& K::operator --(); R& operator --(K& a);
Postfisso a-- R K::operator --(int); R operator --(K& a, int);
Il C++ utilizza il parametro fittizio senza nome int per differenziare gli operatori di incremento prefisso e postfisso.

Operatori relazionali

Tutti gli operatori di confronto possono essere sovraccaricati solo in C++. Dal C++20, l'operatore di disuguaglianza viene generato automaticamente se viene definito operator== e tutti e quattro gli operatori relazionali vengono generati automaticamente se viene definito operator<=>.

Nome operatore Sintassi Incluso in C Esempi di implementazione in C++
Come membro della classe K Fuori dalla classe
Uguale a = b Sì bool K::operator ==(S const& b) const; bool operator ==(K const& a, S const& b);
Diverso a != b Sì bool K::operator !=(S const& b) const; bool operator !=(K const& a, S const& b);
Maggiore di a > b Sì bool K::operator >(S const& b) const; bool operator >(K const& a, S const& b);
Minore di a < b Sì bool K::operator <(S const& b) const; bool operator <(K const& a, S const& b);
Maggiore o uguale a a >= b Sì bool K::operator >=(S const& b) const; bool operator >=(K const& a, S const& b);
Minore o uguale a a <= b Sì bool K::operator <=(S const& b) const; bool operator <=(K const& a, S const& b);

Operatori logici (o booleani)

Tutti gli operatori logici (o booleani[1]) sono esistenti sia in C che in C++ e possono essere chiaramente sovraccaricati solo in quest'ultimo linguaggio di programmazione.

Nonostante la possibilità di sovraccarico in C++, tale operazione è sconsigliata con AND logico e OR logico sia sconsigliato perché, come operatori sovraccaricati, si comporterebbero come normali chiamate di funzione, il che significa che entrambi i loro operandi verrebbero valutati, perdendo di conseguenza la loro importante valutazione di McCarthy. [2]

Nome dell'operatore Sintassi Esempi di implementazione in C++
Come membro della classe K Fuori dalla classe
NOT logico ! a bool K::operator !(); bool operator !(K a);
AND logico a && b bool K::operator &&(S b); bool operator &&(K a, S b);
OR logico a || b bool K::operator ||(S b); bool operator ||(K a, S b);

Operatori bit a bit

Tutti gli operatori bit a bit (o di manipolazione dei bit) esistono sia C che C++ e possono essere sovraccaricati soltanto nel linguaggio inventato da Bjarne Stroustrup.

Nome dell'operatore Sintassi Esempi di implementazione in C++
Come membro della classe K Fuori dalla classe
Complemento a uno (inversione di tutti i bit) ~a R K::operator ~(); R operator ~(K a);
AND bit a bit a & b R K::operator &(S b); R operator &(K a, S b);
OR inclusivo bit a bit a | b R K::operator |(S b); R operator |(K a, S b);
OR esclusivo bit a bit (OR exclusive, XOR) a ^ b R K::operator ^(S b); R operator ^(K a, S b);
Spostamento di tutti i bit verso sinistra a << b R K::operator <<(S b); R operator <<(K a, S b);
Spostamento di tutti i bit verso destra a >> b R K::operator >>(S b); R operator >>(K a, S b);

Operatori ed espressioni di assegnamento

Tutti gli operatori e le espressioni di assegnamento sono esistenti sia in C che in C++ e possono essere chiaramente sovraccaricate solo in quest'ultimo linguaggio di programmazione.

Per gli operatori indicati, la semantica dell'espressione di assegnazione combinata incorporata a ⊚= b è equivalente a a = a ⊚ b, eccetto per il fatto che a viene valutata una sola volta.

Tipologia assegnamento Sintassi Esempi di implementazione in C++
Come membro della classe K Fuori dalla classe
Espressione semplice di assegnamento a = b R& K::operator =(S b); N.D.
Assegnamenti composti 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);

Operatori membro e puntatore

Nome operatore[3] Sintassi Ammette overload (sovraccarico) in C++ Implementabile in C Esempi di implementazione in C++
Come membro della classe K Fuori dalla classe
Indicizzazione a[b] Sì Sì R& K::operator [](S b);

R& K::operator [](S b, ...); // since C++23

N.D.
Deferenziazione *a Sì Sì R& K::operator *(); R& operator *(K a);
Indirizzo &a Sì Sì R* K::operator &(); R* operator &(K a);
Deferenziazione e selezione a->b Sì Sì R* K::operator ->(); N.D.
Selezione (object.member) a.b No Sì style="background: #ececec; color: #2C2C2C; vertical-align: middle; text-align: center; " class="table-na" | N.D.
Deferenziazione e selezione con puntatore a membro a->*b Sì No R& K::operator ->*(S b); R& operator ->*(K a, S b);
Selezione con puntatore a membro a.*b No No style="background: #ececec; color: #2C2C2C; vertical-align: middle; text-align: center; " class="table-na" | N.D.


[[Categoria:C++]] [[Categoria:C]]

  1. ^ L'accezione booleana è stata coniata in onore del matematico George Boole.
  2. ^ isocpp.org, https://isocpp.org/wiki/faq/operator-overloading.
  3. ^ Andrea Domenici e Graziano Frosini, Introduzione alla programmazione ed elementi di strutture dati con il linguaggio C++, collana "Informatica", diretta da A. L. Frisiani, VIII edizione, Milano/Pisa, ISBN 978-8846462022.
Estratto da "https://it.wikipedia.org/w/index.php?title=Operatori_in_C_e_C%2B%2B&oldid=140869050"