#define vs const

From what I've read so far on the topic, there seems to be a common consensus that it is good practice to use const inplace of a preprocessor #define when declaring constants. Many of the reasons go on about type checking, and debugging, however, my main curiousity on the difference between the two is memory management on a low level. Since const allocates memory for a variable whereas #define simply does text replacement in the code, when it all comes down to machine language, which makes more effecient use of space, a hardcoded value or a variable?

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.

If you are on a modern machine, space is not an issue. However, on an embedded system (where space counts), using a const will save you some space since it is a reference and not an inline value. But, the space you save is very minimal.

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.

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.

Quote:

---

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;
}

---

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.

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.

Quote:

---

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.

Quote:

---

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 ];

---

It has been noted but I thought I should clarify it; consts are always put into memory in C, but in C++ they're only put into memory if they have to.