programacion - plantillas en c++

Compruebe si un tipo es la instanciación de una plantilla

Question

Quiero verificar si un tipo es una instanciación de una plantilla en particular durante la compilación.

Por ejemplo:

1. std::vector<int> es una instanciación de std::vector
2. std::array<int, 5> es una instanciación de std::array

Puedo hacer una prueba que funciona para el caso 1 pero no funciona para el caso 2.

#include <iostream>
#include <type_traits>
#include <string>
#include <vector>
#include <array>
#include <queue>
template<template<typename...> class, typename...>
struct is_instantiation : public std::false_type {};

template<template<typename...> class U, typename... T>
struct is_instantiation<U, U<T...>> : public std::true_type {};

int main() {
    using A = std::vector<int>;
    std::cout << is_instantiation<std::vector, A>::value << "/n";
    std::cout << is_instantiation<std::queue, A>::value << "/n";
    // std::cout << is_instantiation<std::array, A>::value << "/n";
}

¿Cómo hacer que funcione para ambos casos?

Intenté auto, pero no puedo hacer que funcione.

Ventajas del auto en parámetros de plantilla en C ++ 17

Answer 1

Spezialized std :: array size

La única manera que veo es hacer clases de Array especializadas con tamaños de arraigo predefinidos. Algo como esto:

#include <iostream>
#include <type_traits>
#include <string>
#include <vector>
#include <array>
#include <queue>
template<template<typename...> class, typename...>
struct is_instantiation : public std::false_type {};

template<template<typename...> class U, typename... T>
struct is_instantiation<U, U<T...>> : public std::true_type {};

template <class T> class My5Array {
    public:
    My5Array() { }
    private:
    std::array<T, 5> arr;
};

template <class T> class My10Array {
    public:
    My10Array() { }
    private:
    std::array<T, 10> arr;
};

int main() {
    using A = std::vector<int>;
    using B = My5Array<int>;
    std::cout << is_instantiation<std::vector, A>::value << "/n";
    std::cout << is_instantiation<std::queue, A>::value << "/n";
    std::cout << is_instantiation<My5Array, A>::value << "/n";
    std::cout << is_instantiation<My5Array, B>::value << "/n";
    std::cout << is_instantiation<My10Array, B>::value << "/n";
}

huellas dactilares

1
0
0
1
0

Por supuesto, hay desventajas:

• posiblemente desperdicio de memoria debido al tamaño de la matriz fija
• Se necesitan varias clases para los tamaños de matriz deseados
• Uso de tipo no estándar MyXArray
• obviamente, una instancia de My5Array no puede ser una instancia de My10Array al mismo tiempo (ver var B en el código anterior)

1ª alternativa posible: std :: dynarray

También encontré std :: dynarray, que podría funcionar en lugar de std :: array, pero creo que aún no está incluido en los últimos estándares de C ++. Tal vez valga la pena vigilarlo.

2da alternativa posible: solo dejalo caer

El contenedor estándar disponible es posiblemente suficiente para la mayoría de las aplicaciones.