getter/setterの設計を単純化するために、値ラッパーと演算子（）のオーバーロードを使用する：危険な方法ですか？

Question

以下のクラスを考えてみましょう：

class MyClass1 
{ 
    public: 
     double x() const {return _x;} // getter 
     double y() const {return _y;} // getter 
     double z() const {return _x*_y;} // getter 
     void x(const double var) {_x = var;} // setter 
     void y(const double var) {_y = var;} // setter 
     void z(const double var) {_x = var; _y = 1;} // setter 
    protected: 
     double _x; 
     double _y; 
}; 

MyClass1の実際の内容は、実装の詳細であるため、ゲッターとセッターは、クラスの内容を取得し、設定する統一された方法を提供し、彼らはinterdependantであっても（ここでは_zありません内部的に存在するが、ユーザにとっては、zは、xおよびyのような変数である。 xとyのgetter/setterメソッドを記述する必要がないようにする今

、1はこのようにラッパーを使用することができます。

template <typename Type> 
class Wrapper 
{ 
    public: 
     constexpr Wrapper(const Type& value) {_value = value;} 
     constexpr Type& operator()() {return _value;} 
     constexpr const Type& operator()() const {return _value;} 
     constexpr void operator()(const Type& value) {_value = value;} 
    protected: 
     _value; 
}; 

をそして今、元のクラスは次のようになります。

class MyClass2 
{ 
    public: 
     Wrapper<double> x; 
     Wrapper<double> y; 
     double z() const {return x*y;} // getter 
     void z(const double var) {x = var; y = 1;} // setter 
}; 

がそれですゲッター/セッターを書く必要がないようにするには、危険な練習かよい解決策が必要ですか？

注：ここでMyClass1とMyClass2は例にすぎません。私の質問は非常に "一般的"です：getter/setterが単に内部値を返す/設定するとき、提案されたWrapperによってクラスのgetter/setterを置き換えるのは危険です。

Answer 1

getterとsetterの主な目的は、プライベートインスタンス変数にアクセスして設定する統一的な方法を提供することです。

あなたのラッパーソリューションから、プログラムのライフサイクルのトラックをいつか変更したい場合は、ラッパーを破棄して、MyClass1のような元のゲッター/セッターに置き換えることができます。それを呼び出すコードの他のコンポーネント

だから、あなたの解決策は余分な数行のコードを入力するのを防ぐ有効な方法だと思います。

Answer 2

特に危険なことは何も見ませんが、何も得られないようです。 C++は、セッター関数と互換性のないあらゆる種類のオブジェクトの参照セマンティクスを提供します。時には、実際の内容は単なる詳細ではない場合もあります。あなたはまた、（実際には、これは私が、私はこの質問をクリックしたときに表示することが期待したものである）他の道を行くことができ

：

struct virt_z { 
    double x; 
    double y; 
    struct z_wrap { 
     virt_z &parent; 

     operator double() { return parent.x * parent.y; } 
     z_wrap &operator=(double in) { 
      parent.x = in; 
      parent.y = 1; 
      return *this; 
     } 
     z_wrap(virt_z &in) : parent(in) {} 
    } z; 

    virt_z() : z(*this) {} 
    virt_z(virt_z const &o) : x(o.x), y(o.y), z(*this) {} 
}; 

https://ideone.com/qqgj3D

Answer 3

それはのような危険はありません、それはちょうどより多くであります使用するのが難しい（クラスユーザーのために）。 MyClass2はインターフェイスを難読化し、混乱させます。

コードを書くのが面倒になるかもしれませんが、コードを一度書くだけで済みます。インターフェイスは何度も再利用されます。したがって、コードリーダーを優先する必要があります。

この理由から、MyClass1はMyClass2とPotatoswatterのどちらのソリューションよりも優れています。

（これを行うには、C++でのやり方があった場合でも：

class MyClass3 
{ 
    double x, y, z; 
} 

MyClass3::z::operator=(double) { ... } // property set 
double MyClass3::z::operator() { ... } // property get 

「隠された」コードのこの種は、そのできの悪い仮定につながるので、C＃で、それはまだ私が考える悪いアイデアだろうように関数のスタイルでは、少なくともプリミティブなコピーよりも複雑なものがあるかもしれないと思うことができます。