Settings Array in C++

Question

My aim is to set up a data structure to store the settings of my application.

In PHP I would just write...

$settings = array(
    "Fullscreen" => true,
    "Width"      => 1680,
    "Height"     => 1050,
    "Title"      => "My Application",
);

Now I tried to create a similar structure in C++ but it can't handle different datatypes yet. By the way if there is a better way of storing such settings data, please let me know.

struct Setting{ string Key, Value; };

Setting Settings[] = {
    ("Fullscreen", "true"),     // it's acceptable to store the boolean as string
    ("Width", "1680"),          // it's not for integers as I want to use them later
    ("Height", 1050),           // would be nice but of course an error
    ("Title", "My Application") // strings aren't the problem with this implementation
};

How can I model a structure of an associative array with flexible datatypes?

Answer 1

An associative data structure with varying data types is exactly what a struct is...

struct SettingsType
{
    bool Fullscreen;
    int Width;
    int Height;
    std::string Title;
} Settings = { true, 1680, 1050, "My Application" };

Now, maybe you want some sort of reflection because the field names will appear in a configuration file? Something like:

SettingsSerializer x[] = { { "Fullscreen", &SettingsType::Fullscreen },
                           { "Width",      &SettingsType::Width },
                           { "Height",     &SettingsType::Height },
                           { "Title",      &Settings::Title } };

will get you there, as long as you give SettingsSerializer an overloaded constructor with different behavior depending on the pointer-to-member type.

Answer 2

C++ is a strongly typed language. The containers hold exactly one type of object so by default what you are trying to do cannot be done with only standard C++.

On the other hand, you can use libraries like boost::variant or boost::any that provide types that can hold one of multiple (or any) type, and then use a container of that type in your application.

Rather than an array, you can use std::map to map from the name of the setting to the value:

std::map<std::string, boost::variant<bool,int,std::string> >

Answer 3

#include <map>
#include <string>

std::map<std::string,std::string> settings;

settings.insert("Fullscreen","true");
settings.insert("Width","1680");
settings.insert("Height","1050");
settings.insert("Title","My Application");

Could be one way of doing it if you want to stick with the STL.

Answer 4

One solution could be to define the ISetting interface like:

class ISetting{
public:
  virtual void save( IStream* stream ) = 0;
  virtual ~ISetting(){}
};

after that you can use a map in order to store your settings:

std::map< std::string, ISetting* > settings;

One example of the boolean setting is:

class BooleanSetting : public ISetting{
private:
  bool m_value;
public:
  BooleanSetting(bool value){
    m_value = value
  }

  void save( IStream* stream ) {
    (*stream) << m_value;
  }

  virtual ~BooleanSetting(){}
};

in the end:

settings["booleansetting"]=new BooleanSetting(true);
settings["someothersetting"]=new SomeOtherSetting("something");

Answer 5

One possible solution is to create a Settings class which can look something like

class Settings {
    public:
        Settings(std::string filename);

        bool getFullscreen() { return Fullscreen; }
        // ...etc.

    private:
        bool Fullscreen;
        int Width;
        int Height;
        std::string Title;
};

This assumes that the settings are stored in some file. The constructor can be implemented to read the settings using whatever format you choose. Of course, this has the disadvantage that you have to modify the class to add any other settings.

Answer 6

To answer your question, you could use boost::any or boost::variant to achieve what you would like. I think variant is better to start with.

boost::variant<
    std::string,
    int,
    bool
  > SettingVariant;

std::map<std::string, SettingVariant> settings;

To not answer your question, using typeless containers isn't what I would recommend. Strong typing gives you a way to structure code in a way that the compiler gives you errors when you do something subtly wrong.

struct ResolutionSettings {
  bool full_screen;
  size_t width;
  size_t height;
  std::string title;
};

Then just a simple free function to get the default settings.

ResolutionSettings GetDefaultResolutionSettings() {
  ResolutionSettings settings;
  settings.full_screen = true;
  settings.width = 800;
  settings.height = 600;
  settings.title = "My Application';
  return settings;
}

If you're reading settings off disk, then that is a little different problem. I would still write strongly typed settings structs, and have your weakly typed file reader use boost::lexical cast to validate that the string conversion worked.

ResolutionSettings settings;
std::string str = "800";
size_t settings.width = boost::lexical_cast<size_t>(str);

You can wrap all the disk reading logic in another function that isn't coupled with any of the other functionality.

ResolutionSettings GetResolutionSettingsFromDisk();

I think this is the most direct and easiest to maintain (especially if you're not super comfortable in C++).