2013-01-31 10 views
21

Ho una certa esperienza in programmazione in C ma non oserei definirmi esperto. Recentemente, ho incontrato la seguente macro:C: vantaggio/intento della macro apparentemente inutile

#define CONST(x) (x) 

trovo in genere utilizzato in espressioni come per esempio:

double x, y; 
x = CONST(2.0)*y; 

Completamente sconcertato dal punto di questa macro, ho ampiamente studiato i vantaggi/svantaggi e le proprietà dei macro, ma ancora non riesco a capire quale sarebbe l'uso di questa particolare macro. Mi sto perdendo qualcosa?

+2

Questa macro non ottiene nulla, a parte forse come promemoria visivo che qualcosa è una costante ... –

+2

L'unica ragione per cui posso pensare a ciò sarebbe consentire a uno strumento esterno di trovare più facilmente costanti specifiche nel programma . Viene utilizzato per contrassegnare il testo da tradurre a volte anche se non sono sicuro di come possa essere d'aiuto qui – jcoder

+2

E lo rende ricercabile – Minthos

risposta

11

Come presentato nella domanda, hai ragione che la macro non fa nulla.

Questo sembra una struttura artificiale imposta da chiunque abbia scritto quel codice, forse per rendere abbondantemente chiaro dove sono le costanti, e poterle cercare? Potrei vedere il vantaggio nell'avere costanti ricercabili, ma questo non è il modo migliore per raggiungere questo obiettivo.

È anche possibile che questo facesse parte di un altro schema macro che non è mai stato implementato o è stato rimosso solo parzialmente.

+1

+1, questa è l'unica cosa sana che possa pensare anche per questo. –

+5

Questo non è sano, un programmatore sensato non userebbe "numeri magici" ma invece '#define SOME_FLOAT 2.0', seguito da' x = SOME_FLOAT * y; '. O ancora meglio, usa una variabile 'const', se applicabile. – Lundin

+2

Una variabile const non è "ancora migliore". È considerato dannoso. –

2

Non c'è assolutamente alcun vantaggio di quella macro e chiunque l'abbia scritta deve essere confusa. Il codice è completamente equivalente a x = 2.0*y;.

1

Bene, questo tipo di macro potrebbe effettivamente essere utile quando è necessario risolvere l'espansione della macro.
Un tipico esempio di tale necessità è la macro di stringificazione. Fare riferimento alla seguente domanda per un esempio: C Preprocessor, Stringify the result of a macro

Ora nel tuo caso specifico, non vedo il vantaggio appart da estremo paradosso o scopi di analisi del codice.

+0

Un buon punto sulla macro di stringificazione che ho riscontrato anche nella mia ricerca in un precedente SO post http://stackoverflow.com/questions/1597007/creating-c-macro-with-and-line-token-concatenation-with- positioning-macr Comunque nel codice che ho trovato, non è usato in quel modo – Pankrates

0

Un altro utilizzo potrebbe essere di riservare quei valori come futuri invocazioni di funzione, qualcosa di simile:

/* #define CONST(x) (x) */ 
#define CONST(x) some_function(x) 

// ... 

double x, y; 
x = CONST(2.0)*y; // x = some_function(2.0)*y; 
6

alcuni compilatori (old) C non supportano la parola const e questa macro è molto probabilmente una reminiscenza di un sequenza più elaborata di macro che gestiva diversi compilatori. Usato come in x = CONST(2.0)*y; anche se non ha senso.

È possibile controllare this section from the Autoconf documentation per ulteriori dettagli.

MODIFICA: Un altro scopo di questa macro potrebbe essere la preelaborazione personalizzata (ad esempio per estrarre e/o sostituire determinate costanti), come fa Q2 Framework Meta Object Compiler.

0

altro aspetto positivo di questa macro sarebbe qualcosa di simile

result=CONST(number+number)*2; 

o qualcosa legato ai confronti

result=CONST(number>0)*2; 

Se c'è qualche problema con questa macro, è probabilmente il nome. Questa cosa "CONST" non è correlata con le costanti ma con qualche altra cosa. Sarebbe bello cercare il resto del codice per sapere perché l'autore lo chiamava CONST.

0

Questa macro ha l'effetto di avvolgere le parentesi attorno a x durante l'espansione della macro.

Sto cercando di indovinare che qualcuno sta cercando di permettere qualcosa sulla falsariga di

CONST(3+2)*y 

che, senza la parentesi, sarebbe diventato

3+2*y 

ma con le parentesi diventa

(3+2)*y 

Mi sembra di ricordare che abbiamo avuto bisogno di qualcosa di simile in una precedente vita di sviluppo.