C++: магазин/запомнить тип шаблона класса

Question

Предположим, у нас есть класс, как следующее:

class AbstractContainer{ 
    ... 
}; 

template <typename T> 
class Container : public AbstractContainer { 
    T someFunction(); 
}; 

Теперь есть еще один класс, который имеет переменную-член, который должен хранить один из этих контейнеров. Однако тип шаблона не должен быть фиксированным. Поэтому вместо объявления переменной-члена типа Container оно объявляется как тип AbstractContainer*, поэтому указатель на базовый класс. Этот указатель должен иметь возможность хранить все типы классов Container, независимо от параметра шаблона.

class Interface{ 
public: 
    Interface(); 
    void doSth(); 
private: 
    AbstractContainer* container; 
}; 

Давайте предположим, что контейнер выполнен в конструкторе Interface класса, как это:

Interface::Interface(){ 
    if (/* some condition */) 
     this->container = new Container<int>(25); 
    } else { 
     this->container = new Container<float>(25); 
    } 
    //here I'd need to remember of which type container is: int or float 
} 

Так вот мне нужно бы хоть как-то магазин, какой тип мой контейнер (int или float) , Я знаю это в этот момент своей программы, и он полностью детерминирован. Мне нужно хранить его, потому что позже я мог бы отдать свой AbstractContainer* спиной к Container<int>* или Container<float>*, например, в другой функции:

void Interface::doSth(){ 
    //here I have to recall what the type was 
    if(/* type was int */) { 
     dynamic_cast<Container<int>&>(*(this->container)).someFunction(); 
    } else { 
     dynamic_cast<Container<float>&>(*(this->container)).someFunction(); 
    } 
} 

Я думал об использовании enum, который содержит значения для всех других поддерживаемых типы и сохранение типа в дополнительной переменной-члене этого типа перечисления. Тогда я должен был бы сделать оператор switch, который проверяет все различные возможности и выполняет правильный перевод. Однако я задавался вопросом, может ли быть более простой способ.

Что я хотел бы сделать, это сохранить тип, используемый в конструкторе Interface, а затем вызвать его в Interface::doSth.

EDIT: Я должен четко указать, что функция someFunction зависит от параметра шаблона T. Таким образом, это не вариант сделать его виртуальным.

Answer 1

Вы можете сделать

void Interface::doSth(){ 
    if (auto* c_int = dynamic_cast<Container<int>*>(this->container)) { 
     c_int->someFunction(); 
    } else if (auto* c_float = dynamic_cast<Container<float>*>(this->container)) { 
     c_float->someFunction(); 
    } 
} 

Но почему бы не двигаться someFunction() в базовый класс? и использовать виртуальный метод?

Answer 2

Хотя Jarod42's answer лучше, один из способов сделать это является использование typeid:

void doSth() 
{ 
    if (typeid(*container).hash_code() == typeid(Container<int>).hash_code()) 
    { 
     cout << "int" << endl; 
    } 
    else if (typeid(*container).hash_code() == typeid(Container<float>).hash_code()) 
    { 
     cout << "float" << endl; 
    } 
} 

Но вам нужно, по крайней мере виртуальной функции в базовом классе. Например, вы можете создать виртуальный деструктор.

Answer 3

Возможно, ваш ответ Curiously recurring template pattern.

template<class T, template<class> class U> 
class AbstractContainer 
{ 
    void interface() 
    { 
     static_cast<U<T> *>(this)->implementation(); 
    } 
}; 

template<class T> 
class Container : public AbstractContainer<T, Container> 
{ 
    void implementation() 
    { 

    } 
}; 

Answer 4

Другой вариант:

template <class T> 
T doSth(Container<T> &container){ 
    return container.someFunction(); //assume someFunction returns a T 
} 

Вам не нужен базовый класс, ни наследования, ни слепков.

Answer 5

class AbstactObject { 
public: 
    virtual ~AbstractObject() = 0; 

    virtual AbstractObject &doSomething() = 0; 
} 

template<class T> 
class Object : AbstactObject { 
public: 
    virtual ~Object(); 

    virtual Object<T> &doSomething(); 

    T &get(); 
private: 
    T t; 
} 

class AbstractContainer { 
public: 
    virtual ~AbstractObject() = 0; 

    virtual AbstractObject &doSomething(); 

private: 
    AbstractObject *obj; 
}; 

template<class T> 
class Container : AbstactContainer { 
public: 
    virtual ~Container(); 

    virtual Object<T> &doSomething() { 
    return obj->doSomething(); 
    }; 
} 

class Interface { 
public: 
    Interface(); 
    void doSth(); 
private: 
    AbstractContainer* container; 
}; 


Interface::Interface() { 
    if (/* some condition */) 
    container = new Container<int>(25); 
    } else { 
    container = new Container<float>(25); 
    } 
} 

void Interface::doSth() { 
    auto obj = container->doSomething(); 
    auto val = obj.get();  
} 

, когда вы хотите, чтобы получить значение Т

auto obj = container->doSomething(); 
auto val = obj.get(); 

Пожалуйста, проверьте: ковариантный тип возвращаемого https://en.wikipedia.org/wiki/Covariant_return_type