c++ - sumar - ¿Puede static_assert comprobar si un tipo es un vector?

vectores y matrices en c++

Question

¿Puede static_assert comprobar si un tipo es un vector? IE, un int elevaría la aserción, mientras que un vector<int> no lo haría.
Estoy pensando en algo como:

static_assert(decltype(T) == std::vector, "Some error")

Answer 1

Sí. Considere la siguiente función meta:

#include <stdio.h>
#include <vector>
template <class N>
struct is_vector { static const int value = 0; };
template <class N, class A>
struct is_vector<std::vector<N, A> > { static const int value = 1; };
int main()
{
printf("is_vector<int>: %d/n", is_vector<int>::value);
printf("is_vector<vector<int> >: %d/n", is_vector<std::vector<int> >::value);
}

Simplemente usa eso como tu expresión en static_assert .

Answer 2

Una solución general. Dado un tipo y una plantilla, para comprobar si el tipo es una instancia de este último:

template<typename T, template<typename...> class Tmpl>
struct is_instance_of_a_given_class_template : std:: false_type {};
template<template<typename...> class Tmpl, typename ...Args>
struct is_instance_of_a_given_class_template< Tmpl<Args...>, Tmpl > : std:: true_type {};

Con esto, entonces lo siguiente será cierto:

is_instance_of_a_given_class_template< vector<int> , vector > :: value
type to check ~~~~~~~^ ^
template to check against ~~~~~~~~~~~~~~~~~~~~~~~/

y por lo tanto usarías:

static_assert( is_instance_of_a_given_class_template<T,std::vector>::value
, "Some error")

Nota: Si T es const , esto no funcionará directamente. Así que prueba algo como is_instance_of_a_given_class_template< std::decay_t<T> ,std::vector> lugar.

Answer 3

c ++ 0x:

static_assert(std::is_same<T, std::vector<int>>::value, "Some Error");

Answer 4

Si

template<typename T>
struct isVector
{
typedef char (&yes)[2];
template<typename U>
static yes check(std::vector<U>*);
static char check(...);
static const bool value = (sizeof(check((T*)0)) == sizeof(yes));
};

Uso:

isVector<vector<int> >::value;
isVector<int>::value;

Demo

Nota : Mi respuesta (complicada) tiene una limitación que se evalúa como true si T se hereda públicamente del vector<> . Podría resultar en un error del compilador si T tiene private herencia private / protected del vector<> . ¡Sólo manteniéndolo para el registro, para que esta manera no se use! :)