C ++コードのコンポーネント接続性の低下

可変寿命

PImpl

• GotW＃24：コンパイルファイアウォール
  
• GotW＃28：Fast Pimplイディオム
  
• GotW＃100：コンパイルファイアウォール
  
• GotW＃101：コンパイルファイアウォール、パート2
  

1. このイディオムは、実装用のパラメーターを受け取るパブリックコンストラクターを隠しません。 この問題は、オブジェクトのインターフェイスとファクトリを組み合わせることで解決できます。
   
2. モジュールのインクルードのパブリック部分に不要なものをすべて、実装とともに移動することを忘れないでください。
   
3. 余分なコードを目から隠すために、C ++ 98と互換性のあるPImplモジュールを実装しました
   
   コード

    #ifndef PIMPL_H #define PIMPL_H ///idea from GotW #101: Compilation Firewalls, Part 2s http://herbsutter.com/gotw/_101/ #include <boost/scoped_ptr.hpp> template<typename T> class PImpl { private: boost::scoped_ptr<T> m; public: PImpl() : m(new T) { } template<typename A1> PImpl(A1& a1) : m(new T(a1)) { } //    2  9  …. template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6 , typename A7, typename A8, typename A9, typename A10> PImpl(A1& a1, A2& a2, A3& a3 , A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) : m(new T(a1, a2, a3, a4, a5 , a6, a7, a8, a9, a10)) { } PImpl(const PImpl& orig) : m(new T(*orig)) { } T* operator->() const { return m.get(); } T& operator*() const { return *m.get(); } PImpl& operator=(const PImpl& orig) { m.reset(new T(*orig)); return *this; } }; #endif /* PIMPL_H */ 

   
   
   
   
4. すべてのクラスで、実装宣言は次のようになります
   

    class Impl; PImpl<Impl> me; 

   
   meはVBAから借りました
   
5. （パブリックメソッドを呼び出すために）パブリック部分へのポインターが必要な場合、パブリックthisは最初のパラメーターImplコンストラクターに渡され、 ppubフィールドに格納されます
   
6. 完全な宣言を持つ実装は、現在のモジュールにのみスコープがあるため、常にstructとして宣言されます。
   
7. 通常、実装には、コンストラクターと、パブリックコンストラクターを完全に繰り返すオーバーロードオペレーターが必要です。 コピーコンストラクタとoperator=については、 meとppub設定することを忘れないでください。
   
8. JavaスタイルのImpl関数宣言。 ご存知のように、クラスですぐに宣言および定義された関数はインライン関数です。 インラインはコンパイラーへの単なるアドバイスであり、考慮に入れていない可能性があることを忘れてはなりません。したがって、大規模な関数はインライン化されない可能性が高くなりますが、関数の宣言と定義の定型文は少なくなります。
   
9. 単体テストについて。 ご存じのように、ユニットテストでは、テスト対象のモジュールが依存する実装の代わりにスタブが必要になることがよくあります。 コードが依存するオブジェクトがPImplで実装されている場合、リンカーを使用して実際の実装をスタブに非常に簡単に置き換えることができます。 隠された実装のテストは、＃includeディレクティブを使用してテストモジュールに実装コードを含めることで可能です。
   
   上記の包括的な例

    ------- Hasher.h ------ #include <PImpl.h> class Hasher { class Impl; //   class  struct    PImpl<Impl> me; //   public: Hasher(); void execute(); int getResults(); }; ------- Hasher.cpp ------ #include “Hasher.h” #include <HashLib.h> #include “SecTokens.h” // . struct      struct Hasher::Impl { Hasher* ppub; //    HashContext cnt; int hash; Impl(Hasher* ppub): ppub(ppub) { } void prepare() { HashLib::createContext(cnt); hash = 0; } void update(int val) { HashLib::updateHash(cnt, hash, val); } void finalize() { HashLib::releaseContext(cnt); } }; Hasher::Hasher(): me(this) { //     } void Hasher::execute() { me->prepare(); me->update(SecTokens::one); me->update(SecTokens::two); me->finalize(); } int Hasher::getResults(){ return me->hash; } ------- Cryptor.h ------ #include <string> #include <PImpl.h> class Cryptor { class Impl; PImpl<Impl> me; public: Cryptor(std::string salt); std::string crypt(std::string plain); }; ------- Cryptor.cpp ------ #include <CryptoLib.h> #include “Cryptor.h” struct Cryptor::Impl { std::string salt; CryptoContext cnt; Impl(std::string salt): me(salt) { } void prepare() { CryptoLib::createContext(cnt); } void update(std::string plain) { CryptoLib::updateHash(cnt, plain); } std::string finalize() { return CryptoLib::releaseContext(cnt); } }; Cryptor::Cryptor(std::string salt): me(salt) { } std::string Cryptor::crypt(std::string plain) { me->prepare(); me->update(plain); return me->finalize(); } ------- MockHasher.cpp ------ #include “Hasher.h” struct Hasher::Impl { }; void Hasher::execute() { } int Hasher::getResults(){ return 4; } ------- TestCryptor.cpp ------ #include “Cryptor.cpp” int main(int argc, char** argv) { Cryptor::Impl impl(“salt”); impl.prepare(); //   impl  prepare impl.update(“text”); //   impl  update std::string crypto=impl.finalize(); //    crypto } 

   
   
   
   したがって、テストを記述する必要があるCryptoLibクラス（特定のHashLibラッパー）と、 Cryptor依存するHasherクラス（特定のHashLibラッパー）があります。 ただし、 Cryptor依然としてHashLibおよびSecTokensに依存しており、 Cryptorテストでは絶対にこれを必要としません。 代わりに、MockHasher.cppを準備します。
   Cryptor.cppコードはTestCryptor.cppに含まれているため、テストをビルドするには、TestCryptor.cppとMockHasher.cppのみをコンパイルして構成します。 これはこの記事のトピックではないため、ユニットテストライブラリに基づいた例を示しません。
   

ヘッダーファイルの包含の改訂

パブリック関数の代わりにコールバックとファンクター

 void fillDefaults(boost::function<void(std::string, std::string) > setDefault); 

 void fillDefaults(std::map<std::string, std::string, ci_less>& defaults); 

  void setDefault(std::string key, std::string value) { defaults[key] = value; } void fillDefaults() { platform::fillDefaults(boost::bind(&SettingsManager::Impl::setDefault, this, _1, _2)); } 

  void fillDefaults() { platform::fillDefaults(defaults); } 

 void Hasher::execute() { me->prepare(); me->update(SecTokens::one); me->update(SecTokens::two); me->finalize(); } 

 void Hasher::Impl::execute() { prepare(); update(SecTokens::one); update(SecTokens::two); finalize(); } void Hasher::execute() { me->execute(); } 

 ------- Hasher.h ------ #include <boost/functions.hpp> #include <PImpl.h> class Hasher { class Impl; //   class  struct    PImpl<Impl> me; //   public: Hasher(); boost::function<void()> execute; int getResults(); }; ------- Hasher.cpp ------ //……... Hasher::Hasher(): me(this), execute(boost::bind(&Hasher::Impl::execute, &*me)) { } int Hasher::getResults(){ return me->hash; } 

 void f(Hasher& h) { h.execute(); } 

 void f(Hasher& h, boost::asio::io_service& executor) { executor.post(h.execute); } 

 void f(Hasher& h, boost::asio::io_service& executor) { executor.post(boost::bind(&Hasher::execute, &h)); } 

 void myFunction(int, int); int main(int argc, char** argv) { boost::function<void(int, int)> functor1(boost::bind(myFunction, _1, _2)); boost::function<void(int)> functor2(boost::bind(functor1, 4, _1)); } 

 int main(int argc, char** argv) { Bindable<void(int, int)> functor1(boost::bind(myFunction, _1, _2)); Bindable<void(int)> functor2(functor1.bind(4, _1)); } 

 #ifndef BINDABLE_H #define BINDABLE_H #include <boost/bind.hpp> #include <boost/function.hpp> template<typename Signature> struct Bindable : public boost::function<Signature> { Bindable() { } template<typename T> Bindable(const T& fn) : boost::function<Signature>(fn) { } template<typename NewSignature, typename A1> Bindable<NewSignature> bind(const A1& a1) { return boost::bind(this, a1); } //    2  9  template<typename NewSignature, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> Bindable<NewSignature> bind(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10) { return boost::bind(*this, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } }; #endif /* BINDABLE_H */ 

コンストラクターオプションの隠蔽

1. 特定のインスタンスアプリケーションの構成パラメータ。 通常、これらはフラグ、ラ​​イン、メトリックなどの単純なタイプのパラメーターです。 ただし、これらのオプションを非表示にすることはできません。
   
2. 実装作業のグローバルスコープから取得したオブジェクト。 ここでそれらを非表示にします。
   

1. グローバルオブジェクトの取得はリソースを大量に消費する操作になる場合があるため、クラスフィールドにキャッシュすることをお勧めします
   
2. グローバルオブジェクトの取得は、たとえばglobalStorage.getProfiles().getProfile(“Default”)ような複雑な構文を持つことができます。 このような式を繰り返さないためには、オブジェクトまたはその参照をクラスフィールドに保存することをお勧めします
   
3. グローバルオブジェクトのコピーを変更する必要がある場合があります。 次に、コピーもクラスフィールドにある必要があります
   
4. デバッグ目的で使用済みオブジェクトを置き換える必要がある場合があります。 次に、クラスフィールドへの抽出と割り当ての呼び出しが1回だけ変更されます。
   

継承 工場とインターフェース

構成

ファイルの構造化、モジュール化、遅延初期化

 globalStorage.getHoster()->invoke(); 

 Profile pr=globalStorage.getProfiles()->getProfile(“Default”); 

IOCモジュールサービスの構成

 #include "InjectPtr.h" ///Helper interface class. Only for visual marking of needed methods. ///We can't do virtual template members namespace ioc { ///methods like http://tapestry.apache.org/defining-tapestry-ioc-services.html#DefiningTapestryIOCServices-ServiceBuilderMethods ///Like public @InjectService or @Inject annotation ///ServiceId Case http://tapestry.apache.org/defining-tapestry-ioc-services.html#DefiningTapestryIOCServices-ServiceIds template<typename T, size_t ID> InjectPtr<T> resolve(); ///Singleton or factory case template<typename T> InjectPtr<T> resolve(); }; 

 boost::shared_ptr<Hoster> hoster = globalStorage.getHoster(); 

 InjectPtr<Hoster> hoster = ioc::resolve<Hoster>(); 

 #ifndef INJECT_PTR_H #define INJECT_PTR_H #include <cassert> #include <cstddef> #include <boost/shared_ptr.hpp> #include <boost/scoped_ptr.hpp> #include <boost/make_shared.hpp> #include <boost/function.hpp> #include <boost/thread/mutex.hpp> ///Pointer to lazy instantiative object template<typename T> class InjectPtr { private: typedef boost::function<T*() > Factory; boost::shared_ptr< boost::shared_ptr<T> > px; boost::shared_ptr< boost::scoped_ptr<boost::mutex> > instantiateMutex; Factory factory; public: ///Main constructor. Take factory for future instantiate object InjectPtr(Factory factory) : px(boost::make_shared<boost::shared_ptr<T> >()) , instantiateMutex(boost::make_shared<boost::scoped_ptr<boost::mutex> >(new boost::mutex)) , factory(factory) { } InjectPtr() : px(boost::make_shared<boost::shared_ptr<T> >()) , instantiateMutex(boost::make_shared<boost::scoped_ptr<boost::mutex> >()) { } InjectPtr(boost::shared_ptr<T> pObject) : px(boost::make_shared<boost::shared_ptr<T> >(pObject)) { assert(*px != 0); } InjectPtr(InjectPtr const &orig) : px(orig.px) , instantiateMutex(orig.instantiateMutex) , factory(orig.factory) { } InjectPtr & operator=(InjectPtr const & orig) { px = orig.px; instantiateMutex = orig.instantiateMutex; factory = orig.factory; return *this; } virtual ~InjectPtr() { } T & operator*() { instantiate(); return **px; } T * operator->() { instantiate(); return &**px; } bool operator!() const { return !*px; } void operator==(InjectPtr const& that) const { return *px == that->px; } void operator!=(InjectPtr const& that) const { return *px != that->px; } boost::shared_ptr<T> sharedPtr() { instantiate(); return *px; } void instantiate() { if (!*px && factory) { { boost::mutex::scoped_lock lock(**instantiateMutex); if (!*px) { px->reset(factory()); } } instantiateMutex->reset(); } } Factory getFactory() const { return factory; } void setFactory(Factory factory) { if(!*px && !this->factory){ if(!*instantiateMutex) instantiateMutex->reset(new boost::mutex); this->factory = factory; } } }; template<class T, class U> InjectPtr<T> static_pointer_cast(InjectPtr<U> r) { return InjectPtr<T>(boost::static_pointer_cast<T>(r.sharedPtr())); } #endif /* INJECT_PTR_H */ 

 ------- IOCModule.h ------ //      #ifndef IOCMODULE_H #define IOCMODULE_H #include <boost/functional/factory.hpp> #include <boost/bind.hpp> #include <IOC.h> #endif /* IOCMODULE_H */ ------- IOCModule.cpp ------ #include "Hoster.h" #include "SomeService.h" #include "InjectPtr.h" #include <IOCModule.h> #include <IOC.h> //Module like http://tapestry.apache.org/tapestry-ioc-modules.html //Now only for: - To provide explicit code for building a service using namespace ioc; ///methods like http://tapestry.apache.org/defining-tapestry-ioc-services.html#DefiningTapestryIOCServices-ServiceBuilderMethods template<> InjectPtr<SomeService> resolve<SomeService>() { static InjectPtr<Hoster> result(boost::bind(boost::factory<SomeService*>())); return result; } ///Hoster takes SomeService in constructor template<> InjectPtr<Hoster> resolve<Hoster>() { static InjectPtr<Hoster> result(boost::bind(boost::factory<Hoster*>(), resolve<SomeService>())); return result; } 

 #include "Hoster.h" #include "SomeService.h" #include "InjectPtr.h" #include <IOCModule.h> #include <IOC.h> //Module like http://tapestry.apache.org/tapestry-ioc-modules.html //Now only for: - To provide explicit code for building a service using namespace ioc; struct CoreStorage { InjectPtr<SomeService> someService; InjectPtr<Hoster> hoster; }; static CoreStorage storage; ///methods like http://tapestry.apache.org/defining-tapestry-ioc-services.html#DefiningTapestryIOCServices-ServiceBuilderMethods template<> InjectPtr<SomeService> resolve<SomeService>() { if(!storage.someService.getFactory()) { storage.someService.setFactory(boost::bind(boost::factory<SomeService*>())); } return storage.someService; } ///Hoster takes SomeService in constructor template<> InjectPtr<Hoster> resolve<Hoster>() { if(!storage.hoster.getFactory()) { storage.hoster.setFactory(boost::bind(boost::factory<Hoster*>(), resolve<SomeService>())); } return storage.hoster; } 

IOCモジュールヘッダーファイル

• クラスインターフェイスのIOCレベルモジュールでのpublicの包含。
  
• IOCレベルの転送および単純な構造のモジュールでの完全な宣言。
  
• プリプロセッサ定義モジュールのIOCレベルでパブリック。
  

• プロジェクトのすべてのクラスの予備発表。
  
• IOCモジュールおよび単純な構造の内部転送の完全な宣言。
  
• IOCプリプロセッサ定義モジュールの内部。