C++
戻り型共分散

algorithm Android C Language C# Language Design patterns Java Language GNU/Linux opencv Python Language Qt
サーチ…


備考

仮想メンバ関数mパラメータまたは戻り値の共分散は、型Tが派生クラスのmのオーバーライドでより具体的になる場所です。次に、型T 、 m提供するクラスと同じ方法（ co ）で特異性が変化する（ 分散 ）。 C ++は、生ポインタまたは生の参照である共変リターン型の言語サポートを提供します。共分散はpointeeまたはreferent型です。

関数の戻り値はC ++の唯一の純粋なout-argumentであり、共分散は純粋なout-argumentの型の安全なため、C ++のサポートは戻り型に限定されています。さもなければ、呼び出しコードは、受信コードが予期していないより具体的でない型のオブジェクトを供給することができます。 MITのバーバラ・リスコフ教授は、これと関連する分散型安全問題を調査しました。現在、Liskov Substitution Principle（ LSP）と呼ばれています。

共分散サポートは、本質的にダウンキャスティングと動的なタイプのチェックを避けるのに役立ちます。

スマートポインタはクラス型であるため、スマートポインタの結果に対して直接的に共分散のビルトインサポートを使用することはできませんが、生ポインタを生成する共変virtual関数の共分散非virtualスマートポインタ結果ラッパー関数を定義できます。

1.共変リターンのない基本例は、それが望ましい理由を示しています。

// 1. Base example not using language support for covariance, dynamic type checking.

class Top
{
public:
    virtual Top* clone() const = 0;
    virtual ~Top() = default;       // Necessary for `delete` via Top*.
};

class D : public Top
{

public:
    Top* clone() const override
    { return new D( *this ); }
};

class DD : public D
{
private:
    int answer_ = 42;

public:
    int answer() const
    { return answer_;}

    Top* clone() const override
    { return new DD( *this ); }
};

#include <assert.h>
#include <iostream>
#include <typeinfo>
using namespace std;

int main()
{
    cout << boolalpha;

    DD* p1 = new DD();
    Top* p2 = p1->clone();
    bool const  correct_dynamic_type = (typeid( *p2 ) == typeid( DD ));
    cout << correct_dynamic_type << endl;               // "true"

    assert( correct_dynamic_type ); // This is essentially dynamic type checking. :(
    auto p2_most_derived = static_cast<DD*>( p2 );
    cout << p2_most_derived->answer() << endl;          // "42"
    delete p2;
    delete p1;
}

2.基本例の共変結果バージョン、静的型検査。

// 2. Covariant result version of the base example, static type checking.

class Top
{
public:
    virtual Top* clone() const = 0;
    virtual ~Top() = default;       // Necessary for `delete` via Top*.
};

class D : public Top
{
public:
    D* /* ← Covariant return */ clone() const override
    { return new D( *this ); }
};

class DD : public D
{
private:
    int answer_ = 42;

public:
    int answer() const
    { return answer_;}

    DD* /* ← Covariant return */ clone() const override
    { return new DD( *this ); }
};

#include <iostream>
using namespace std;

int main()
{
    DD* p1 = new DD();
    DD* p2 = p1->clone();
    // Correct dynamic type DD for *p2 is guaranteed by the static type checking.

    cout << p2->answer() << endl;          // "42"
    delete p2;
    delete p1;
}

3.共変のスマートポインタ結果（自動クリーンアップ）。

// 3. Covariant smart pointer result (automated cleanup).

#include <memory>
using std::unique_ptr;

template< class Type >
auto up( Type* p ) { return unique_ptr<Type>( p ); }

class Top
{
private:
    virtual Top* virtual_clone() const = 0;

public:
    unique_ptr<Top> clone() const
    { return up( virtual_clone() ); }

    virtual ~Top() = default;       // Necessary for `delete` via Top*.
};

class D : public Top
{
private:
    D* /* ← Covariant return */ virtual_clone() const override
    { return new D( *this ); }

public:
    unique_ptr<D> /* ← Apparent covariant return */ clone() const
    { return up( virtual_clone() ); }
};

class DD : public D
{
private:
    int answer_ = 42;

    DD* /* ← Covariant return */ virtual_clone() const override
    { return new DD( *this ); }

public:
    int answer() const
    { return answer_;}

    unique_ptr<DD> /* ← Apparent covariant return */ clone() const
    { return up( virtual_clone() ); }
};

#include <iostream>
using namespace std;

int main()
{
    auto  p1 = unique_ptr<DD>(new DD());
    auto  p2 = p1->clone();
    // Correct dynamic type DD for *p2 is guaranteed by the static type checking.

    cout << p2->answer() << endl;          // "42"
    // Cleanup is automated via unique_ptr.
 }


Modified text is an extract of the original Stack Overflow Documentation
ライセンスを受けた CC BY-SA 3.0
所属していない Stack Overflow