C++でProperty（getter/setter）

C#のPropertyって便利だよね

C++でやるには？

とりあえず簡単に実装するなら名前を渡してメンバ変数とgetter/setterを定義するマクロ。
これは稀によく見る。
でもスマートじゃないよね。

じゃあもうTemplateしかないっしょ

書いてみた。
https://github.com/HogeTatu/cpp_module/tree/master/Property

Property基底

template <typename T>
class Property
{
public:
    Property(T& value) : _value(value) {}
    Property(const Property& ref) : _value(ref._value) {}
    virtual ~Property() {}

    Property<T>& operator = (const Property<T>& ref)
    {
        this->_value = T(ref._value);
        return *this;
    }

protected:
    T&      _value;
};

getter/setter有りなProperty

template <typename T, class Getter = SimplePropertyGetter<T>, class Setter = SimplePropertySetter<T>>
class WritableProperty : public Property<T>, private Getter, private Setter
{
public:
    WritableProperty(T& value) : Property<T>(value) {}
    WritableProperty(const WritableProperty& ref) : Property<T>(ref) {}
    virtual ~WritableProperty() {}

public:
    operator const T& () const { return this->Get(this->_value); }
    const T& operator -> () const { return this->Get(this->_value); }

    WritableProperty<T, Getter, Setter>& operator = (const T& var) { this->Set(this->_value, var); return *this; }
};

getterのみのProperty

template <typename T, class Getter = SimplePropertyGetter<T>>
class ReadOnlyProperty : public Property<T>, private Getter
{
public:
    ReadOnlyProperty(T& value) : Property<T>(value) {}
    ReadOnlyProperty(const ReadOnlyProperty& ref) : Property<T>(ref) {}
    virtual ~ReadOnlyProperty() {}

public:
    operator const T& () const { return this->Get(this->_value); }
    const T& operator -> () const { return this->Get(this->_value); }
};

デフォルトのgetterポリシー

template <typename T>
struct SimplePropertyGetter
{
    static const T& Get(const T& value) { return value; }
};

デフォルトのsetterポリシー

template <typename T>
struct SimplePropertySetter
{
    static void Set(T& value, const T& var) { value = T(var); }
};

実装内容

メンバ変数の実体をコンストラクタで渡して処理を委託する。
getter/setterの振る舞いはポリシーで切り替えられるようにした。

サンプル

こんなクラスがあったとして

class Sample
{
public:
    Sample()
        : _foo1(1)          , foo1(_foo1)
        , _bar1("bar1")     , bar1(_bar1)
        , _foo2(2)          , foo2(_foo2)
        , _bar2("bar2")     , bar2(_bar2)
    {}

    cpp_module::WritableProperty<int>           foo1;
    cpp_module::WritableProperty<std::string>   bar1;
    cpp_module::ReadOnlyProperty<int>           foo2;
    cpp_module::ReadOnlyProperty<std::string>   bar2;

private:
    int             _foo1;
    std::string     _bar1;
    int             _foo2;
    std::string     _bar2;
};

こんな感じに書ける。

Sample sample;

sample.foo1 = 10;
sample.bar1 = "sample.bar1";
output(sample.foo1);
output(sample.bar1);

//sample.foo2 = 20;                 // コンパイルエラー
//sample.bar2 = "sample.bar2";      // コンパイルエラー
output(sample.foo2);
output(sample.bar2);

ちなみにポインタ型でプロパティを定義したら a->b の形でも参照できる。

Getter、Setterの振る舞いを変えたければ、自分でポリシーを定義して

cpp_module::WritableProperty<int, CustomGetter, CustomSetter>   foo1;

みたいにしたらいい。

ちょっと考えたけど思い付かなかったから匙を投げたもの

sample.bar1.c_str()

がエラーになる。

const std::string& bar1 = sample.bar1;
bar1.c_str();

だったらOK。
a.b のオーバーロードができないからなぁ。
「こんなやり方どう？」みたいなのあったら教えて下さい。
あと何かやらかしてたら指摘して頂けると勉強になります。