Dichiarazioni

Dichiarazioni di variabili

int var = 0, var2 = 10;
object@ handle, handle2;
const float pi = 3.141592f;

Le variabili devono essere dichiarate prima di essere utilizzate all'interno del blocco di istruzioni o di qualsiasi sottoblocco. Quando il codice esce dal blocco di istruzioni in cui è stata dichiarata, la variabile non è più valida.

Una variabile può essere dichiarata con o senza espressione iniziale. Se viene dichiarata con un'espressione iniziale, l'espressione deve avere la valutazione di un tipo compatibile con il tipo di variabile.

È possibile dichiarare un numero qualsiasi di variabili sulla stessa riga, separate da virgole, dove tutte le variabili avranno lo stesso tipo.

Le variabili possono essere dichiarate come const. In questo caso, il valore della variabile non può essere modificato dopo l'inizializzazione.

Le variabili di tipo primitivo dichiarate senza valore iniziale avranno un valore casuale. Le variabili di tipi complessi, come gli handle e gli oggetti, sono inizializzate con un valore predefinito. Per gli handle è null, per gli oggetti è quello definito dal costruttore predefinito dell'oggetto.

Dichiarazione di espressione

a = b; // a variable assignment
func(); // a function call

Qualsiasi espressione può essere inserita da sola in una riga come dichiarazione. Di solito viene utilizzata per l'assegnazione di variabili o per le chiamate a funzioni che non restituiscono alcun valore importante.

Tutte le espressioni devono terminare con un ;.

Condizioni: if / if-else / switch-case

if (condition)
{
  // Do something if condition is true
}
if (value < 10)
{
  // Do something if value is less than 10
}
else
{
  // Do something else if value is greater than or equal to 10
}

Le istruzioni If vengono utilizzate per decidere se eseguire o meno una parte della logica in base a una determinata condizione. L'espressione condizionale deve sempre essere valutata come vera o falsa.

È possibile concatenare più istruzioni if-else, nel qual caso ogni condizione sarà valutata in sequenza finché una non risulterà vera.

switch (value)
{
  case 0:
    // Do something if value equals 0, then leave
    break;
  case 2:
  case constant_value:
    // This will be executed if value equals 2 or the constant_value
    break;
  default:
    // This will be executed if value doesn't equal any of the cases
}

Se si dispone di un'espressione intera (con o senza segno) che ha molti risultati diversi che dovrebbero portare a codice diverso, un caso switch è spesso la scelta migliore per implementare la condizione. È molto più veloce di una serie di if, soprattutto se i valori dei casi sono tutti vicini.

Ogni caso deve essere terminato con un'istruzione break, a meno che non si voglia che il codice continui con il caso successivo.

Il valore del caso può essere una variabile costante inizializzata con un'espressione costante. Se la variabile costante è stata inizializzata con un'espressione che non può essere determinata in fase di compilazione, non può essere utilizzata nei valori dei casi.

Cicli: while / do-while / for

// Loop, where the condition is checked before the logic is executed
int i = 0;
while (i < 10)
{
  // Do something
  i++;
}
// Loop, where the logic is executed before the condition is checked
int j = 0;
do
{
  // Do something
  j++;
} while (j < 10);

Sia per il while che per il do-while, l'espressione che determina se il ciclo deve continuare deve essere valutata o vera o falsa. Se la valutazione è true, il ciclo continua, altrimenti si ferma e il codice continua con l'istruzione successiva al ciclo.

// More compact loop, where condition is checked before the logic is executed
for (int n = 0; n < 10; n++)
{
// Do something
}

Il ciclo for è una forma più compatta di un ciclo while. La prima parte dell'istruzione (fino al primo ;) viene eseguita una sola volta, prima dell'avvio del ciclo. Qui è possibile dichiarare una variabile che sarà visibile solo all'interno dell'istruzione del ciclo. La seconda parte è la condizione che deve essere soddisfatta affinché il ciclo venga eseguito. Un'espressione vuota in questo caso sarà sempre valutata come vera. L'ultima parte viene eseguita dopo la logica del ciclo, ad esempio per incrementare una variabile di iterazione.

Nel ciclo for si possono dichiarare più variabili, separate da ,. Allo stesso modo, si possono usare espressioni di incremento multiple nell'ultima parte, separandole con ,.

Controllo cicli: break / continue

for (;;) // endless loop
{
  // Do something
  // End the loop when condition is true
  if (condition)
      break;
}

L'interruzione termina l'istruzione di loop o di switch più piccola.

for (int n = 0; n < 10; n++ )
{
  if (n == 5)
    continue;
  // Do something for all values from 0 to 9, except for the value 5
}

continue salta all'iterazione successiva dell'istruzione di ciclo più piccola.

Dichiarazione di ritorno

float valueOfPI()
{
return 3.141592f; // return a value
}

Qualsiasi funzione con un tipo di ritorno diverso da void deve essere terminata con una dichiarazione di ritorno in cui l'espressione valuti lo stesso tipo di dati del tipo di ritorno della funzione. Le funzioni dichiarate come void possono avere dichiarazioni di ritorno senza alcuna espressione per terminare in anticipo.

Blocchi di dichiarazioni

{
  int a;
  float b;
  {
    float a; // Override the declaration of the outer variable
             // but only within the scope of this block.
    // variables from outer blocks are still visible
    b = a;
  }
  // a now refers to the integer variable again
}

Un blocco di istruzioni è un insieme di istruzioni. Ogni blocco di istruzioni ha il proprio ambito di visibilità, quindi le variabili dichiarate all'interno di un blocco di istruzioni non sono visibili al di fuori del blocco.

Blocchi try-catch

{
  try
  {
    DoSomethingThatMightThrowException();
    // This is not executed if an exception was thrown
  }
  catch
  {
    // This is executed if an exception was thrown
  }
}

Un blocco try-catch può essere usato se si sta eseguendo del codice che potrebbe lanciare un'eccezione e si vuole catturare l'eccezione e continuare con l'eccezione piuttosto che interrompere lo script.

Le eccezioni possono verificarsi per vari motivi; alcuni esempi sono l'accesso a puntatori nulli in handle non inizializzati, la divisione per zero o le eccezioni sollevate da funzioni registrate dall'applicazione. In alcuni casi, le eccezioni vengono sollevate intenzionalmente dallo script per interrompere l'esecuzione.

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.