C++ Best practices for constants

Question

I have a whole bunch of constants that I want access to in different parts of my code, but that I want to have easy access to as a whole:

static const bool doX = true; static const bool doY = false; static const int maxNumX = 5; 

etc.

So I created a file called "constants.h" and stuck them all in there and #included it in any file that needs to know a constant.

Problem is, this is terrible for compile times, since every time I change a constant, all files that constants.h reference have to be rebuilt. (Also, as I understand it, since they're static, I'm generating a copy of doX/doY/maxNumX in code every time I include constants.h in a new .cpp, leading to kilobytes of wasted space in the compiled EXE -- is there any way to see this?).

So, I want a solution. One that isn't "declare constants only in the files that use them", if possible.

Any suggestions?

Answer 1

The only alternative is to make your constants extern and define them in another .cpp file, but you'll lose potential for optimization, because the compiler won't know what value they have when compiling each .cpp`.

By the way, don't worry about the size increase: for integral types your constants are likely to be inlined directly in the generated machine code.

Finally, that static is not necessary, since by default const global variables are static in C++.

Answer 2

I think your base assumption is off.

Your other headers are usually organized by keeping together what works together. For example, a class and its related methods or two classes heavily interlinked.

Why group all constants in a single header ? It does not make sense. It's about as bad an idea as a "global.h" header to include every single dependency easily.

In general, the constants are used in a particular context. For example, an enum used as a flag for a particular function:

class File { public:   enum class Mode {     Read,     Write,     Append   };    File(std::string const& filename, Mode mode);    // ... }; 

In this case, it is only natural that those constants live in the same header that the class they are bound to (and even within the class).

The other category of constants are those that just permeate the whole application. For example:

enum class Direction {   Up,   Down,   Right,   Left,   Forward,   Backward }; 

... in a game where you want to express objects' move regarding the direction they are facing.

In this case, creating one header file for this specific set of constants is fine.

And if you really are worried about grouping those files together:

constants/   Direction.hpp   Sandwich.hpp   State.hpp 

And you will neatly sidestep the issue of recompiling the whole application when you add a constant... though if you need to, do it, you're paying the cost only once, better than a wrong-sided design you'll have to live off with for the rest of your work.