È necessario il punto e virgola dopo le dichiarazioni in x ++?

Question

Come detto nel libro Microsoft Dynamics AX 2009 Programmazione: Introduzione E'necessari per mettere un punto e virgola dopo le dichiarazioni di x ++:

Il punto e virgola in più dopo il dichiarazione della variabile è obbligatoria finchè il la prima riga di codice non è una parola chiave . Il punto e virgola indica al compilatore che le dichiarazioni variabili sono terminate. Non è possibile dichiarare nuove variabili dopo questo punto e virgola .

(copiati direttamente dal libro, immutata, se necessario i'll toglierlo)

Tuttavia, quando rimuovo il punto e virgola ed eseguire il lavoro, Theres assolutamente nessun errore o un problema:

static void Job1(Args _args) 
{ 
    str string1 = "STACKOVERFLOW"; 
    ; 
    print string1; 
    pause; 
} 

funziona altrettanto

static void Job2(Args _args) 
{ 
    str string1 = "STACKOVERFLOW"; 

    print string1; 
    pause; 
} 

è davvero necessario? dovrei abituarmi a usarlo?

Answer 1

E 'spiegato in modo elegante here.

Una citazione chiave:

"Il motivo è necessario che il punto e virgola in più è perché il compilatore non può sempre vedere dove la dichiarazione finale variabile Se non lo fai aiuto un po ', lo farà. fai una congettura e non è molto bello allo indovinando. "

Answer 2

È necessario solo il punto e virgola se il corpo del codice non inizia con una parola chiave. Nel tuo esempio, il tuo codice inizia con print, che è una parola chiave integrata. Se avessi provato ad avviare il tuo codice con: string1+=".COM";, riceverai un errore.

Dynamics AX 2009 è l'ultima versione di AX che richiede il punto e virgola in più. AX 6.0 dovrebbe risolvere questo problema: mfp's two cents: What's up with this semicolon?

Answer 3

Con il rilascio di AX 2012 non è necessario inserire il punto e virgola aggiuntivo dopo la dichiarazione delle variabili.

http://msdn.microsoft.com/en-us/library/aa636895.aspx

Answer 4

Davvero non è necessario il bel punto e virgola (non si ottiene un errore di compilazione) quando la parola successiva dopo le dichiarazioni (se presente) non è una parola chiave riconosciuto da compilator come un tipo (un EDT, tavolo, classe, ...)

Ad esempio:

void method1() 
{ 
    CustTable custTable; 

    custTable = CustTable::find("cust"); 
} 

ERRORE! come compilatore non può separare il blocco di dichiarazione di classe dell'inizio del codice X ++. Quando il compilatore legge la seconda riga, non sa se il custTable è una nuova variabile o fa parte del codice X ++.Quindi, è necessario il punto e virgola in più per dire che il compilatore è la fine delle dichiarazioni (in realtà, dove è l'inizio del codice X ++).

void method1() 
{ 
    CustTable custTable; 

    if (custTable) 
    { 
     // stuff happens 
    }   
} 

funziona! come compilatore sa che non è possibile dichiarare una variabile di tipo if (è una parola chiave riservata, ovviamente), quindi è chiaro che questo è l'inizio del codice X ++ e non è possibile dichiarare le variabili dopo questa riga.

questo funziona in questo modo, anche se non ci sono dichiarazioni di variabili:

CustTable method1() 
{ 
    custTable = CustTable::find("cust"); // custTable may exists in the context 
    return custTable; 
} 

ERRORE!custTable può essere una decodifica o codice X ++ come quello nell'esempio.

CustTable method1() 
{ 
    return CustTable::find("cust"); 
} 

OPERE! come return non può essere una dichiarazione.

EXTRA:

void method1() 
{ 
    info("This should work, ya?"); 
} 

Questo dovrebbe funzionare (come info non è un tipo), non è vero? ... ma non è così! Perché? Perché info è uno speciale metodo del kernel che verrà sostituito con il suo nome completo: Global::info(), il primo token sarà Global dopo la sostituzione del precompilatore e Global è una classe.