👨‍👨‍👧‍👦 👩🏾‍🏫 🔆 （いいえ）危険なコピーの削除 🌲 🐋 🚻

今から1年間、私は暇なときにMavenとSpring for C ++の混合物を飲んでいます。その重要な部分は、スマートポインターの自己記述システムです。なぜこれがすべて必要なのかは別の問題です。この記事では、一見便利なC ++の機能の1つがどのように標準の常識を疑わせたかについて簡単に説明したいと思います。

編集者：
habrasocietyとStandardに謝ります。記事が投稿された翌日、私は自分の考えに大きな誤りがあることに気づきました。すぐに記事の終わりを読む方が良いでしょう...そして、はい、 コピーの省略 、それは結局、記事は間接的に関連しているだけです。

1.問題

プロジェクトのスマートポインターは昨年の夏に作成されました。

選択されたポインターコードと説明

template<typename T_Type, typename T_Holding, typename T_Access> class DReference { . . . IDSharedMemoryHolder *_holder; void retain(IDSharedMemoryHolder *inHolder) { . . . } void release() { . . . } . . . ~DReference() { release(); } template<typename T_OtherType, typename T_OtherHolding, typename T_OtherAccess> DReference( const DReference<T_OtherType, T_OtherHolding, T_OtherAccess> & inLReference) : _holder(NULL), _holding(), _access() { retain(inLReference._holder); } . . . }

オブジェクトストレージのロジックとオブジェクトへのアクセスのロジックを実装する戦略構造があります。それらの型をテンプレート引数としてスマートポインタークラスに渡します。 IDSharedMemoryHolder-オブジェクトメモリアクセスインターフェイス。 retain（）関数の呼び出しにより、スマートポインターがオブジェクトの所有を開始します（強参照の場合は++ ref_count ）。 release（）を呼び出すことにより、ポインターはオブジェクトを解放します（強参照--ref_countおよびref_count == 0の場合はオブジェクトを削除するため）。

参照解除に関連するものを意図的に省略し、オペレーター呼び出しでここに保持します。 これらの点について説明した問題は関係ありません。

スマートポインターの動作は、一連の簡単なテストによってテストされました。「ポインターに関連付けられたオブジェクトを作成し、ポインターにポインターを割り当てて、reatin / releaseが正しく動作するように見えました。」テスト（今では非常に奇妙に思えます）に合格しました。 1月上旬にコードをスマートポインターに変換しました。

問題は、スマートポインターによって制御されるメモリが事前に削除されていることが発見された1か月前に始まりました。

具体例を挙げて説明します。

 DStrongReference<DPlugIn> DPlugInManager::createPlugIn( const DPlugInDescriptor &inDescriptor) { . . . DStrongReference<DPlugIn> thePlugInReference = internalCreatePlugIn(inDescriptor); . . . return thePlugInReference; } ... DStrongReference<DPlugIn> DPlugInManager::internalCreatePlugIn( const DPlugInDescriptor &inDescriptor) { for (IDPlugInStorage *thePlugInStorage : _storages) { if (thePlugInStorage->getPlugInStatus(inDescriptor)) return thePlugInStorage->createPlugIn(inDescriptor); } return DStrongReference<DPlugIn>(); } ... class DPlugInStorageImpl : public IDPlugInStorage { public: virtual ~DPlugInStorageImpl() { } virtual DStrongReference<DPlugIn> createPlugIn( const DPlugInDescriptor &inDescriptor); };

DPlugInStorageImpl :: createPlugIn（...）メソッドが呼び出されると、オブジェクトがDStrongReferenceを介して返され 、その後、このスマートポインターがDPlugInManager :: internalCreatePlugIn（...）メソッドを介して呼び出しコンテキストに返されます-DPlugInManager :: createPlugIn（...）メソッド。

そのため、スマートポインターがDPlugInManager :: createPlugIn（...） メソッドに返された場合、 PlugInReferenceはリモートオブジェクトを指していました。明らかに、保持/解放の呼び出しの数が間違っていました。 Eclipseのデバッガーで多くの神経を費やして（ところで-それはひどいです）、私は吐き出し、簡単な方法で問題を解決しました-私はログを使用しました。私は出力をretainメソッドとreleaseメソッドの呼び出しに置き、プログラムを起動しました...何を期待していましたか？ここに何かがあります（擬似コード）：

DPlugInStorageImpl :: createPlugIn（...）=> RETAIN
DPlugInManager :: internalCreatePlugIn（...）、createPlugIn => RETAINを返します
DPlugInStorageImpl :: createPlugIn（...）、〜DStrongReference（）=> RELEASE
DPlugInManager :: createPlugIn（...）、thePlugInReference = internalCreatePlugIn（...）=> RETAIN
DPlugInManager :: internalCreatePlugIn（...）、〜DStrongReference（）=> RELEASE

合計： thePlugInReferenceのref_count = 1 すべてを明確にする必要がありました。

私が実際に見たのは、このように（0_0）し、あらゆる種類のクリーンアップ、再コンパイル、最適化設定の再確認、stdoutのフラッシュの試行などを行うために次の~~1時間半を費やし~~ました。

DPlugInStorageImpl :: createPlugIn（...）=> RETAIN
DPlugInManager :: internalCreatePlugIn（...）、〜DStrongReference（）=> RELEASE

バトルコードの問題を解決するために必死で、すでに非常に間違った何かを疑っていたので、小さなテストプロジェクトを作成しました。

2.テスト

テストコード：

 #include <iostream> #include <stdio.h> class TestClass { private: int _state; public: TestClass(int inState) : _state(inState) { std::cout << "State based: " << inState << std::endl; } TestClass() : _state(1) { std::cout << "Default" << std::endl; } TestClass(const TestClass &inObject0) : _state(2) { std::cout << "Const Copy" << std::endl; } TestClass(TestClass &inObject0) : _state(3) { std::cout << "Copy" << std::endl; } TestClass(const TestClass &&inObject0) : _state(4) { std::cout << "Const Move" << std::endl; } TestClass(TestClass &&inObject0) : _state(5) { std::cout << "Move" << std::endl; } ~TestClass() { std::cout << "Destroy" << std::endl; } void call() { std::cout << "Call " << _state << std::endl; } }; /////////////////////////////////////////////////////////////////////////////// int main() { TestClass theTestObject = TestClass(); theTestObject.call(); fflush(stdout); return 0; }

期待される結果：

デフォルト
定数コピー
コール1
破壊する

実際の結果：

デフォルト
コール1
破壊する

つまり、コピーコンストラクターは呼び出されませんでした。そしてそのときだけ、私はすぐにやるべきことをしました。 Googleでcopy_elisionについて調べました。

3.恐ろしい真実

一言で言えば-C ++コンパイラは、警告やフラグなしでコピーコンストラクターの呼び出しを無視し、代わりに、たとえば、オブジェクトの完全な状態を直接コピーできます。同時に、このようなコピーのプロセスで、 ~~ハッキングなし~~でロジックを実行することはまったく不可能です。ここで、Notesセクションでは、「 コピー除外は、観察可能な副作用を変更できる唯一の許可された最適化形式です 。」

最適化はもちろん優れています...しかし、コピーコンストラクターでロジックを実行する必要がある場合はどうでしょうか。たとえば、スマートポインターの場合そして、コピーコンストラクタの本体にロジックがない場合に-o1でそのような最適化を許可することが不可能だった理由は、私にはまだ何が不明ですか？..今まで、これは私には明らかではありません。

4.決定

クラスオブジェクトの構築時にコンパイラにロジックを実行させる2つの方法を見つけました。

1）コンパイルフラグを通じて。悪い方法。コンパイラ依存。たとえば、g ++の場合、 -fno-elide-constructorsフラグを設定する必要があり、これはプロジェクト全体に影響する（ひどい）か、適切なプッシュ/ポップの場所でコンパイラフラグ設定を使用する必要があり、コードが乱雑になり、読みにくくなります（特にこれは各コンパイラで実行する必要があることを考慮してください）。

2）明示的なキーワードを通じて。これも悪い方法ですが、私の意見では、これはコンパイルフラグを使用するよりも優れています。
明示的な指定子は、型キャスト構文によるクラスのインスタンスの暗黙的な作成を禁止するために必要です。つまり、 MyInt theMyInt = 1の代わりにMyInt theMyInt = MyInt（1）を記述する必要がありました。
この単語をコピーコンストラクターの前に置くと、暗黙的な型変換がかなりおかしくなります-その型へのキャストが禁止されます。

したがって、たとえば、次の

コード

 #include <iostream> #include <stdio.h> class TestClass { private: int _state; public: TestClass(int inState) : _state(inState) { std::cout << "State based: " << inState << std::endl; } TestClass() : _state(1) { std::cout << "Default" << std::endl; } explicit TestClass(const TestClass &inObject0) : _state(2) { std::cout << "Const Copy" << std::endl; } } ~TestClass() { std::cout << "Destroy" << std::endl; } void call() { std::cout << "Call " << _state << std::endl; } }; /////////////////////////////////////////////////////////////////////////////// int main() { TestClass theTestObject = TestClass(); theTestObject.call(); fflush(stdout); return 0; }

私（g ++ 4.6.1）はエラーを引き起こしました：

エラー： 'TestClass :: TestClass（TestClass）'の呼び出しに一致する関数がありません

さらに面白いのは、次のようなC ++構文のためです：TestClass theTestObject（TestClass（））も機能しません。関数ポインターの宣言と見なされ、エラーが発生するためです。

エラー： 'theTestObject'のメンバー 'call'の要求。これは非クラス型 'TestClass（TestClass（*）（））'です。

したがって、コンパイラに強制的にコピーコンストラクターを実行させる代わりに、このコンストラクターの呼び出しを禁止します。

幸いなことに、そのような解決策が思いつきました。実際、コピーコンストラクターを無効にすることで、コンパイラーに、現在のクラスと同じテンプレート引数を持つテンプレートコンストラクター仕様を使用するように強制しました。つまり、「オブジェクトをその型にキャストする」のではなく、「同じテンプレート引数を持つ型にキャストする」ので、別のメソッドを生成しますが、コピーコンストラクターを置き換えます。

それが起こった

 template<typename T_Type, typename T_Holding, typename T_Access> class DReference { . . . IDSharedMemoryHolder *_holder; void retain(IDSharedMemoryHolder *inHolder) { . . . } void release() { . . . } . . . ~DReference() { release(); } //NB: Workaround for Copy elision explicit DReference( const OwnType &inLReference) : _holder(NULL), _holding(), _access() { // Call for some magic cases retain(inLReference._holder); } template<typename T_OtherType, typename T_OtherHolding, typename T_OtherAccess> DReference( const DReference<T_OtherType, T_OtherHolding, T_OtherAccess> & inLReference) : _holder(NULL), _holding(), _access() { retain(inLReference._holder); } . . . }

テスト例では、この松葉杖の類似物は次のようになります。

テストコードと簡単な説明

 #include <iostream> #include <stdio.h> class TestClass { private: int _state; public: TestClass(int inState) : _state(inState) { std::cout << "State based: " << inState << std::endl; } TestClass() : _state(1) { std::cout << "Default" << std::endl; } explicit TestClass(const TestClass &inObject0) : _state(2) { std::cout << "Const Copy" << std::endl; } template<typename T> TestClass(const T &inObject0) : _state(13) { std::cout << "Template Copy" << std::endl; } ~TestClass() { std::cout << "Destroy" << std::endl; } void call() { std::cout << "Call " << _state << std::endl; } }; /////////////////////////////////////////////////////////////////////////////// int main() { TestClass theTestObject = TestClass(); theTestObject.call(); fflush(stdout); return 0; }

同じチップ。テンプレートの仕様、コピーコンストラクターの置き換え...間違ったテンプレートを使用したため、これは悪い解決策であることがわかります。誰もが最高の方法を知っている場合-退会します。

結論の代わりに

C ++とabout-C ++を3年間使用していた数人の友人にコピーの省略について話したとき、彼ら~~もこのように（0_0）~~しました。一方、この最適化により、プログラマーの観点からは奇妙な動作が発生し、C ++アプリケーションの作成時にエラーが発生する可能性があります。

この記事が誰かにとって有用であり、誰かの時間を節約することを願っています。

PS：気づいた見落としについて書いてください-編集します。

編集者：

コメントは正しいです、私は一般的に問題を誤解しました。記事の論理エラーを特定してくれた、特にMonnorochに感謝します。

次のテストコードを記述することで、正しい出力が得られました。

コピーコンストラクターと出力を備えたテンプレートクラス

 /////////////////////////////////////////////////////////////////////////////// #include <iostream> /////////////////////////////////////////////////////////////////////////////// template<typename T_Type> class TestTemplateClass { private: typedef TestTemplateClass<T_Type> OwnType; T_Type _state; public: TestTemplateClass() : _state() { std::cout << "Default constructor" << std::endl; } TestTemplateClass(int inState) : _state(inState) { std::cout << "State constructor" << std::endl; } TestTemplateClass(const OwnType &inValue) { std::cout << "Copy constructor" << std::endl; } template<typename T_OtherType> TestTemplateClass(const TestTemplateClass<T_OtherType> &inValue) { std::cout << "Template-copy constructor" << std::endl; } template<typename T_OtherType> void operator = (const TestTemplateClass<T_OtherType> &inValue) { std::cout << "Operator" << std::endl; } ~TestTemplateClass() { std::cout << "Destructor" << std::endl; } }; /////////////////////////////////////////////////////////////////////////////// TestTemplateClass<int> createFunction() { return TestTemplateClass<int>(); } /////////////////////////////////////////////////////////////////////////////// int main() { TestTemplateClass<int> theReference = createFunction(); std::cout << "Finished" << std::endl; return 0; } ///////////////////////////////////////////////////////////////////////////////

出力：

 Default constructor Copy constructor Destructor Copy constructor Destructor Finished Destructor

つまり、問題はコピーの省略ではなく、ハックは必要ありませんでした。

本当の間違いは当たり前のことでした。今、私はすべてをチェックすることなく記事を書くことを約束したことを恥じています。
実際、スマートポインターは3つのテンプレート引数を受け入れます。

 template<typename T_Type, typename T_Holding, typename T_Access> class DReference { . . .

T_Typeは、スマートポインターシステムによって制御されるオブジェクトタイプです。
T_Holding-メモリ所有権戦略。
T_Accessはメモリアクセス戦略です。

このスマートポインターの実装により、動作を柔軟にカスタマイズできますが、同時に使用が面倒になります（特に戦略はテンプレートクラスであるため）。

強力なポインターを宣言する例：

 DReference<MyType, DReferenceStrongHolding<MyType>, DReferenceCachingAccess< MyType > > theReference;

コードが乱雑になるのを避けるために、C ++ 11標準の機能-template-aliasを使用したいと考えました。しかし、判明したように、g ++ 4.6.1 はそれらをサポートしていません。もちろん、環境をセットアップすることをめちゃくちゃにしてホームペットプロジェクトを書くとき、あなたは面倒すぎるので、別の回避策を行い、継承を使用して引数を取り除くことにしました。

 template<typename T_Type> class DStrongReference : public DReference< T_Type, DReferenceStrongHolding<MyType>, DReferenceCachingAccess< MyType > > { . . .

この場合、コンストラクターが継承されないため、 DStrongReferenceの一連のコンストラクターを定義して、 DReference基本クラスの対応するコンストラクターを呼び出す必要がありました。そして、もちろん、私はコピーコンストラクターを見逃しました...一般に、これらすべての冒険の後に私が与えることができる唯一のアドバイスは、私が入ったそのような愚かな状況に入らないようにテンプレートを使用するとき、非常に注意することです。

PS：これは、テンプレートエイリアスを置き換える継承を使用するテストです（ ToSHiCにこれを出力に渡す良いアドバイスをありがとう）。

テストシミュレーションテンプレートエイリアス

 /////////////////////////////////////////////////////////////////////////////// #include <iostream> /////////////////////////////////////////////////////////////////////////////// template<typename T_Type, typename T_Strategy> class TestTemplateClass { private: typedef TestTemplateClass<T_Type, T_Strategy> OwnType; T_Type _state; T_Strategy _strategy; public: TestTemplateClass() : _state(), _strategy() { std::cout << "Default constructor: " << this << std::endl; } TestTemplateClass(int inState) : _state(inState), _strategy() { std::cout << "State constructor: " << this << std::endl; } TestTemplateClass(const OwnType &inValue) : _state(), _strategy() { std::cout << "Copy constructor: " << this << " from " << &inValue << std::endl; } template<typename T_OtherType, typename T_OtherStrategy> TestTemplateClass( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) : _state(), _strategy() { std::cout << "Template-copy constructor: " << this << std::endl; } void operator = (const OwnType &inValue) { std::cout << "Assigning: " << this << " from " << inValue << std::endl; } template<typename T_OtherType, typename T_OtherStrategy> void operator = ( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) { std::cout << "Assigning: " << this << " from " << &inValue << std::endl; } ~TestTemplateClass() { std::cout << "Destructor: " << this << std::endl; } }; /////////////////////////////////////////////////////////////////////////////// template<typename T_Type> class TestTemplateClassIntStrategy : public TestTemplateClass<T_Type, int> { private: //- Types typedef TestTemplateClassIntStrategy<T_Type> OwnType; typedef TestTemplateClass<T_Type, int> ParentType; public: TestTemplateClassIntStrategy() : ParentType() { } TestTemplateClassIntStrategy(int inState) : ParentType(inState) { } TestTemplateClassIntStrategy(const OwnType &inValue) : ParentType(inValue) { } template<typename T_OtherType, typename T_OtherStrategy> TestTemplateClassIntStrategy( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) : ParentType(inValue) { } //- Operators void operator = (const OwnType &inValue) { ParentType::operator =(inValue); } template<typename T_OtherType, typename T_OtherStrategy> void operator = ( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) { ParentType::operator =(inValue); } }; /////////////////////////////////////////////////////////////////////////////// TestTemplateClassIntStrategy<int> createFunction() { return TestTemplateClassIntStrategy<int>(); } int main() { TestTemplateClassIntStrategy<int> theReference = createFunction(); std::cout << "Finished" << std::endl; return 0; }

出力：

 Default constructor: 0x28fed8 Copy constructor: 0x28ff08 from 0x28fed8 Destructor: 0x28fed8 Copy constructor: 0x28ff00 from 0x28ff08 Destructor: 0x28ff08 Finished Destructor: 0x28ff00

割り当てステートメントの呼び出し

 . . . int main() { TestTemplateClassIntStrategy<int> theReference; theReference = createFunction(); std::cout << "Finished" << std::endl; return 0; }

 Default constructor: 0x28ff00 Default constructor: 0x28fed8 Copy constructor: 0x28ff08 from 0x28fed8 Destructor: 0x28fed8 Assigning: 0x28ff00 from 0x28ff08 Destructor: 0x28ff08 Finished Destructor: 0x28ff00

この方法の重要なマイナス点：この方法でストロングポインターとウィークポインターを定義すると、それらは完全に異なるタイプになり（1つのテンプレートクラスに関連付けられない）、初期化時にそれらを直接割り当てることはできません。

<編集番号2>

再び急いで何かを確認しました。私は夜にそれを得た。結局のところ...これらのクラスには、共通のテンプレート祖先が1つあります。
つまり、任意のDReferenceのテンプレートコンストラクターが後続（テンプレートエイリアスを模倣する）で記述されている場合、次のコードではすべて問題ありません。

コード

 DStrongReference<Type> theStrongReference; //           .  : // // template<typename Type, typename Owning, typename Holding> // DWeakReference::DWeakReference(const DReference<Type, Owning, Holding> &ref) : Parent(ref) { } // //       ,  DStrongReference  DReference. // DWeakReference<Type> theWeakReference = theStrongReference;

このように構成された2つのクラスのテストコード：

継承によるテンプレートエイリアス：2つの擬似エイリアス

 //============================================================================ // Name : demiurg_application_example.cpp // Author : // Version : // Copyright : Your copyright notice // Description : Hello World in C++, Ansi-style //============================================================================ /////////////////////////////////////////////////////////////////////////////// #include <iostream> /////////////////////////////////////////////////////////////////////////////// template<typename T_Type, typename T_Strategy> class TestTemplateClass { private: typedef TestTemplateClass<T_Type, T_Strategy> OwnType; T_Type _state; T_Strategy _strategy; public: TestTemplateClass() : _state(), _strategy() { std::cout << "Default constructor: " << this << std::endl; } TestTemplateClass(int inState) : _state(inState), _strategy() { std::cout << "State constructor: " << this << std::endl; } TestTemplateClass(const OwnType &inValue) : _state(), _strategy() { std::cout << "Copy constructor: " << this << " from " << &inValue << std::endl; } template<typename T_OtherType, typename T_OtherStrategy> TestTemplateClass( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) : _state(), _strategy() { std::cout << "Template-copy constructor: " << this << std::endl; } void operator = (const OwnType &inValue) { std::cout << "Assigning: " << this << " from " << &inValue << std::endl; } template<typename T_OtherType, typename T_OtherStrategy> void operator = ( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) { std::cout << "Assigning: " << this << " from " << &inValue << std::endl; } ~TestTemplateClass() { std::cout << "Destructor: " << this << std::endl; } }; /////////////////////////////////////////////////////////////////////////////// //- Integer strategy template<typename T_Type> class TestTemplateClassIntStrategy : public TestTemplateClass<T_Type, int> { private: //- Types typedef TestTemplateClassIntStrategy<T_Type> OwnType; typedef TestTemplateClass<T_Type, int> ParentType; public: TestTemplateClassIntStrategy() : ParentType() { } TestTemplateClassIntStrategy(int inState) : ParentType(inState) { } TestTemplateClassIntStrategy(const OwnType &inValue) : ParentType(inValue) { } template<typename T_OtherType, typename T_OtherStrategy> TestTemplateClassIntStrategy( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) : ParentType(inValue) { } //- Operators void operator = (const OwnType &inValue) { ParentType::operator =(inValue); } template<typename T_OtherType, typename T_OtherStrategy> void operator = ( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) { ParentType::operator =(inValue); } }; //- Boolean strategy template<typename T_Type> class TestTemplateClassBoolStrategy : public TestTemplateClass<T_Type, bool> { private: //- Types typedef TestTemplateClassBoolStrategy<T_Type> OwnType; typedef TestTemplateClass<T_Type, bool> ParentType; public: TestTemplateClassBoolStrategy() : ParentType() { } TestTemplateClassBoolStrategy(int inState) : ParentType(inState) { } TestTemplateClassBoolStrategy(const OwnType &inValue) : ParentType(inValue) { } template<typename T_OtherType, typename T_OtherStrategy> TestTemplateClassBoolStrategy( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) : ParentType(inValue) { } //- Operators void operator = (const OwnType &inValue) { ParentType::operator =(inValue); } template<typename T_OtherType, typename T_OtherStrategy> void operator = ( const TestTemplateClass<T_OtherType, T_OtherStrategy> &inValue) { ParentType::operator =(inValue); } }; /////////////////////////////////////////////////////////////////////////////// TestTemplateClassBoolStrategy<int> createFunction() { return TestTemplateClassBoolStrategy<int>(); } int main() { TestTemplateClassIntStrategy<int> theReference; theReference = createFunction(); std::cout << "Finished" << std::endl; return 0; }

出力：

 Default constructor: 0x28fed8 Copy constructor: 0x28ff08 from 0x28fed8 Destructor: 0x28fed8 Copy constructor: 0x28ff00 from 0x28ff08 Destructor: 0x28ff08 Finished Destructor: 0x28ff00

一般に、すべてが機能します

</編集番号2>

1eqinfinityのおかげで、スペルエラーを指摘してくれたTorvald3d 。