Is #define var bad with strcmp?

Question

Can i compare#definevarible andchar * in strcmp as below.

#include<stdio.h>
#include<string.h>
#define var "hello"
int main()
{
char *p ="hello";
if(strcmp(p,var)==0)
printf("same\n");
else
printf("not same\n");
return 0;
}

Is there any risk comapre #define with char *as above example?

well, this example won't compile, so I guess there's that risk — UnholySheep, Sep 18 '17 at 14:56
nope, the preprocessor just replaces your token by the literal (that is, if the token matches the literal, which isn't the case in your code) — Jean-François Fabre, Sep 18 '17 at 14:56
The `var` name is *very* confusing. It is *not* a variable. By convention macro names are often all uppercase, e.g. `#define FOO "hello"` — Basile Starynkevitch, Sep 18 '17 at 15:05
Read wikipage on [C preprocessor](https://en.wikipedia.org/wiki/C_preprocessor); then read [documentation of `cpp`](https://gcc.gnu.org/onlinedocs/cpp/) and reference on [preprocessor](http://en.cppreference.com/w/c/preprocessor). You look confused! — Basile Starynkevitch, Sep 18 '17 at 15:08
Why in the world would one want to do this? Why not use a `const char[]`? — too honest for this site, Sep 18 '17 at 15:53
@Olaf can you please let me know advantage on using const char[] on #define please — Rohini Singh, Sep 19 '17 at 05:46
@RohiniSingh: It should become obvious once you learned the language properly. A good C book might help! — too honest for this site, Sep 19 '17 at 11:56

Jean-François Fabre · Accepted Answer · 2017-09-18T16:53:38.510

5

Don't trust us, trust the preprocessor output

File "foo.c"

#include <stdio.h>
#include <string.h>
#define var "hello"

int main(void)
{
    char *buf="hello";

    if(strcmp(buf,var)==0) // Is this good
        printf("same");

    return 0;    
}

now:

gcc -E foo.c

lots of output because of standard system libraries then...:

# 5 "foo.c"
int main(void)
{
    char *buf="hello";

    if(strcmp(buf,"hello")==0)
        printf("same");

    return 0;
}

as you see your define has been safely replaced by the string literal.

When you have a doubt, just apply this method to make sure (more useful when converting to strings or concatenating tokens, there are traps to avoid)

In your case, you could also avoid the macro and use:

static const char *var = "hello";

which guarantees that only 1 occurrence of "hello" is set (saves data memory).

edited Sep 18 '17 at 16:53

answered Sep 18 '17 at 15:06

Jean-François Fabre

137,073
23
153
219

In review I am asked to remove #define with static cost not sure why – Rohini Singh Sep 18 '17 at 15:10
some people don't like macros. In that case, `static const char *` is also OK, and maybe is even better since it guarantees that the memory of the string isn't duplicated. – Jean-François Fabre Sep 18 '17 at 15:12
@Jean-FrançoisFabre: Never use a macro if typesafe code will do as well (e.g. you will always get the same string, possibly save memory, etc.). – too honest for this site Sep 19 '17 at 11:58
yeah, in that case, you can avoid it without any copy/paste issue. Macros are great to avoid copying/pasting code constructs or token concatenation (to some extent) but here's it's overkill (I added such conclusion in my answer if you noticed) – Jean-François Fabre Sep 19 '17 at 15:59

score 2 · Answer 2 · answered Sep 18 '17 at 15:03

No, there is no risk to comapre #define with char* at all.

    #include <stdio.h>
    #include <string.h>
    #define var "hello"

    int main(void)
    {
        char *buf="hello";

        if(strcmp(buf,var)==0) // Is this good
            printf("same");

        return 0;    
    }

Is #define var bad with strcmp?

2 Answers2