Why make a constant a constant again?

The following is from a FreeBSD modem dialup program.

in ward.h

Code:

---

#define SPEAKER_ON      "M1"
#define SPEAKER_OFF    "M0"
#define SPKR_VOL_0      "M1L0"
#define SPKR_VOL_1      "M1L1"
#define SPKR_VOL_2      "M1L2"
#define SPKR_VOL_3      "M1L3"

---

And in modem.c

Code:

---

const char *Vol [] = {
        SPEAKER_OFF, SPKR_VOL_0, SPKR_VOL_1, SPKR_VOL_2, SPKR_VOL_3
};

---

[[email protected] award-1.0]# grep -iR SPEAKER_OFF /tmp/award-1.0
/tmp/award-1.0/modem.c: SPEAKER_OFF, SPKR_VOL_0, SPKR_VOL_1, SPKR_VOL_2, SPKR_VOL_3
/tmp/award-1.0/ward.h:#define SPEAKER_OFF "M0"

#define already makes stuff like SPEAKER_OFF constant. Why make it constant again in modem.c? Also, why not use these constants?

Sure, the "constants" are constant.
But this

Code:

---

const char *Vol []

---

says to the compiler that "We're not about to change the contents of the elements in this array" - so if the compiler wishes to be clever about it (e.g. "remembering" something across a function call), it doesn't need to worry about some code going changing the strings somewhere else.

Of course, if you then start modifying the strings, the compiler will give you an error - at least if the compiler actually understands what's going on.

So there's certainly very good reason to do things this way.

--
Mats

If the 'const' wasn't there then it would be saying that Vol is an array of pointers to strings that can be modified. However it actually only contains string literals, which must NOT be modified, hence the const for protection.

In fact, I would have put an extra const in there as well:

Code:

---

const char * const Vol []

---

This would stop the array elements themselves from being changed to point to different string literals later on.

I think part of the confusion stems from what #define is really doing.
#define doesn't create constants as you might be thinking of them. #define will just create a macro, which is essentially text substitution. So if you have the following:

Code:

---

#define FOO "foo"
const char *a[] = { FOO };

---

You'll actually wind up with the following code:

Code:

---

const char *a[] = { "foo" };

---

FOO isn't a variable at all, but something that's simply replaced. That explains why it acts like a constant:

Code:

---

#define FOO "foo"
FOO = "bar";

---

This doesn't work because it'd expand to: "foo" = "bar"; nonsense, clearly. But macros don't have a type, so they're not flagged as "constant". They expand to something that might have a type; in the instant case you see that they simply expand to a string literal, which has type array-of-char. No const! See the above posts for why you'd then want to use const yourself.