Macro C e uso di argomenti tra parentesi

Esempio

#define Echo(a) a #define Echo(a) (a) 

Mi rendo conto che probabilmente non c’è una differenza significativa qui, ma perché dovresti voler includere l’ a tra parentesi all’interno del corpo macro? Come lo altera?

    Supponiamo di avere

     #define mul(x, y) x * y 

    Cosa succede se dico:

     mul(a + 5, 6); /* a + 5 * 6 */ 

    Ora se cambio leggermente la macro:

     #define mul(x, y) ((x) * (y)) mul(a + 5, 6); /* ((a + 5) * (6)) */ 

    Ricorda, gli argomenti non vengono valutati o nulla, viene eseguita solo la sostituzione testuale.

    MODIFICARE

    Per una spiegazione su come avere l’intera macro tra parentesi, vedere il collegamento pubblicato da Nate CK .

    Solo per la cronaca, sono atterrato da qui. Come correggere gli errori matematici mentre uso le macro e cercherò di espandere qui questa risposta per adattarla all’altra.

    Stai chiedendo la differenza su:

     #define Echo( a ) a #define Echo( a ) ( a ) 

    che va bene fintanto che non capisci la macro stessa (non sono un esperto troppo :)).

    Prima di tutto già (probabilmente) sai che esiste la Precedenza dell’operatore, quindi c’è un’enorme differenza tra questi due programmi:

    1):

     #include  #define ADD( a , b ) a + b int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( 2 + a , 2 + b ); printf( "%d", c ); return 0; } 

    Produzione:

     19 

    e:

     #include  #define ADD( a , b ) ( a ) + ( b ) int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( a , b ); printf( "%d", c ); return 0; } 

    Produzione:

    15

    Ora lascia preplace + con * :

     #define ADD( a, b ) a * b 

    Il compilatore tratta a * b come per esempio a == 5 e b == 10 che fa 5 * 10 .

    Ma quando dici: ADD ( 2 + a * 5 + b ) Come qui:

     #include  #define ADD( a , b ) ( a ) * ( b ) int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( 2 + a , 5 + b ); printf( "%d", c ); return 0; } 

    Otterrai 105 , perché la precedenza dell’operatore è coinvolta e tratta

    2 + b * 5 + a

    come

    ( 2 + 5 ) * ( 5 + 10 )

    che è

    ( 7 ) * ( 15 ) == 105

    Ma quando lo fai:

     #include  #define ADD( a, b ) a * b int main( void ) { auto const int a = 5; auto const int b = 10; auto const int c = ADD ( 2 + a , 5 + b ); printf( "%d", c ); return 0; } 

    ne ottieni 37 causa di

      2 + 5 * 5 + 10 

    che significa:

     2 + ( 5 * 5 ) + 10 

    che significa:

     2 + 25 + 10 

    Risposta breve, c’è una grande differenza tra:

     #define ADD( a , b ) a * b 

    e

     #define ADD( a , b ) ( a ) * ( a )