C++ qua loại chưa biết đến một hàm ảo

Question

Tôi đang viết bằng C++ và tôi muốn vượt qua một loại vô danh (chỉ được biết đến trong thời gian chạy) để một hàm ảo thuần túy:

virtual void DoSomething(??? data); 

nơi DoSomething là một thực hiện của một hàm ảo thuần túy trong một lớp dẫn xuất.

Tôi dự định sẽ sử dụng các mẫu nhưng vì nó biến ra chức năng ảo và các mẫu không có tác dụng với nhau: Can a C++ class member function template be virtual?

Tôi muốn tránh sử dụng một lớp cơ sở cho tất cả các lớp tôi vượt qua để chức năng (giống như object trong C#).

Cảm ơn trước

Answer 1

Bạn cần type erasure. Một ví dụ về điều này là mục đích chung boost::any (và std::any trong C++ 17).

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

Và sau đó mỗi sub-class có thể cố gắng các an toànany_cast để có được các dữ liệu mà nó mong đợi.

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

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

Tất nhiên, bạn có thể xóa bỏ loại trừu tượng của mình nếu phạm vi hành vi bạn tìm kiếm bị hạn chế hơn.

Answer 2

một cái gì đó như thế ?:

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

Nếu bạn không muốn sử dụng tăng/C++ 17 nào, hãy xem xét thu được những tham số của chức năng 'doSometing' từ một lớp cơ sở, và làm diễn viên năng động để đối tượng lớp phù hợp. Trong trường hợp này, bạn có thể kiểm tra trong thời gian chạy mà bạn có một con trỏ hợp lệ.

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. 
} 

Cách đơn giản nhất (nhưng không an toàn!) Sẽ được sử dụng con trỏ void * + cast tĩnh

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

Type-tẩy xoá không phải là khả năng duy nhất.

Bạn có thể quan tâm để sử dụng mẫu người truy cập: lấy như là đối số một std :: biến và ghé thăm nó với một lambda chứa mã mẫu mà bạn muốn thực hiện:

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