Curiosity about preprocessor directive with #define

Question

I am practicing on #define and typedef. I think I got a good hold on the matter, according to this valid discussion. Currently, I am on this simple chunk of code:

#include <stdio.h>

/*typedef char *string;       with typedef the code works correctly*/

#define string char *

int main(void){
    string a[] = {"I", "like", "to", "fight,"}, 
           b[] = {"pinch", "and", "bight."};

    printf("%s %s %s %s %s %s %s\n",
        a[0], a[1], a[2], a[3], b[0], b[1], b[2]);
    return 0;
}

I know that define gives directive to the preprocessor. In this case, to substitute string with char *. Because of that, a is correctly declared as char *a[], while b[] is not! The problem could easily be addressed with

string b[] = {"pinch", "and", "bight."};

but my textbook challenge the reader by telling that the code with #define can work just by precisely adding one single character. I have been unable to figure out the solution. It is just for the sake of curiosity that I propose this simple problem to the community. Hence, thanks in advance for your time!

And that's why we generally don't use macros, or want anyone to be clever and use macros. C's declaration syntax is complicated, and not easily amenable to textual substitution. — Kerrek SB, May 12 '18 at 15:27
@KerrekSB I mainly agree. As far as my brief experience can tell, macros are more subtle to use. — Worice, May 12 '18 at 15:32

score 5 · Answer 1 · answered May 12 '18 at 15:34

5

This is why you should not use macro, after replacement you will get:

char* a[] = {"I", "like", "to", "fight,"}, 
       b[] = {"pinch", "and", "bight."};

where a is array of pointers to chars, and b is array of chars.

This is how declaration work, counter example:

char* a, b;

a is pointer to char b is char, to make it so you would have to write:

char* a, *b;

answered May 12 '18 at 15:34

Mateusz Wojtczak

1,621
1
12
28

1

BTW even using `typedef char *string;` is questionable. It make believe that there _is_ a `string` type, but `string` is still a mere pointer to char. – Jabberwocky May 12 '18 at 16:22

medalib · Answer 2 · 2018-05-13T00:04:13.527

3

After preprocessing, your code will look like this:

char * a[] = {"I", "like", "to", "fight,"}, 
       b[] = {"pinch", "and", "bight."};

In this way, b will be an array of char.

To solve the issue:

string a[] = {"I", "like", "to", "fight,"}, 
       *b[] = {"pinch", "and", "bight."};
       ^
       You have to add an asterisk here.

edited May 13 '18 at 00:04

answered May 12 '18 at 15:35

medalib

937
1
6
7

score 2 · Accepted Answer · answered May 12 '18 at 15:35

Adding a * before b will make the code work because then it expands to:

char *a[] = {"I", "like", "to", "fight,"}, 
     *b[] = {"pinch", "and", "bight."};

Of course having the * there will look utterly confusing when using the string macro (making it look like b is an array of string pointers), which I imagine is the point of the exercise: to show why using macros as a poor man's typedef leads to confusion.

Curiosity about preprocessor directive with #define

3 Answers3