Kann man den Aufruf lesbarer machen in C++?

?

enum option1_t
{
  option1_disabled,
  option1_enabled,
};
enum option2_t
{
  option2_disabled,
  option2_enabled,
};
...
Settings(option1_t opt1, option2_t opt2,...)
...
Settings(option1_enabled, option2_disabled, ...)

#include <iostream>
#include <boost/parameter.hpp>

BOOST_PARAMETER_NAME(option1)
BOOST_PARAMETER_NAME(option2)
BOOST_PARAMETER_NAME(option3)

struct settings_impl {
  bool option1, option2, option3;

  template <class ArgumentPack>
  settings_impl(ArgumentPack const& args)
    : option1(args[_option1 | false]),
      option2(args[_option2 | false]),
      option3(args[_option3 | false]) {}
};

struct settings : settings_impl
{
  BOOST_PARAMETER_CONSTRUCTOR(settings, (settings_impl), tag,
                              (optional (option1, *) (option2, *) (option3, *)))

  friend std::ostream& operator<<(std::ostream& os, settings const& s) {
    return os << "settings("
              << "option1=" << std::boolalpha << s.option1 << ", "
              << "option2=" << std::boolalpha << s.option2 << ", "
              << "option3=" << std::boolalpha << s.option3 << ")";
  }
};

int main()
{
  settings x(false, true);                      // positional
  settings y(_option1 = true, _option2 = true); // named
  settings z(_option3 = true);                  // positional/defaulted
  std::cout << "x: " << x << '\n';
  std::cout << "y: " << y << '\n';
  std::cout << "z: " << z << '\n';
}

Ausgabe:

x: settings(option1=false, option2=true, option3=false)
y: settings(option1=true, option2=true, option3=false)
z: settings(option1=false, option2=false, option3=true)

Jeder normaldenkende Programmierer würde das so umsetzen:
[...]

Haelst du es nicht fuer praktisch, dafuer noch einen neuen Thread zu starten, damit man parallel zum einlesen schon wieder was anderes machen kann?

normaldenker schrieb:

Jeder normaldenkende Programmierer würde das so umsetzen:[...]

Haelst du es nicht fuer praktisch, dafuer noch einen neuen Thread zu starten, damit man parallel zum einlesen schon wieder was anderes machen kann?

Nein, das wäre Overkill.

struct Settings
{
    enum printOption_e
    {
        NO_PRINT,
        PRINT   
    };

    enum saveOption_e
    {
        AUTO_SAVE,
        MANUAL_SAVE
    };

    enum alarmOption_e
    {
        SILENT,
        ALARMING
    };

    Settings( printOption_e po = NO_PRINT, saveOption_e so = AUTO_SAVE, alarmOption_e ao = SILENT )  
    : printOption( po )
    , saveOption( so )
    , alarmOption( ao )
    {}

    printOption_e printOption;
    saveOption_e saveOption;
    alarmOption_e alarmOption;
};

int main()
{
    Foo( Settings( Settings::PRINT, Settings::MANUAL_SAVE, Settings::ALARMING ) );
}

~Edit: alles in die Klasse (wg. namespace) II: 1. Vorschlag gelöscht, war eh Mist~

struct Foo
{
    enum options_e
    {
        NONE = 0,
        PRINTING = 1 << 0,
        SAVING   = 1 << 1,
        ALARMING = 1 << 2
    };

    Foo( unsigned int opt = NONE )  
    : options( opt )
    {}

private:
    unsigned int options;
};

int main()
{
    Foo( Foo::PRINTING | Foo::SAVING | Foo::ALARMING );
}

Etwas unschön ist, dass kombinierte Enum-Werte nicht mehr vom Enum-Typ sind, sondern (unsigned) int.

Sind denn die Optionen der jeweiligen Foo-Instanz zur Compilezeit schon bekannt? Dann könnte man auch über Polymorphie oder Policy-Klassen nachdenken... Das macht dann die Auswertung der Optionen innerhalb von Foo eleganter.

Kann man den Aufruf lesbarer machen in C++?

Da gibt es viele Möglichkeiten, einige wurden auch schon genannt. Hier eine weitere:

struct Settings
{
    struct Builder {
        explicit Builder(const Settings &s = Settings());
        Builder(const ::Builder &other);
        ~Builder() noexcept;

        Builder& operator=(const RequestBody::Builder &other);

        operator Builder() const;

        Builder& option1(bool state);
        Builder& option2(bool state);
        Builder& option3(bool state);

    private:
        struct Private;
        Private *d = nullptr;
    };

    Settings() : option1( false ),
                 option2( false ),
                 option3( false )
    {
    }

    friend Builder;
    bool option1;
    bool option2;
    bool option3;
};

struct Settings::Builder::Private {
    Private(const Settings &s) : settings s ) {}

    Settings settings;
};

Settings::Builder::Builder(const Settings &s)
  : d( new Private( s ) ) {
}

Settings::Builder::Builder(Settings::Builder const &other)
  : d( new Private( other.d->body ) ) {
}

Settings::Builder::~Builder() {
    delete d;
}

Settings::Builder& Settings::Builder::operator=(Settings::Builder const &other) {
    d->settings = other.d->settings;
    return *this;
}

Settings::Builder::operator Settings() const {
    return d->settings;
}

Settings::Builder& Settings::Builder::option1(bool state) {
    d->settings.option1 = state;
    return *this;
}

Settings::Builder& Settings::Builder::option1(bool state) {
    d->settings.option2 = state;
    return *this;
}

Settings::Builder& Settings::Builder::option3(bool state) {
    d->settings.option3 = state;
    return *this;
}

int main()
{
    Settings s = Settings::Builder().option1( true ).option3( true );

    // Wenn du sprechendere Namen verwendest, wäre es noch lesbarer:
    //Url url = Url::Builder().schema( "http" ).host( "www.c-plusplus.net" ).port( 80 ).path( "/forum/posting" );
}

Etwas unschön ist, dass kombinierte Enum-Werte nicht mehr vom Enum-Typ sind, sondern (unsigned) int.

Dafür gibts Operatorüberladung.

Da gibt es viele Möglichkeiten, einige wurden auch schon genannt. Hier eine weitere:

struct Settings
{
    // Settings Klasse
    struct Builder {
        // eine weitere Klasse, die kein Mensch braucht, es aber viel umständlicher macht

Und das soll besser sein? Ineffizient (überflüssige Allokation) und umständlich nur um 3 Optionen zu setzen. Vom Ansatz dennoch nicht ganz weit weg. Hier ist eine einfachere und effizientere Variante:

class Settings
{
  bool _option1;
  bool _option2;
  bool _option3;

public:
  Settings()
    : _option1(false),
      _option2(false),
      _option3(false)
      { }

  Settings& option1(bool sw)   { _option1 = sw; return *this; }
  Settings& option2(bool sw)   { _option2 = sw; return *this; }
  Settings& option3(bool sw)   { _option3 = sw; return *this; }
  bool option1() const  { return _option1; }
  bool option2() const  { return _option2; }
  bool option3() const  { return _option3; }
};

int main(int argc, char* argv[])
{
  Settings s = Settings().option1(true).option2(true).option3(true);

  // oder ein Beispiel sprechenden Namen:
  Settings s = Settings().schema( "http" ).host( "www.c-plusplus.net" ).port( 80 ).path( "/forum/posting" );
}

Der Code ist lesbarer und der syntaktische Zucker kann vom Compiler komplett weg optimiert werden.

Man kann natürlich auch wahlweise die Member öffentlich machen und die getter weg lassen, wie im ersten Beispiel. Dann muss man sich nur sinnvolle Namen für die setter ausdenken, wie z.B. setOption1(bool) .

Vom Ansatz dennoch nicht ganz weit weg. Hier ist eine einfachere und effizientere Variante:

class Settings
{
  bool _option1;
  bool _option2;
  bool _option3;

public:
  Settings()
    : _option1(false),
      _option2(false),
      _option3(false)
      { }

  Settings& option1(bool sw)   { _option1 = sw; return *this; }
  Settings& option2(bool sw)   { _option2 = sw; return *this; }
  Settings& option3(bool sw)   { _option3 = sw; return *this; }
  bool option1() const  { return _option1; }
  bool option2() const  { return _option2; }
  bool option3() const  { return _option3; }
};

int main(int argc, char* argv[])
{
  Settings s = Settings().option1(true).option2(true).option3(true);

  // oder ein Beispiel sprechenden Namen:
  Settings s = Settings().schema( "http" ).host( "www.c-plusplus.net" ).port( 80 ).path( "/forum/posting" );
}

Der Code ist lesbarer [...]

ähm ... der code ist einfacher und lesbarer als

enum { OPT1 = 0x1, OPT2 = 0x2, OPT3 = 0x4 };
Foo(OPT1 | OPT2 | OPT3);

??