Metaprogramming C/C++ usando il preprocessore

Question

Quindi ho questo enorme albero che è fondamentalmente un grosso interruttore/caso con chiavi stringa e chiamate di funzioni diverse su un oggetto comune a seconda della chiave e di un pezzo di metadati.

Ogni voce appare sostanzialmente in questo modo

} else if (strcmp(key, "key_string") == 0) { 
    ((class_name*)object)->do_something(); 
} else if (... 

dove do_something può avere diverse invocazioni, quindi non posso semplicemente usare puntatori a funzione. Inoltre, alcune chiavi richiedono che l'oggetto venga trasmesso a una sottoclasse.

Ora, se dovessi codificare questo in un linguaggio di livello superiore, userei un dizionario di lambda per semplificare questo.

mi venne in mente che avrei potuto usare le macro per semplificare questo a qualcosa come

case_call("key_string", class_name, do_something()); 
case_call(/* ... */) 

dove case_call sarebbe una macro che espandere questo codice per il primo frammento di codice.

Tuttavia, sono molto sul recinto se questo sarebbe considerato di buon gusto. Voglio dire, ridurrebbe il lavoro di digitazione e migliorerebbe l'ESSENZIALITÀ del codice, ma in realtà sembra abusare del sistema macro in qualche modo.

Vuoi andare su quella strada, o meglio scrivere tutto? E quale sarebbe il tuo ragionamento per farlo?

Modifica

Alcuni chiarimenti:

Questo codice è utilizzato come strato collante tra un'API scripting semplificata che accede diversi aspetti di come semplici proprietà valori-chiave C++ API. Le proprietà sono implementate in diversi modi in C++: alcuni hanno metodi getter/setter, alcuni sono impostati in una struttura speciale. Le azioni di scripting fanno riferimento a oggetti C++ convertiti in una classe base comune. Tuttavia, alcune azioni sono disponibili solo su alcune sottoclassi e devono essere abbattute.

In fondo alla strada, posso cambiare l'attuale API C++, ma per il momento, deve essere considerato immutabile. Inoltre, questo deve funzionare su un compilatore incorporato, quindi boost o C++ 11 non sono (purtroppo) non disponibili.

Answer 1

Ti suggerirei di invertire leggermente i ruoli. Stai dicendo che l'oggetto è già una classe che sa come gestire una certa situazione, quindi aggiungi un virtual void handle(const char * key) nella tua classe base e consenti all'oggetto di verificare l'implementazione se si applica a esso e fa tutto ciò che è necessario.

Questo non solo eliminerebbe la lunga catena if-else-if, ma sarebbe anche più sicuro per il tipo e offrirà una maggiore flessibilità nella gestione di tali eventi.

Answer 2

Questo mi sembra un uso appropriato delle macro. Dopotutto, sono fatti per eliminare la ripetizione sintattica. Tuttavia, quando si ha una ripetizione sintattica, non è sempre colpa della lingua, probabilmente ci sono scelte progettuali migliori là fuori che consentono di evitare completamente questa decisione.

La saggezza generale è quella di utilizzare un tasti di mappatura tabella per azioni:

std::map<std::string, void(Class::*)()> table; 

Poi cercare e richiamare l'azione in un colpo solo:

object->*table[key](); 

Oppure utilizzare find per verificare la presenza di guasti:

const auto i = table.find(key); 
if (i != table.end()) 
    object->*(i->second)(); 
else 
    throw std::runtime_error(...); 

Ma se come dici tu non c'è una firma comune per le funzioni (es., non è possibile utilizzare i puntatori funzione membro), quindi quello che effettivamente deve fare dipende dai dettagli del progetto, che non conosco. Potrebbe essere che una macro sia l'unico modo per elidere la ripetizione che stai vedendo, o potrebbe essere che ci sia un modo migliore per farlo.

Chiediti: perché le mie funzioni accettano argomenti diversi? Perché sto usando i cast? Se stai inviando il tipo di un oggetto, è probabile che tu debba introdurre un'interfaccia comune.