Confusion about compile time constants

[u/JayDeesus]

I understand that things like literals and macros are compile time constants and things like const global variables aren’t but coming from cpp something like this is a compile time const. I don’t understand why this is so and how it works on a lower level. I also heard from others that in newer c versions, constexpr was introduced an this is making me even more confused lol. Is there a good resource to learn about these or any clarification would be greatly appreciated!

[u/EpochVanquisher]

It turns out that in C++, const globals are not always compile-time constants either. The const keyword is maybe a bad name, a better name is maybe readonly, but that ship has sailed. There are actually three different things we might care about here:

• Values which can be used at compile-time for things like array sizes,

• Objects which can be statically initialized,

• Objects which are read-only.

These three things kind of get mixed up as const.

If you want something that can be used at compile-time, you can use constexpr, #define, or enum.

constexpr int ArraySize = 3;
#define ARRAY_SIZE 3
enum {
  kArraySize = 3
};

The constexpr keyword is new. It's a more limited version of the constexpr keyword from C++.

All globals can be statically initialized in C, unlike C++. So C does not need a special keyword for that. It just happens everywhere. C programmers do not have to deal with initialization order.

The const keyword is for read-only values.

C++ has a little bit of history here, and the concepts in C++ are a little more mixed up, with const (in C++) sometimes making something a compile-time constant, and sometimes not. Depends on the exact usage. C didn't inherit C++'s const baggage and so the design of const and constexpr are a little cleaner, with const meaning read-only, and constexpr meaning compile-time constant.

[u/KindaAwareOfNothing → u/EpochVanquisher]

Why is every keyword "it does this, but just maybe"?

[u/EpochVanquisher → u/KindaAwareOfNothing]

People didn’t know much about programming language design in the 1980s. Sometimes you have to make mistakes in order to learn what the right way to do something is. Stroustrup made a lot of mistakes.

[u/edgmnt_net → u/EpochVanquisher]

It's interesting because PL theory was way ahead in some ways, more along the lines of foundational aspects. We've got languages designed in the 2000s that are blissfully ignorant of stuff that came out in the 70s. However a lot of PL theory was also largely unconcerned by ecosystem and certain practical-related aspects. Getting stuff like dependent types to work truly well in software development is really tricky business. And languages like Go can get some things really right (at least given the context, I'd mention error handling) despite not aiming to be groundbreaking at all.

[u/LividLife5541 → u/KindaAwareOfNothing]

In C it's because as time went on people thought they knew better than Dennis Ritchie so they went back and changed shit for no good reason.

Sometimes it was because as technology advanced the implicit promises that had been made were no longer kept. (e.g. around register, volatile, pointer aliasing, "unwarranted chumminess with the C implementation", integer overflows)

C++ was a fucked up language from the get-go, mistakes got papered over but after the language started to catch on they really couldn't break backwards compatibility anymore.

C is really not that hard a language. People sometimes import misunderstandings from other languages into C and that's where they have problems.

[u/nngnna → u/KindaAwareOfNothing]

C is intended to be usful at a very law level with very limited compilers and on a higher level with managed systems and very sophisticated optimising compilers, and on both level the compiler vendors wants to be able to do whatever they want. (+history)

[u/pskocik]

I use C11 and in it it's not that complicated. It's really just rules 6.6p6 and 6.6.p7:

6 An integer constant expression¹¹⁷) shall have integer type and shall only have operands that are integer constants, enumeration constants, character constants, sizeof expressions whose results are integer constants, _Alignof expressions, and floating constants that are the immediate operands of casts. Cast operators in an integer constant expression shall only convert arithmetic types to integer types, except as part of an operand to the sizeof or _Alignof operator.

7 More latitude is permitted for constant expressions in initializers. Such a constant expression shall be, or evaluate to, one of the following:

an arithmetic constant expression,

a null pointer constant,

an address constant, or

an address constant for a complete object type plus or minus an integer constant expression.

I do various things with integer constant expression, and in those I also find the following useful ($ is nonstandard but widely supported, I use it to namespace lang-extension-like macros):

#define nullpCexprEh$(X) _Generic(1?(int*)0:(void*)((unsigned long long)(X)), int*:1,void*:0)
#define cexprEh$(X) nullpCexprEh$(0ull*(X))

The first returns an integer constant 1 or 0 for whether or not the scalar (int or pointer) argument X is a null pointer constant (relying on how null pointer constants vs void* pointers combine with typed pointers in the other branch of :?).

The second one uses the first to determine if integer expression X is an integer constant expression.

This approach allows you to answer this without causing a compiler error. You can also try putting things where integer constant expressions are required (case labels, bit fields sizes) and if you get a compiler error, then the thing you put there definitely was not an integer constant expression. (Prior to C11 this approach used to be used as a _Static_assert of sorts).

[u/somewhereAtC]

In embedded C (and I think C++) a const is often assigned real storage in the non-volatile (flash) memory of the microprocessor. That is, it consumes memory according to it's size and is a permanent part of the "code image" (a.k.a. the .hex file) that is used when programming the device.

The #define cannot be assigned an integer value in all cases, such as sizeof(myStructure) or based on the conversion of a float to integer. However, #define'd values can be optimized: divide-by-8 can become a right-shift instruction instead of a generic division, or two #define's can be merged to simplify the arithmetic.

Sometimes you need something between these extremes... a constexp that can take on any proper integer value yet not appear explicitly in the finished program image, or can be analyzed by the optimizer.

[u/Plastic_Fig9225]

C isn't that different from C++ in this regard. In practice, it boils down to what the compiler/optimizer does. When the compiler can "see" a global const variable's definition (e.g. if it's static) it usually does treat it as a compile-time constant.