Tengo una plantilla de clase que se ve a continuación en mi

Counter.hpp

template <typename T1, size_t Count>
class Counter {
public:

    explicit Counter();
    ~Counter() = default;

    void inc(T1 t, uint64_t val);

    void dec(T1 t, uint64_t val);

private:

    uint16_t array[Count];
};

En el archivo Main.cpp

Puedo crear un objeto como este:

Counter< MetricCounter1Type, countOfMetricCounter1Type()> myCounter;

Y usar el objeto ... pero quiero poder hacer algo como una declaración de puntero y crear un objeto en el montón:

using counterp = std::shared_ptr <Counter>;

counterp myCounter1p = std::make_shared<Counter<T1type, n>>;
counterp myCounter2p = std::make_shared<Counter<T2type, m>>;

Entiendo su tipo de pregunta trivial, al ser nuevo en las plantillas y los consejos compartidos, hay demasiadas cosas para entender.

Entonces, básicamente, la pregunta es ¿puede crear un tipo de puntero compartido generalizado como el anterior e instanciar objetos?

1
ajax_velu 17 feb. 2018 a las 12:43

2 respuestas

La mejor respuesta

Counter es una plantilla de clase que toma dos parámetros , es decir, esta plantilla de clase está parametrizada por T1 y Count. Se genera un tipo de clase a partir de esta plantilla de clase proporcionando argumentos a esos parámetros.

Suponiendo que cualquiera de los argumentos que está pasando a la plantilla de clase es diferente entre sí, es decir: T1type es diferente de T2type o n es diferente de m, entonces Counter<T1type, n> y Counter<T2type, m> son tipos diferentes. Por tanto, los objetos generados por:

std::make_shared<Counter<T1type, n>>();
std::make_shared<Counter<T2type, m>>();

También tienen un tipo diferente. Por lo tanto, no puede definir un tipo común (sin plantilla) para almacenar cualquiera de los dos objetos.


Tenga en cuenta que su counterp alias de tipo no se compilará:

using counterp = std::shared_ptr<Counter>;

Porque Counter no recibió los dos argumentos de plantilla que requiere para convertirse en un tipo.

Sin embargo, puede definir una plantilla de alias :

template<typename T1, size_t Count>
using counterp = std::shared_ptr<Counter<T1, Count>>;

Y luego proporcione a couterp el argumento de dos plantillas que requiere:

counterp<T1type, n> myCounter1p = std::make_shared<Counter<T1type, n>>();
counterp<T2type, m> myCounter2p = std::make_shared<Counter<T2type, m>>();

Tenga en cuenta nuevamente que counterp<T1type, n> y counterp<T2type, m> pueden ser de diferentes tipos.

2
眠りネロク 17 feb. 2018 a las 10:18

Puedes usar auto

auto myCounter1p = std::make_shared<Counter<T1type, n>>;
auto myCounter2p = std::make_shared<Counter<T2type, m>>;

O plantilla de alias

template<typename T1, size_t Count>
using counterp = std::shared_ptr <Counter<T1, Count>>;
...
counterp<T1type, n> myCounter1p = std::make_shared<Counter<T1type, n>>();
counterp<T2type, m> myCounter2p = std::make_shared<Counter<T2type, m>>();
0
Yola 17 feb. 2018 a las 09:54