const correctness for configuration structures

Question

I have a configuration file which gets read in, parsed and put into structures at the beginning of my programs run time.

The problem I am having is that I want these structures to be constant since the values in them should not change during the programs lifespan.

Currently I am doing the following:

config.h

#pragma warning(push)
#pragma warning(disable: 4510) /*-- we don't want a default constructor --*/
#pragma warning(disable: 4610) /*-- we don't want this to ever be user instantiated --*/

typedef struct SerialNode {
private:
    void operator=(SerialNode&);
public:
    const char* const port;
    const char* const format;
} SerialNode;

#pragma warning(pop)

typedef std::map<const char*, const SerialNode*, MapStrComp> SerialMap;
SerialMap SerialConfig;

config.cpp

/*-- so we don't fall out of scope --*/
SerialNode* global_sn;
SerialNode local_sn = {port, format};
global_sn = new SerialNode(local_sn);
SerialConfig[key_store] = global_sn;

---

This works fine. However my problem is that now I am dealing with more complicated configuration data which requires me to pull a structure back out of the list, modify it and then put it back.

Obviously I can't modify it, so the solution would be something like:

SerialNode* global_sn;
SerialNode* old_sn = SerialConfig[key_store];
SerialNode local_sn = {port, format, old_sn->old_data, old_sn->more_old_data};
global_sn = new SerialNode(local_sn);
SerialConfig[key_store] = global_sn;
delete old_sn;

But this strikes me as bad programming practice. Is there is a better way to achieve what I'm going for which doesn't require such a hacked looking solution?

For reference, I'm using Visual Studio 2010

Answer 1

As always, the best thing you can do is not re-implement something that has already been written. There are a large number of libraries and frameworks that will help with serialization for c++:

• Boost Serialization
• Qt
• Protocol Buffers
• msgpack
• Capn' Proto

Ideally the serialization framework you choose will exactly recreate the data graph that you are trying to store. Regardless of whether you have done any fixup, your goal will likely be to only provide const access to the global configuration data. Just make sure that mutators (including non const pointers) are not exposed via a header file.

Answer 2

This is not an answer to your question, just some observations to your code.

• You don't need the typedef struct SerialNode { ... } SerialNode;, this is a c idiom. In c++, you just write struct SerialNode { ... }; and use SerialNode as a type name.

• If you want to prevent a default constructor, make it private as you already do with the assignment operator

  class SerialNode {
  private:
      SerialNode();
      SerialNode &operator=(SerialNode&);
  ...
  };
  

• Don't use char* members, use std::string instead. C++ strings are much easier and safer to use than plain char pointers and the associated heap allocation.

• Same goes for the map key; if you use std::string as a key, you don't need MapStrComp anymore, because std::string already provides an appropriate comparison.

Answer 3

Probably nicer is to wrap the whole thing in a singleton class:

class Config {
  public:
    static Config const& get() { return *config; }
    static void load();

    SerialNode const* operator[](const char*);

  private:     
    static Config* config;

    SerialMap map;
};

void Config::load() {
  config = new Config();
  // put things into it
}

Disclaimer: not tested, and haven't used C++ in a while, so there might be some syntax errors :)

Answer 4

The simple answer is what Thomas suggest, but correctly done (that is, not causing undefined behavior):

Create a mutable configuration object but pass it to the rest of the components by constant reference. When you create (and where you maintain) the real object you can change it, but the rest of the application won't be able to modify the config. A common pattern I have used in the past was:

class SomeObject {
    Configuration const & config;
public:
    SomeObject(Configuration const & config) : config(config) {}
    void f() {
        if (config.someParam()) { ...
// ...

void loadConfiguration(Config & config) { ... }
int main() {
   Configuration config;
   loadConfiguration(config);  // config is a non-const &, can modify
   SomeObject object(config);  // object holds a const&, can only read
   object.f();
// ...