Come memorizzare le etichette goto in una matrice e poi saltare a loro?

Question

Voglio dichiarare un array di "jumplabels".

Quindi voglio passare a una "jumplabel" in questo array.

Ma non ho idea di come farlo.

Esso dovrebbe essere simile al seguente codice:

function() 
{ 
    "gotolabel" s[3]; 
    s[0] = s0; 
    s[1] = s1; 
    s[2] = s2; 

    s0: 
    .... 
    goto s[v]; 

    s1: 
    .... 
    goto s[v]; 

    s2: 
    .... 
    goto s[v]; 
} 

Qualcuno ha un'idea di come eseguire questa?

Answer 1

È possibile con la funzione GCC nota come "labels as values".

void *s[3] = {&&s0, &&s1, &&s2}; 

if (n >= 0 && n <=2) 
    goto *s[n]; 

s0: 
... 
s1: 
... 
s2: 
... 

Funziona solo con GCC!

Answer 2

Non esiste un modo diretto per memorizzare gli indirizzi di codice in cui passare in C. Come utilizzare lo switch.

#define jump(x) do{ label=x; goto jump_target; }while(0) 
int label=START; 
jump_target: 
switch(label) 
{ 
    case START: 
     /* ... */ 
    case LABEL_A: 
     /* ... */ 
} 

È possibile trovare codice simile prodotto da ogni parser/generatore di stato senza stack. Tale codice non è facile da seguire, a meno che non sia generato codice o il tuo problema è il più facilmente descritto dalla macchina a stati, consiglierei di non farlo.

Answer 3

potresti utilizzare i puntatori di funzione invece di goto?

In questo modo è possibile creare una serie di funzioni per chiamare e chiamare quella appropriata.

Answer 4

In semplice standard C, questo non è possibile per quanto ne so. Esiste tuttavia un'estensione nel compilatore GCC, documented here, che rende ciò possibile.

L'estensione introduce il nuovo operatore &&, per prendere l'indirizzo di un'etichetta, che può quindi essere utilizzato con l'istruzione goto.

Answer 5

goto ha bisogno di un'etichetta in fase di compilazione.

Da questo esempio sembra che si stia implementando una sorta di macchina a stati. Più comunemente la loro applicazione come un interruttore-costrutto case:

while (!finished) switch (state) { 
    case s0: 
    /* ... */ 
    state = newstate; 
    break; 

    /* ... */ 
} 

Se avete bisogno di essere più dinamico, utilizzare un array di puntatori a funzione.

Answer 6

Ecco a cosa servono le dichiarazioni switch.

switch (var) 
{ 
case 0: 
    /* ... */ 
    break; 
case 1: 
    /* ... */ 
    break; 
default: 
    /* ... */ 
    break; /* not necessary here */ 
} 

Nota che non è necessariamente tradotto in una tabella di salto dal compilatore.

Se si desidera creare autonomamente il jump table, è possibile utilizzare un array di puntatori di funzioni.

Answer 7

Non è possibile farlo con un goto: le etichette devono essere identificatori, non variabili o costanti. Non riesco a capire perché non vorresti usare un interruttore qui - probabilmente sarà altrettanto efficiente, se questo è ciò che ti riguarda.

Answer 8

Per una risposta semplice, invece di forzare i compilatori a fare cose veramente stupide, apprendere buone pratiche di programmazione.

Answer 9

Si potrebbe voler dare un'occhiata a setjmp/longjmp.

Answer 10

Tokenizer? Questo sembra quello per cui è stato creato gperf. No davvero, dai un'occhiata.

Answer 11

compilatori Ottimizzazione (tra cui GCC) saranno compilare un'istruzione switch in una tabella di salto (fare una dichiarazione interruttore esattamente veloce come la cosa si sta cercando di costruire) se sono soddisfatte le seguenti condizioni:

tuo interruttore i casi (numeri di stato) iniziano da zero.

Le custodie degli interruttori sono in costante aumento.

Non si salta alcun numero intero nelle proprie custodie.

ci sono abbastanza casi che una tabella salto è effettivamente più veloce (un paio di dozzine confrontare-e-goto nel metodo di controllo-ogni-caso di trattare con istruzioni switch è in realtà più veloce di un tavolo salto.)

Questo ha il vantaggio di permetterti di scrivere il tuo codice in C standard invece di basarti su un'estensione del compilatore. Funzionerà altrettanto velocemente in GCC. Funzionerà altrettanto velocemente nella maggior parte dei compilatori ottimizzanti (so che il compilatore Intel lo fa, non sono sicuro delle cose di Microsoft). E funzionerà, anche se più lentamente, su qualsiasi compilatore.