Tipi di dati

Si noti che l'applicazione host può aggiungere tipi specifici per tale applicazione; per ulteriori informazioni, consultare il manuale dell'applicazione.

Primitivi

void

void non è un vero e proprio tipo di dati, ma piuttosto una mancanza di tipo di dati. Può essere usato solo per indicare al compilatore che una funzione non restituisce alcun dato.

bool

bool è un tipo booleano con due soli valori possibili: true o false. Le parole chiave true e false sono costanti di tipo bool che possono essere utilizzate come tali nelle espressioni.

Numeri interi

Tipo	Valore minimo	Valore massimo
int8	-128	127
int16	-32,768	32,767
int	-2,147,483,648	2,147,483,647
int64	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
uint8	0	255
uint16	0	65,535
uint	0	4,294,967,295
uint64	0	18,446,744,073,709,551,615

Poiché il motore di scripting è stato ottimizzato per i tipi di dati a 32 bit, l'uso delle varianti più piccole è consigliato solo per accedere alle variabili specificate dall'applicazione. Per le variabili locali è meglio usare la variante a 32 bit.

int32 è un alias di int e uint32 è un alias di uint.

Numeri reali

Tipo	Range valori	valore positivo più piccolo	massimo digit
float	+/- 3.402823466e+38	1.175494351e-38	6
double	+/- 1.79769313486231e+308	2.22507385850720e-308	15

Nota: questi numeri presuppongono che la piattaforma utilizzi l'IEEE 754 per rappresentare i numeri in virgola mobile nella CPU.

Se si utilizza un numero di cifre superiore a quello massimo, possono verificarsi errori di arrotondamento.

Curiosità: I numeri reali possono avere anche i valori aggiuntivi di 0 positivo e negativo o infinito e NaN (Not-a-Number). Per i float NaN è rappresentato dalla parola dati a 32 bit 0x7fc00000.

Oggetti

Esistono due forme di oggetti: i tipi di riferimento e i tipi di valore.

I tipi di valore si comportano come i tipi primitivi, in quanto vengono allocati sullo stack e deallocati quando la variabile esce dallo scope. Solo l'applicazione può registrare questi tipi, quindi è necessario controllare la documentazione dell'applicazione per ulteriori informazioni sui tipi registrati.

I tipi di riferimento sono allocati sull'heap della memoria e possono sopravvivere alla variabile iniziale che li ha allocati se viene mantenuto un altro riferimento all'istanza. Tutte le classi dichiarate da script sono tipi di riferimento. Le interfacce sono una forma speciale di tipi di riferimento, che non possono essere istanziati, ma possono essere utilizzati per accedere agli oggetti che implementano le interfacce senza conoscere esattamente il tipo di oggetto.

obj o;      // An object is instantiated
o = obj();  // A temporary instance is created whose
            // value is assigned to the variable

Handle di oggetti

Gli handle degli oggetti sono un tipo speciale che può essere utilizzato per contenere riferimenti ad altri oggetti. Quando si richiamano metodi o si accede alle proprietà di una variabile che è un handle di un oggetto, si accede all'oggetto effettivo a cui l'handle fa riferimento, proprio come se fosse un alias. Si noti che, a meno che non sia inizializzato con l'handle di un oggetto, l'handle è nullo.

obj o;
obj@ a;           // a is initialized to null
obj@ b = @o;      // b holds a reference to o
b.ModifyMe();     // The method modifies the original object
if (a is null)    // Verify if the object points to an object
{
  @a = @b;        // Make a hold a reference to the same object as b
}

Non tutti i tipi consentono di prendere un handle. Nessuno dei tipi primitivi può avere handle e possono esistere alcuni tipi di oggetti che non consentono gli handle. Gli oggetti che consentono o meno gli handle dipendono dall'applicazione che li registra.

I modificatori di tipo handle e array di oggetti possono essere combinati per formare handle ad array, o array di handle, ecc.

Handle di funzioni

Un handle di funzione è un tipo di dati che può essere impostato dinamicamente per puntare a una funzione globale che ha una firma di funzione corrispondente a quella definita dalla dichiarazione della variabile. Gli handle di funzione sono comunemente usati per i callback, cioè quando un pezzo di codice deve essere in grado di richiamare del codice in base ad alcune condizioni, ma il codice che deve essere richiamato non è noto in fase di compilazione.

Per utilizzare gli handle di funzione è necessario innanzitutto definire la firma della funzione che verrà utilizzata a livello globale o come membro di una classe. Una volta fatto ciò, le variabili possono essere dichiarate utilizzando tale definizione.

Ecco un esempio che mostra la sintassi per l'utilizzo degli handle di funzione.

// Define a function signature for the function handle
funcdef bool CALLBACK(int, int);

// An example function that shows how to use this
void main()
{
  // Declare a function handle, and set it
  // to point to the myCompare function.
  CALLBACK @func = @myCompare;

  // The function handle can be compared with the 'is' operator
  if (func is null)
  {
    print("The function handle is null\n");
    return;
  }
  // Call the function through the handle, just as if it was a normal function
  if (func(1, 2))
  {
    print("The function returned true\n");
  }
  else
  {
    print("The function returned false\n");
  }
}

// This function matches the CALLBACK definition, since it has
// the same return type and parameter types.
bool myCompare(int a, int b)
{
return a > b;
}

Delegates

È anche possibile prendere handle di funzione per metodi di classe, ma in questo caso il metodo di classe deve essere legato all'istanza dell'oggetto che verrà utilizzato per la chiamata. Questo legame si chiama creazione di un delegato e si effettua eseguendo una chiamata di costrutto per la definizione di funzione dichiarata, passando il metodo della classe come argomento.

class A
{
  bool Cmp(int a, int b)
  {
    count++;
    return a > b;
  }
  int count = 0;
}

void main()
{
  A a;
  // Create the delegate for the A::Cmp class method
  CALLBACK @func = CALLBACK(a.Cmp);
  // Call the delegate normally as if it was a global function
  if (func(1,2))
  {
    print("The function returned true\n");
  }
  else
  {
    print("The function returned false\n");
  }
  printf("The number of comparisons performed is "+a.count+"\n");
}

Stringhe

Le stringhe contengono un array di byte o di parole a 16 bit, a seconda delle impostazioni dell'applicazione. Normalmente vengono utilizzate per memorizzare il testo, ma in realtà possono memorizzare qualsiasi tipo di dato binario.

Ci sono due tipi di costanti stringa supportate nel linguaggio script avanzato: le normali stringhe quotate e le stringhe di documentazione, chiamate stringhe heredoc.

Le stringhe normali sono scritte tra doppi apici (") o singoli apici ('). All'interno delle stringhe costanti si possono usare alcune sequenze di escape per scrivere valori esatti di byte che potrebbero non essere possibili da scrivere nel normale editor.

Sequenza	Valore	Descrizione
\0	0	carattere nullo
\\	92	barra rovesciata
\'	39	virgolette singole (apostrofo)
\"	34	virgolette doppie
\n	10	avanzamento di riga
\r	13	ritorno a capo
\t	9	carattere di tabulazione
\xFFFF	0xFFFF	FFFF deve essere scambiato con un numero esadecimale da 1 a 4 cifre che rappresenta il valore desiderato. Se l'applicazione utilizza stringhe a 8 bit, sono accettati solo valori fino a 255.
\uFFFF	0xFFFF	FFFF deve essere scambiato con il numero esadecimale che rappresenta il punto di codice unicode.
\UFFFFFFFF	0xFFFFFFFF	FFFFFFFF deve essere scambiato con il numero esadecimale che rappresenta il punto di codice unicode.

string str1 = "This is a string with \"escape sequences\" .";
string str2 = 'If single quotes are used then double quotes can be included without "escape sequences".';

Le stringhe heredoc sono progettate per l'inclusione di grandi porzioni di testo senza l'elaborazione di sequenze di escape. Una stringa heredoc è circondata da tripli doppi segni di virgolette (""") e può estendersi su più righe di codice. Se i caratteri che seguono l'inizio della stringa fino alla prima interruzione di riga contengono solo spazi bianchi, questi vengono automaticamente rimossi dal compilatore. Allo stesso modo, se i caratteri che seguono l'ultima interruzione di riga fino alla fine della stringa contengono solo spazi bianchi, anche questi vengono rimossi.

string str = """
  This is some text without "escape sequences". This is some text.
  This is some text. This is some text. This is some text. This is
  some text. This is some text. This is some text. This is some
  text. This is some text. This is some text. This is some text.
  This is some text.
  """;

Se più costanti stringa sono scritte in sequenza con solo spazi bianchi o commenti tra di esse, il compilatore le concatena in un'unica costante.

string str = "First line.\n"
"Second line.\n"
"Third line.\n";

Le sequenze di escape \u e \U aggiungono il punto di codice unicode specificato come sequenza codificata UTF-8 o UTF-16, a seconda delle impostazioni dell'applicazione. Sono accettati solo i punti di codice unicode 5.1 validi, ossia quelli compresi tra U+D800 e U+DFFF (riservati alle coppie surrogate) o superiori a U+10FFFF.

Dichiarazioni auto

È possibile utilizzare "auto" come tipo di dati di una dichiarazione di variabile in stile assegnazione.

Il tipo appropriato per le variabili sarà determinato automaticamente.

auto i = 18; // i will be an integer
auto f = 18 + 5.f; // the type of f resolves to float
auto o = getLongObjectTypeNameById(id); // avoids redundancy for long type names

Auto può essere qualificato con const per forzare un valore costante:

const auto i = 2; // i will be typed as 'const int'

Per i tipi che supportano gli handle, auto diventerà sempre un handle, perché è più efficiente che fare un'assegnazione di valore. Se per qualche motivo la variabile non deve essere un handle, non utilizzate la parola chiave 'auto'.

auto a = getObject(); // auto is typed 'obj@'
auto@ b = getObject(); // this is still allowed if you want to be more explicit

Gli handle automatici non possono essere utilizzati per dichiarare i membri della classe, poiché la loro risoluzione dipende dal costruttore.

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.