c++ - tag - cómo consultar si(T== int) con la clase de plantilla

video question tags

Question

Cuando estoy escribiendo una función en una clase de plantilla, ¿cómo puedo averiguar qué es mi T?

p.ej

template <typename T>
ostream& operator << (ostream &out,Vector<T>& vec)
{
if (typename T == int)
}

¿Cómo puedo escribir la declaración if anterior para que funcione?

Answer 1

Algo como esto:

template< class T >
struct TypeIsInt
{
    static const bool value = false;
};

template<>
struct TypeIsInt< int >
{
    static const bool value = true;
};

template <typename T>
ostream& operator << (ostream &out,Vector<T>& vec)
{
    if (TypeIsInt< T >::value)
    // ...
}

Answer 2

De esta manera.

ostream & operator << (ostream &out, Vector<int> const & vec)
{
    // ...
}

El compilador elegirá esta función sobre la plantilla de función si pasa Vector<int> .

Edición: Encontré este artículo , que intenta explicar por qué preferir la sobrecarga a la especialización de plantillas.

Answer 3

Definirlo explícitamente, por ejemplo:

template <>
ostream& operator << (ostream &out,Vector<int>& vec)
{
}

Answer 4

Desde C ++ 11 tenemos std::is_same :

if (std::is_same<T, int>::value) ...

Se implementa de forma similar al rasgo sugerido TypeIsInt sugiere en las otras respuestas, pero con dos tipos para comparar.

Answer 5

La forma más fácil es proporcionar una especialización de plantillas:

#include <iostream>
#include <vector>
using namespace std;

template <typename T> struct A {
};

template <typename T > 
ostream & operator <<( ostream & os, A<T> & a  ) {
    return os << "not an int" << endl;
}


template <> 
ostream & operator <<( ostream & os, A<int> & a  ) {
    return os << "an int" << endl;
}

int main() {
    A <double> ad;
    cout << ad;
    A <int> ai;
    cout << ai;
}

Answer 6

La solución más simple, más general: simplemente escriba una sobrecarga simple de la función:

ostream& operator << (ostream &out,Vector<int>& vec)
{
// Your int-specific implementation goes here
}

Esto supone que las versiones int y non- int no tienen mucho código en común, ya que tiene que escribir dos implementaciones separadas.

Si desea usar una implementación común de la función, con solo una instrucción if que difiera, use la implementación de Charles Bailey:

template< class T >
struct TypeIsInt
{
    static const bool value = false;
};

template<>
struct TypeIsInt< int >
{
    static const bool value = true;
};

template <typename T>
ostream& operator << (ostream &out,Vector<T>& vec)
{
    if (TypeIsInt< T >::value) {
      // your int-specific code here
    }
}

En general, no use typeid si no lo necesita.

Answer 7

Las plantillas de C ++ no funcionan de esta manera. La idea general de las plantillas es expresar algunas cosas, lo cual es común para muchos tipos diferentes. Y en tu caso deberías utilizar la especialización de plantillas.

template<class T> ostream& operator<< (ostream& out, const vector<T>& v)
{
    // your general code for all type
}
// specialized template
template<> ostream& operator<< <int>(ostream& out, const vector<int>& vec)
{
    // your specific to iny type code goes here
}

Luego, el compilador de C ++ llamará a esta función cuando use el tipo int y la implementación general para cualquier otro tipo

std::vector<int> f(5, 5);
std::cout << f;

Answer 8

TypeID nunca es una buena idea. Se basa en RTTI. Por cierto, aquí está tu respuesta: http://www.parashift.com/c++-faq-lite/templates.html#faq-35.7

Answer 9

Una solución más es:

if(std::is_same<T, int>::value)
     //It is int
if (std::is_same<T, double>::value)
     //It is double
if (std::is_same<T, long double>::value)
     //It is long double