Thread: #define help please

#define is not used to define variables. #define is a simple command to the preprocessor to replace all the text it sees with the given value you provided.
In your example, it will replace every TRUE it finds with "1;".
Perhaps you should learn more about #defines, the preprocessor and variables.

It's possible, but not recommended. Whenever you do a a #define, the preprocessor will start replacing all the text from that point onwards. So you can do a "#define variable TRUE" somewhere and it will replace all the "variable" with "TRUE".
You can also undefine a define and then define it again, so you redefine it to something else.
But do not two things first:

- The preprocessor runs only once. So if you replace something with TRUE, then it will be TRUE in the code and not 1.
- Defines should not end with a ";". Everything after the space of the define is what the preprocessor will replace the text with.

So "#define TRUE 1;" will replace every "TRUE" with "1;" and not "1".

That's not a global variable in your code.

a global variable doesn't start with #define

If you have a global variable say:

int x = 10;

Then anywhere in the program you can change that value and it will be the stored and not lost. Also I'm interested to know what 'conditions' that you are talking about.

A global variable is just a variable that is defined at global scope, ie outside any functions.

Code:

int myint;
int main()

myint is global.
But global variables should be avoided, if possible.

As to your original question, you suspicion is correct. Define is not suited for global variables. It is suited for constants and macros.

A global variable is a variable you declare outside a function typically before the main function. Unlike variables declared inside functions where the values are lost when the function exits, the global variable retains it's value between function calls.

So if you have defined x = 10 as an int globally. It will remain that way until changed, if changed, it will keep that change until the program exits.

Originally Posted by Elysia

But global variables should be avoided, if possible.

Exactly. It's better to put use structs.

Eitherways, for small programs it doesn't matter about global variables and can be the most efficient way to implement a solution.

This may or may not be, but one should consider avoiding them since it's bad practice and will also make avoiding the decision of when the program is big enough to do away with them.
I don't recommend using them at all, unless necessary, not even in small programs. But your mileage may vary. Just take this into account.

Note also that the preprocessor does not do any sort of interpretation of just about anything that isn't starting with # or has a "name" in it that is a #define. So for example, we can write this (horrible thing):

Code:

#define A 1

int main()
{
    for(i = A;  // 1
#undef A
#define A 11
          i < A; i++)    // 2
    {
#undef A
#define A 100
          printf("i=%d A = %d\n", i, A);    // 3
    
    }
    return 0;
}

1. A is replaced with 1
2. A is replaced by 11
3. A is replaced by 100

--
Mats

That's not going to work

This is not really a good idea (not to mention you can't switch in a non-constant expression). It's confusing to say the least. Instead, it's better to do something such as:

Code:

typedef int bool;
#define false 0
#define true 1
bool debug = true;

...
if (debug)
...

void flipDebug(void)
{
    debug = !debug;
}