オペレータでのオブジェクトポインタの比較===

Question

いくつかのコードのメンテナンスを行っていますが、は簡略化する必要があります。の方が、読みやすく、コードの数が少なくて済みます。 次のサンプルクラスを考える：

class MyClass 
{ 

public: 
    MyClass(); 
    MyClass(Object1* o1, Object2* o2, Object3* o3, Object4* o4); 
    ~MyClass(); 

    MyClass &operator=(const MyClass &other); 
    void copy(const MyClass &other); 
    bool operator==(const MyClass &other) const; 

    ... 

private: 
    Object1* o1 = 0; 
    Object2* o2 = 0; 
    Object3* o3 = 0; 
    Object4* o4 = 0; 
}; 

このクラスは、1〜4の任意のオブジェクトで構成されています。

これらのオブジェクトがnullになる可能性がありますので、私は等しい演算子に来たときに、私が見つけた次等しい演算子が必要な場合、私は議論を持参する必要はありません

bool MyClass::operator==(const MyClass &other) const 
{ 
    if (o1 && (other.o1 == NULL)) return false; 
    if ((o1 == NULL) && other.o1) return false; 
    if (o1 && other.o1){ if (*o1!= *other.o1) return false; } 
    if (o2 && (other.o2 == NULL)) return false; 
    if ((o2 == NULL) && other.o2) return false; 
    if (o2 && other.o2){ if (*o2!= *other.o2) return false; } 
    if (o3 && (other.o3 == NULL)) return false; 
    if ((o3 == NULL) && other.o3) return false; 
    if (o3 && other.o3){ if (*o3!= *other.o3) return false; } 
    if (o4 && (other.o4 == NULL)) return false; 
    if ((o4 == NULL) && other.o4) return false; 
    if (o4 && other.o4){ if (*o4!= *other.o4) return false; } 
    return true; 
} 

かそうではない、私はちょうど上記のコードを簡素化する方法があるかどうかを知りたい。

一般的なこと：等価演算子でオブジェクトポインタを比較する最も標準的で効率的な方法は何ですか？

Answer 1

実際にコードを簡略化したい場合は、ポインタの使用をやめ、実際にはoptionalのオブジェクトを使用してください。次のいずれかを実行できwait for std::optional（C++ 17、これだけ数ヶ月と新しいコンパイラはおそらく既にそれをサポートしています）、またはブーストを使用します。

#include <boost/optional.hpp> 

class MyClass 
{ 

public: 
    MyClass(
     boost::optional<Object1> o1 = boost::none, 
     boost::optional<Object2> o2 = boost::none, 
     boost::optional<Object3> o3 = boost::none, 
     boost::optional<Object4> o4 = boost::none 
    ) : o1(o1), o2(o2), o3(o3), o4(o4) {} 

private: 
    boost::optional<Object1> o1; 
    boost::optional<Object2> o2; 
    boost::optional<Object3> o3; 
    boost::optional<Object4> o4; 
}; 

またはちょうどかなり簡単に独自のロール。

これらすべての演算子や独自のコピーコンストラクタは必要ありません。

いつものように、キーは特定のロジックを抽象化しているので、きれいに再利用できます。この場合、まだどこかにoperator==がありますが、まだコピーコンストラクタがどこかにありますが、をのoptionalの内部に実装しており、それぞれのインスタンスに対してen masseを再作成する必要はありません。複数のインスタンスが自然に構成されます。

あなたが本当にあなたの現在の実装に固執したい場合は、少なくとも短縮することができます。

if (o1 && (other.o1 == NULL)) return false; 
if ((o1 == NULL) && other.o1) return false; 
if (o1 && other.o1){ if (*o1!= *other.o1) return false; } 

をする：

if (!o1 != !other.o1) return false; 
if (o1 && (*o1 != *other.o1)) return false; 

、それはまだ少しのEWのですが。

Answer 2

フィールドゲッターを受け入れるコンパレータの作成はどうですか？

template< typename TGetter > bool 
Eq(MyClass const & left, MyClass const & right, TGetter && getter) 
{ 
    auto const p_left(getter(left)); 
    auto const p_right(getter(right)); 
    return((!p_left && !p_right) || (p_left && p_right && (*p_left == *p_right))); 
} 

bool MyClass::operator==(const MyClass &other) const 
{ 
    return 
    (
     Eq(*this, other, [](const MyClass & inst){return inst.o1;}) 
     && 
     Eq(*this, other, [](const MyClass & inst){return inst.o2;}) 
     && 
     Eq(*this, other, [](const MyClass & inst){return inst.o3;}) 
     && 
     Eq(*this, other, [](const MyClass & inst){return inst.o4;}) 
    ); 
)