Thread: #define vs const

It doesn't matter. Chances are that when your compiler see the const value, it will consider it the same way as the #define'd value. Leave such small optimizations to your compiler. It knows much better about optimization than any of us.

It isn't allways possible for optomizations to rollout const values, and you really shouldn't assume that it happens... not in C.

When you declare a const variable, assume that it either gets put on the stack (local variable) or in the .data segment of your program (globals).

So, in theory, it's a bit more space efficient to use #define.

Originally Posted by @nthony

Practically, I know it should not matter, but it is of much interest to me how the memory management works on a machine code level (i.e. assembley). It would be of great help if someone could clarify exactly what happens on a assembler level when a const is used vs a #define.

You should learn assembly if you really want an understanding of C's memory handling, but here it goes.

The following assembly is more or less pseudocode. I haven't done any actual assembly in years.

-------------------------------------------------
First, an introduction to my assembly pseudocode...
The data segment contains information which is included in the exe and is loaded into memory when the program is run. It can be roughly though of as 'global' memory.
The code segment contains information which is included in the exe and is loaded into memory when the program is run. It is the machine code of the program.
The assembly is very simplified, and I made up the directives and instructions on the fly. Everything after a ';' is meant to be a comment.
db stands for 'declare byte'. 'dlw' stands for 'declare long word', or 32 bits.

Inline code.

Code:

int main (void) {
   printf("%d\n", 3);
   return 0;
}

Translates into something like this:

Code:

segment data 
__string1: 
db '%d\n\0' ; 4 bytes are allocated in the data segment

segment code
__main:
push 3
push __string1
call printf
ret 0

-----------------------------

The equivalent 'const' code.

Code:

int const i = 3;

int main (void) {
   printf("%d\n", i);
   return 0;
}

Code:

segment data 
__string1: 
db '%d\n\0' ; 4 bytes are allocated in the data segment.
i:
dlw 3 ; I assume 'int' is a 32-bit value, so 4 more bytes.

segment code
__main:
push lookup i ; Note that i is an address value.  So, at the machine level, 
     ; a very basic sort of dereferencing has to happen.  Processors, of course,
     ; are very much optomized for this kind of operation.
push __string1
call printf
ret 0

So, the inlined code should take up less space in memory, and as a file, because of the smaller data segment.

----------------------------------------------

Before anyone claims that the C compiler will just turn the const code into equivalent #define code, I would like to point out that const and #define are not equivalent. Const neccisarily needs store the variable somewhere in memory so we can do things like this:

Code:

int const i = 3;

int main (void) {
   int const * p = &i;
   printf ("%d\n", *p);
   return 0;
}

1. This isn't possible in C

const int size = 10;
int myArray[ size ];

You have to do
#define size 10
int myArray[ size ];

2. macro values are not type checked whereas consts are

3. You could point at a const, whereas you can't point at a define.

4. constants are more visible to the debugger. #defines are essentially lost when the pre-processor is run.

Any more?

Same principle applies. A pointer takes memory just as much as an int does.

-------------------------------------------------

Code:

int main (void) {
   printf("Hello World!\n");
   return 0;
}

Translates into something like this:

Code:

segment data 
__string1: 
db 'Hello World!\n\0'

segment code
__main:
push __string1
call printf
ret 0

-----------------------------

The equivalent 'const' code.

Code:

char const * const S = "Hello World!\n";

int main (void) {
   printf(S);
   return 0;
}

Code:

segment data 
__string1: 
db 'Hello World!\n\0'
S:
dlw __string1 ; Still 4 extra bytes.

segment code
__main:
push lookup S
call printf
ret 0

I sometimes use #defines for strings, as Kennedy mentioned. It's useful for concatenating strings.

Code:

#define VERSION "1.00"
#define FULL_VERSION "program version " VERSION

printf(FULL_VERSION "\n"
    "usage: program [arguments]);

Another alternative for numbers is to use the "enum hack". I don't like it myself, though, and I'm sure some people agree with me.

Originally Posted by Kennedy

how about

#define "This is a long string that will be used several times in the program."

I guess I should have clarified that the #define of a string is to what I was refering, not int, char, etc.

Ah, I should point out...
No matter how many times you use that string, the 'extra space' is still only going to be about 4 bytes, and both versions are going to still end up loading the 70-or-so bytes that that string requires.

Space isn't the only issue. Read Salem's post.

Originally Posted by Salem

1. This isn't possible in C

const int size = 10;
int myArray[ size ];

You have to do
#define size 10
int myArray[ size ];