Espressioni

Assegnazioni

lvalue = rvalue;

lvalue deve essere un'espressione che valuta una posizione di memoria in cui il valore dell'espressione può essere memorizzato, ad esempio una variabile. Un'assegnazione valuta lo stesso valore e lo stesso tipo di dati memorizzati. L'espressione di destra viene sempre calcolata prima di quella di sinistra.

Chiamate a funzione

func();
func(arg);
func(arg1, arg2);
lvalue = func();

Le funzioni vengono chiamate per eseguire un'azione ed eventualmente restituire un valore che può essere utilizzato in altre operazioni. Se una funzione accetta più di un argomento, le espressioni degli argomenti vengono valutate in ordine inverso, cioè l'ultimo argomento viene valutato per primo.

Alcune funzioni sono dichiarate con parametri di riferimento in uscita per restituire più valori. Quando si chiamano tali funzioni, il parametro di uscita deve essere fornito come espressione che può essere assegnata al valore restituito. Se il valore di uscita aggiuntivo non verrà utilizzato, utilizzare l'argomento speciale "void" per indicare al compilatore questa possibilità.

// This function returns a value in the output parameter
void func(int &out outputValue)
{
outputValue = 42;
}
// Call the function with a valid lvalue expression to receive the output value
int value;
func(value);
// Call the function with 'void' argument to ignore the output value
func(void);

Gli argomenti possono anche essere denominati e passati a un argomento specifico, indipendentemente dall'ordine in cui i parametri sono stati dichiarati. Nessun argomento posizionale può seguire un argomento nominato.

void func(int flagA = false, int flagB = false, int flagC = false) {}
// Call the function, setting only a subset of its parameters
func(flagC: true);
func(flagB: true, flagA: true);

Operatori matematici

c = -(a + b);

operatore	descrizione	mano sinistra	mano destra	risultato
+	unario positivo		NUM	NUM
-	unario negativo		NUM	NUM
+	addizione	NUM	NUM	NUM
-	sottrazione	NUM	NUM	NUM
*	moltiplicazione	NUM	NUM	NUM
/	divisione	NUM	NUM	NUM
%	moduli	NUM	NUM	NUM
**	esponente	NUM	NUM	NUM

Il più e il meno possono essere utilizzati anche come operatori unari. NUM può essere scambiato con qualsiasi tipo numerico, ad esempioint o float. Entrambi i termini delle operazioni doppie vengono convertiti implicitamente nello stesso tipo. Il risultato è sempre dello stesso tipo dei termini originali. Un'eccezione è rappresentata dal negativo unario, che non è disponibile per uint.

Operatori a bit

c = ~(a | b);

operatore	descrizione	mano sinistra	mano destra	risultato
~	complemento bitwise		NUM	NUM
&	in modo bitwise e	NUM	NUM	NUM
\|	bitwise o	NUM	NUM	NUM
^	xor bitwise	NUM	NUM	NUM
<<	spostamento a sinistra	NUM	NUM	NUM
>>	spostamento a destra	NUM	NUM	NUM
>>>	spostamento aritmetico a destra	NUM	NUM	NUM

Tutti, tranne ~, sono operatori doppi.

Entrambi gli operandi vengono convertiti in numeri interi mantenendo il segno del tipo originale prima dell'operazione. Il tipo risultante sarà lo stesso dell'operando di sinistra.

Assegnazione composta

lvalue += rvalue;
lvalue = lvalue + rvalue;

Un assegnamento composto è una combinazione di un operatore seguito da un assegnamento. Le due espressioni qui sopra significano praticamente la stessa cosa. Solo che la prima è più efficiente in quanto il valore l viene valutato una sola volta, il che può fare la differenza se il valore l è di per sé un'espressione complessa.

Operatori disponibili: += -= *= /= %= **= &= |= ^= <<= >>= >>>=

Operatori logici

if (a and b or not c)
{
// ... do something
}

operatore	descrizione	mano sinistra	mano destra	risultato
not	logico non		bool	bool
and	logico e	bool	bool	bool
or	logico o	bool	bool	bool
xor	logico esclusivo o	bool	bool	bool

Gli operatori booleani valutano solo i termini necessari. Ad esempio, nell'espressione a e b, b viene valutato solo se a è vero.

Ciascun operatore logico può essere scritto anche come simbolo, ad esempio || per or, && per and, ^^ per xor e ! per not.

Operatori di confronto di uguaglianza

if (a == b)
{
// ... do something
}

Gli operatori == e != vengono utilizzati per confrontare due valori e determinare se sono rispettivamente uguali o non uguali. Il risultato di questa operazione è sempre un valore booleano.

Operatori di confronto relazionale

if (a > b)
{
// ... do something
}

Gli operatori <, >, <= e >= vengono utilizzati per confrontare due valori e determinarne la relazione. Il risultato è sempre un valore booleano.

Operatori di confronto identità

if (a is null)
{
// ... do something
}
else if (a is b)
{
// ... do something
}

Gli operatori is e !is vengono utilizzati per confrontare l'identità di due oggetti, ossia per determinare se i due oggetti sono uguali o meno. Questi operatori sono validi solo per i tipi di riferimento, poiché confrontano l'indirizzo di due oggetti. Il risultato è sempre un valore booleano.

Operatori di incremento

// The following means a = i; i = i + 1;
a = i++;
// The following means i = i - 1; b = i;
b = --i;

Questi operatori possono essere anteposti o posposti a un valore l per incrementare/decrementare il suo valore prima o dopo l'utilizzo nell'espressione. Il valore viene sempre incrementato o decrementato con 1.

Operatori di indicizzazione

arr[i] = 1;

Questo operatore viene utilizzato per accedere a un elemento contenuto nell'oggetto. A seconda del tipo di oggetto, l'espressione tra i [] deve essere di tipo diverso.

Espressioni condizionali

choose ? a : b;

Se il valore di choose è vero, l'espressione restituisce a altrimenti restituisce b.

Sia a che b devono essere dello stesso tipo. Se non lo sono, il compilatore tenterà una conversione implicita seguendo il principio del minor costo, cioè l'espressione che verrà convertita è quella che costa meno da convertire. Questo costo viene determinato nello stesso modo in cui viene fatto per la corrispondenza degli argomenti nelle chiamate di funzione.

Se la conversione non funziona o se la conversione di entrambe le espressioni ha lo stesso costo, il compilatore darà un errore.

L'espressione condizionale può essere utilizzata come valore l, cioè come valore a sinistra di un'espressione di assegnazione, se sia a che b sono valori l dello stesso tipo.

int a, b;
(expr ? a : b) = 42;

Accesso ai membri

object.property = 1;
object.method();

L'oggetto deve essere un'espressione che dà come risultato un tipo di dati che ha dei membri. property è il nome di una variabile membro che può essere letta/impostata direttamente. method è il nome di un metodo membro che può essere richiamato sull'oggetto.

Handle-of

// Make handle reference the object instance
@handle = @object;
// Clear the handle and release the object it references
@handle = null;

Gli handle degli oggetti sono riferimenti a un oggetto. Più di un handle può fare riferimento allo stesso oggetto e solo quando non ci sono più handle che fanno riferimento a un oggetto, l'oggetto viene distrutto.

Si accede ai membri dell'oggetto a cui l'handle fa riferimento nello stesso modo in cui si accede direttamente alla variabile dell'oggetto, cioè con l'operatore .

Parentesi

a = c * (a + b);
if ((a or b) and c)
{
// ... do something
}

Le parentesi vengono utilizzate per raggruppare le espressioni quando la precedenza degli operatori non fornisce l'ordine di valutazione desiderato.

Risoluzione ambito

int value;
void function()
{
int value; // local variable overloads the global variable
::value = value; // use scope resolution operator to refer to the global variable
}

L'operatore di risoluzione dell'ambito :: può essere utilizzato per accedere a variabili o funzioni da un altro ambito quando il nome è sovraccaricato da una variabile o funzione locale. Scrivete il nome dell'ambito a sinistra (o vuoto per l'ambito globale) e il nome della variabile/funzione a destra.

Conversioni di tipo

// implicitly convert the clss handle to a intf handle
intf @a = @clss();
// explicitly convert the intf handle to a clss handle
clss @b = cast<clss>(a);

Gli handle degli oggetti possono essere convertiti in altri handle di oggetti con l'operatore cast. Se il cast è valido, cioè l'oggetto vero implementa la classe o l'interfaccia richiesta, l'operatore restituisce un handle valido. Se il cast non è valido, restituisce un handle nullo.

Questo metodo è chiamato cast di riferimento e funziona solo per i tipi che supportano gli handle degli oggetti. In questo caso, l'handle fa ancora riferimento allo stesso oggetto, ma è solo esposto attraverso un'interfaccia diversa.

I tipi che non supportano gli handle degli oggetti possono essere convertiti con un cast di valore. In questo caso viene costruito un nuovo valore o, nel caso degli oggetti, viene creata una nuova istanza dell'oggetto.

// implicit value cast
int a = 1.0f;
// explicit value cast
float b = float(a)/2;

Nella maggior parte dei casi, tuttavia, un cast esplicito non è necessario per i tipi primitivi, poiché il compilatore è solitamente in grado di eseguire un cast implicito al tipo corretto.

Oggetti anonimi

Gli oggetti anonimi, cioè creati senza essere dichiarati come variabili, possono essere istanziati nelle espressioni invocando il costruttore dell'oggetto come se fosse una funzione. Sia i tipi di riferimento che i tipi di valore possono essere creati in questo modo.

// Call the function with a new object of the type MyClass
func(MyClass(1,2,3));

Per i tipi che lo supportano, gli oggetti anonimi possono anche essere inizializzati con liste di inizializzazione.

// Call the function with a dictionary, explicitly informing the type of the initialization list
func(dictionary = {{'banana',1}, {'apple',2}, {'orange',3}});
// When there is only one possible type that support initialization lists it is possible
// to omit the type and let the compiler implicitly determine it based on the use
funcExpectsAnArrayOfInts({1,2,3,4});

This Info:	ALT+q
Page Header:	ALT+h
Topic Header:	ALT+t
Topic Body:	ALT+b
Contents:	ALT+c
Search:	ALT+s
Exit Menu/Up:	ESC

Abilitare JavaScript per vedere questo sito.