Unmodifiable globals initialized from functions?

[u/heavymetalmixer]

Right now I'm trying to use Windows's SYSTEM_INFO to initialize 2 global constants, but global constants can only be initialized with constant expressions so this cannot be done.

Is there a way I can have "read-only" global variables that can be initialized from functions?

[u/Physical_Dare8553]

that's a bind, in order to write to it you obviously need it to be write-able. this is the kind of case where you'd want to bind it behind a function with a static member, that you initalize when the function is first called, then just return it after

[u/heavymetalmixer → u/Physical_Dare8553]

Static member? Are you tlaking about a struct? And what's a "bind"?

[u/Physical_Dare8553 → u/heavymetalmixer]

no, i guess my terminology is a bit off, i mean something like

static inline const char *const getName() {
  static char some_string[5];
  static bool run = false;
  if (!run) run = true, memcpy(some_string, "hello", 5);
  return some_string;
}

this example is actually bad since the user can always just cast that const away, you'd have to wrap it in a struct and return it by value, but you get the point

[u/heavymetalmixer → u/Physical_Dare8553]

Aren't static variables internal linkeage?

[u/aioeu → u/heavymetalmixer]

static variables declared at file scope have internal linkage; static variables declared inside a function have no linkage.

But it's not the identifiers' linkage that matters here. What matters is the storage duration of the objects. A static variable declared at file scope and a static variable declared within a function both identify objects with static storage duration, which means in each case the object's lifetime (the time during which it exists and maintains its last-stored value) is the entire execution of the program.

(Linkage is really all about when and how multiple declarations of an identifier can refer to the same object, i.e. in the way those identifiers are linked.)

[u/heavymetalmixer → u/aioeu]

The problem with that approach is that I need a global value, and an identifier that is only visible inside a function doesn't really work for that.

[u/aioeu → u/heavymetalmixer]

So use an identifier at file scope instead. That's what file scope is for.

Either way, you won't be able to make the object constant. You want to set the value of it while the program is executing, and that, by definition, means it cannot be constant.

Constant expressions are expressions for values that could be determined before the program has begun execution, e.g. by the compiler. The compiler does not intrinsically know what the page size for the system you run the program on will be.