オブジェクト指向における「クラスA have a クラスB」の関係において，クラスBからクラスAのあるメンバ変数だけを触る方法

Question

クラス10～50個の中規模プログラミングに当たって，以下の問題がよく出てきて，「簡潔な方法はないものか・・・」と悩んでいます． ●前提条件【・「クラスAに持たれているクラスB（　A　have　a　B　関係）において，　　クラスBからクラスAのあるメンバ変数（プロパティ）だけを触りたい」】この場合，私はよく以下のようにしてしまい，クラス間の独立性を無くしてしまいます． ●方法１：・クラスBのコンストラクタに「自分の持ち主であるクラスAのオブジェクト」を引数に取り，クラスBの変数（プロパティ）usedClassAとする． ======= C言語風に書くと，


public　void　クラスA{
　　クラスB　usingClassB　=　new　クラスB();　//　持っているクラスB
　　int　commonNum　=　0;
　　public　void　AddCommonNum(){
　　　　　　commonNum++;
　　　}
　　　...
　　　（その他の処理）
　　　...
}

public　void　クラスB{
　　　class　usedClassA;　　　　//　持ち主のクラスA

　　　//　コンストラクタ
　　　public　クラスB(クラスA　_usedClassA){
　　　　　　　usedClassA　=　_usedClassA;
　　　}
　　　public　void　AddCommonNum(){
　　　　　　　_usedClassA.AddCommonNum();
　　　}
}
<\code>
となります．

この方法の問題点は，クラスAとクラスBに＜双方向の依存関係を作っている＞ことで，
クラスAの設計（ここではAddCommonNum()）が変更されたときに，クラスBの内容を変更しなければならない可能性があることから，拡張性に欠けると考えています．

そこで，他に何かいい実装方法が無いか，
教えていただけないでしょうか？
特に，このような前提条件に汎用的に使える方法だと尚良いです．

machongola · Accepted Answer

　こんにちは。

　簡単な話、共通のプロパティクラスを作成して、ClassAとClassBが其れを参照したり更新したりすれば、ClassAとClassBは左程依存しないのでは。
　一応C++で、其れらしき事をしてみましたので、参考程度に。

#pragma warning(disable : 4786)
#include<map>
#include<string>

//プロパティオブジェクトココから
struct IVariantHolder
{
　　virtual ~IVariantHolder(){ }
};

template<class __TP>
struct CVariantHolder : public IVariantHolder
{
　　typedef typename __TP variant;

　　explicit CVariantHolder(const variant& val) : m_val(val){}
　　~CVariantHolder(){}

　　variant& Get(){ return m_val; }
　　const variant& Get() const { return m_val; }
　　operator variant&(){ return m_val; }
　　operator const variant&() const { return m_val; }
private:
　　variant m_val;
};

struct CPropertyData
{
　　typedef std::map<std::string, IVariantHolder*> map_t;
　　template<class __TP>
　　bool AddProperty(const __TP& tp, const std::string& sPropertyName)
　　{
　　　　if(GetProperty(sPropertyName))return false;
　　　　return m_map.insert(std::make_pair(sPropertyName, new CVariantHolder<__TP>(tp))).second;
　　}
　　IVariantHolder* GetProperty(const std::string& sPropertyName)
　　{
　　　　return const_cast<IVariantHolder*>(
　　　　　　　　　　　　　　　　static_cast<const CPropertyData&>(*this).GetProperty(sPropertyName)
　　　　　　　　　　　　　　　　　　　　　);
　　}
　　const IVariantHolder* GetProperty(const std::string& sPropertyName) const
　　{
　　　　map_t::const_iterator it = m_map.find(sPropertyName);
　　　　return it == m_map.end() ? 0 : it->second;
　　}
private:
　　map_t m_map;
};

template<class __TP>
static __TP* Lock(CPropertyData* property, const std::string& sPropertyName)
{
　　CVariantHolder<__TP>* pVal = dynamic_cast<CVariantHolder<__TP>*>(property->GetProperty(sPropertyName));
　　return pVal ? &pVal->Get() : 0;
}
//プロパティオブジェクトココまで

//テスト用の構造体
struct CommonStruct
{
　　CommonStruct(long _l, short _s, char _c) : l(_l), s(_s), c(_c){}
　　longl;
　　shorts;
　　charc;
};

//クラスAとクラスBココから
struct ClassB;
struct ClassA
{
　　ClassA(ClassB* p, CPropertyData* property) : m_useClassB(p), m_property(property)
　　{
　　　　//ココでメンバ変数（プロパティ）の領域を動的に作成する
　　　　m_property->AddProperty(int(0), "commonNum");
　　　　m_property->AddProperty(CommonStruct(4, 2, 1), "commonStruct");
　　}
　　void DisplayProperty()
　　{
　　　　::printf("%s %d %s\n", "[commonNum : ", *::Lock<int>(m_property, "commonNum"), "]");

　　　　CommonStruct* p = ::Lock<CommonStruct>(m_property, "commonStruct");
　　　　::printf("%s <%d><%d><%d> %s\n", "[commonStruct <l><s><c> : ", p->l, p->s, p->c, "]");
　　}
private:
　　ClassB*m_useClassB;
　　CPropertyData*m_property;
};

struct ClassB
{
　　explicit ClassB(CPropertyData* property) : m_property(property){}
　　void AddCommonNum()
　　{
　　　　int* pi = ::Lock<int>(m_property, "commonNum");
　　　　(*pi)++;
　　}
　　void SetCommonStruct(long l, short s, char c)
　　{
　　　　CommonStruct* pc = ::Lock<CommonStruct>(m_property, "commonStruct");
　　　　new (pc) CommonStruct(l, s, c);
　　}
private:
　　CPropertyData*m_property;
};
//クラスAとクラスBココまで

//お試し
int main()
{
　　//両方に共通なプロパティオブジェクト
　　CPropertyData property;

　　//クラスBに渡す
　　ClassB b(&property);

　　//クラスAにクラスBとプロパティオブジェクトを渡す
　　ClassA a(&b, &property);

　　//クラスBでプロパティを操作する
　　b.AddCommonNum();
　　b.SetCommonStruct(10, 20, 30);

　　//クラスAでプロパティを表示する
　　a.DisplayProperty();
　　return 0;
}

machongola · Answer

御礼・補足頂きました。
　C++ではstructとclassの違いはアクセス指定のデフォルトが違うだけです。その他は全て一緒です。
　structはデフォルトでpublic、classはデフォルトでprivateです。
　
　私の書いたCPropertyDataクラスにデストラクタを書き忘れてしまいました・・・。

　以下追記
　~CPropertyData()
　{
　　　　　for(map_t::iterator it = m_map.begin(); it != m_map.end(); ++it)
　　　　　　　delete it->second;
　}

noname#94983 · Answer

そうだな、ちょっと具体例が思い浮かばないが、基本、やっぱりコンストラクタで引数を渡し保持するような形になるのはやむを得ないと思うな。

ただし、汎用性を考えるのであれば、Aをインターフェイスとして定義し、その実装としてAImplクラスを定義する。そしてクラスBでは、引数にAインターフェイスを渡すように考える。Aインターフェイスでは、B内から必要となるメソッドなりフィールドなりを実装するよう定義しておく。

であれば、AImplを変更したり別のクラスに差し替える必要が生じた場合も、新しいクラスにimplements Aするだけですむ。完全に依存性を排除することはできないが、弱い依存性でまとめることが可能になる。

オブジェクト指向における「クラスA have a クラスB」の関係において，クラスBからクラスAのあるメンバ変数だけを触る方法

御礼・補足頂きました。

こんにちは。

この回答への補足

そうだな、ちょっと具体例が思い浮かばないが、基本、やっぱりコンストラクタで引数を渡し保持するような形になるのはやむを得ないと思うな。

この回答への補足

似たような質問が見つかりました

関連するカテゴリからQ&Aを探す

デイリーランキングこのカテゴリの人気デイリーQ&Aランキング

マンスリーランキングこのカテゴリの人気マンスリーQ&Aランキング

　御礼・補足頂きました。

　こんにちは。