C++、私はC++で書いていると私は純粋仮想関数に（実行時にのみ知られている）未知のタイプを渡したい

Question

仮想関数に未知のタイプを渡す：

DoSomethingが実装され

virtual void DoSomething(??? data); 

派生クラスの純粋仮想関数の

私はテンプレートを使用する計画が、それは仮想関数を回し、テンプレートが一緒に動作しないよう：Can a C++ class member function template be virtual?

私は関数に渡すすべてのクラスの基本クラスを使用しないようにしたい（objectのようなものをC＃で）。あなたがtype erasureを必要とし、事前

Answer 1

で

感謝。これの一例は汎用目的boost::any（およびC++ 17ではstd::any）です。

virtual void DoSomething(boost::any const& data); 

し、各サブクラスは、それが期待したデータを取得するために安全any_castを試みることができます。あなたが求める行動の範囲がより制約の場合

void DoSomething(boost::any const& data) { 
    auto p = any_cast<std::string>(&data); 

    if(p) { 
    // do something with the string pointer we extracted 
    } 
} 

はもちろん、独自の型消去の抽象化をロールアウトすることができます。あなたはブーストを使用しない場合はそのような

Answer 2

何か？：

class Foo 
{ 
    virtual ~Foo() = 0; 
}; 

template <typename T> 
class Bar : public Foo 
{ 
    T object; 
} 

... 

virtual void DoSomething(Foo* data) 
{ 
    Bar<int>* temp = dynamic_cast<Bar<int>*>(data); 
    if (temp) 
     std::count<<temp->object; 
} 

Answer 3

/任意のC++ 17、ベースクラスから「doSometing」関数のパラメータを導出検討し、それらへの動的なキャストを行います正しいクラスオブジェクト。この場合、実行時に有効なポインタがあることを確認できます。

class param{ 
public: 
    virtual ~param(){}; 
}; 

template <typename T> 
struct specificParam:param{ 
    specificParam(T p):param(p){} 
    T param; 
}; 


class Foo 
{ 
public: 
    virtual void doSomething(param* data) = 0; 
}; 

template <typename T> 
class Bar : public Foo 
{ 
public: 
    virtual void doSomething(param* data){ 
     specificParam<T> *p = dynamic_cast<specificParam<T> *>(data); 

     if (p != nullptr){ 
      std::cout<<"Bar got:" << p->param << "\n"; 
     } 
     else { 
      std::cout<<"Bar: parameter type error.\n"; 
     } 
    } 
}; 

int main(){ 
    Bar<char> obj1; 
    Bar<int> obj2; 
    Bar<float> obj3; 

    specificParam<char> t1('a'); 
    specificParam<int> t2(1); 
    specificParam<float> t3(2.2); 

    obj1.doSomething(&t1); //Bar got:a 
    obj2.doSomething(&t2); //Bar got:1 
    obj3.doSomething(&t3); //Bar got:2.2 

    // trying to access int object with float parameter 
    obj2.doSomething(&t3); //Bar: parameter type error. 
} 

最も簡単な（しかし安全ではない！）の方法は、Type-消去が唯一の可能性ではありませんvoid *型のポインタ+静的キャスト

class Foo 
{ 
public: 
    virtual void doSomething(void* data) = 0; 
}; 

template <typename T> 
class Bar:public Foo 
{ 
public: 
    virtual void doSomething(void* data){ 
     T* pData = static_cast<T*>(data); 
     std::cout<<"Bar1 got:" << *pData << "\n"; 
    } 
}; 

int main(){ 

    Bar<char> obj1; 
    Bar<int> obj2; 
    Bar<float> obj3; 

    char c = 'a'; 
    int i = 1; 
    float f = 2.2; 

    obj1.doSomething(&c); // Bar1 got:a 
    obj2.doSomething(&i); // Bar1 got:1 
    obj3.doSomething(&f); // Bar1 got:2.2 

    //obj2.doSomething(&c); // Very bad!!!  
} 

Answer 4

を使用することです。引数としてのstd ::バリアントを取ると、あなたが実装したいテンプレートコード含むラムダでそれを参照してください：

virtual void doSomething(std::variant<int,float/*,...*/> data) 
    { 
    visit([=](auto v){/*...*/;},data); 
    }