First question: is it good practise to collect all such runtime config data in one class?
Yes. It is better to centralize runtime constants and values and the code to read them.
A class' constructor can be a given a reference to my ConfigBlock
This is bad: most of your constructors will not need most of the values. Instead, create interfaces for everything that is not trivial to construct:
old code (your proposal):
MyGreatClass(ConfigBlock &config);
new code:
struct GreatClassData {/*...*/}; // initialization data for MyGreatClass
GreatClassData ConfigBlock::great_class_values();
instantiate a MyGreatClass:
auto x = MyGreatClass{ current_config_block.great_class_values() };
Here, current_config_block is an instance of your ConfigBlock class (the one that contains all your values) and the MyGreatClass class receives a GreatClassData instance. In other words, only pass to constructors the data they need, and add facilities to your ConfigBlock to create that data.
Or they just include a header "CodingBlock.h" which contains a definition of my CodingBlock:
extern CodingBlock MyCodingBlock;
Then, only the classes .cpp file needs to include and use the ConfigBlock stuff. The .h file does not introduce this interface to the user of the class. However, the interface to ConfigBlock is still there, however, it's hidden from the .h file. Is it good to hide it this way?
This code suggests that you will have a global CodingBlock instance. Don't do that: normally you should have an instance declared globally, in whatever entry point your application uses (main function, DllMain, etc) and pass that around as an argument wherever you need (but as explained above, you should not pass the entire class around, just expose interfaces around the data, and pass those).
Also, don't tie your client classes (your MyGreatClass) to the type of CodingBlock; This means that, if your MyGreatClass takes in a string and five integers, you will be better off passing in that string and integers, than you will be passing in a CodingBlock.
