Restringir la función de plantilla

Question

Escribí un programa de ejemplo en http://codepad.org/ko8vVCDF que usa una función de plantilla.

¿Cómo puedo retrotraer la función de la plantilla para que solo use números? (int, doble, etc.)

#include <vector> 
#include <iostream> 

using namespace std; 

    template <typename T> 
T sum(vector<T>& a) 
{ 
    T result = 0; 
    int size = a.size(); 
    for(int i = 0; i < size; i++) 
    { 
     result += a[i]; 
    } 

    return result; 
} 

int main() 
{ 
    vector<int> int_values; 
    int_values.push_back(2); 
    int_values.push_back(3); 
    cout << "Integer: " << sum(int_values) << endl; 

    vector<double> double_values; 
    double_values.push_back(1.5); 
    double_values.push_back(2.1); 
    cout << "Double: " << sum(double_values); 

    return 0; 
} 

Answer 1

La única manera de restringir una plantilla es hacerlo de modo que utilice algo de los tipos que desee, que otros tipos no tienen.

Así, se construye con un int, el uso + y + =, llama a un constructor de copia, etc.

Cualquier tipo que tiene todas estas trabajará con su función - por lo que, si se crea una nueva tipo que tiene estas características, su función funcionará en él, que es genial, ¿no?

Si desea restringirlo más, use más funciones que solo están definidas para el tipo que desea.

Otra forma de implementar esto es mediante la creación de una plantilla rasgos - algo como esto

template<class T> 
SumTraits 
{ 
public: 
    const static bool canUseSum = false; 
} 

Y luego se especializan para las clases que desea estar bien:

template<> 
class SumTraits<int> 
{ 
    public: 
    const static bool canUseSum = true; 
}; 

Luego, en su código, puede escribir

if (!SumTraits<T>::canUseSum) { 
    // throw something here 
} 

edición: como se ha mencionado en los comentarios, puede utilizar B OOST_STATIC_ASSERT para convertirlo en una verificación en tiempo de compilación en lugar de en tiempo de ejecución

Answer 2

¿Por qué quiere restringir los tipos en este caso? Las plantillas permiten "tipado de pato estático", por lo que cualquier cosa permitida por su función sum en este caso debería permitirse. Específicamente, la única operación requerida de T es la asignación de asignación y la inicialización por 0, por lo que cualquier tipo que admita esas dos operaciones funcionaría. Esa es la belleza de las plantillas.

(Si ha cambiado su initialiser a T result = T(); o similar, entonces sería trabajar para ambos números y cadenas, también.)

Answer 3

Se podría buscar en rasgos de tipo (uso impulso, esperar a que C++ 0x o crea tu propio).

He encontrado lo siguiente en Google: http://artins.org/ben/programming/mactechgrp-artin-cpp-type-traits.pdf

Answer 4

se puede hacer algo como esto:

template <class T> 
class NumbersOnly 
{ 
private: 
    void ValidateType(int &i) const {} 
    void ValidateType(long &l) const {} 
    void ValidateType(double &d) const {} 
    void ValidateType(float &f) const {} 

public: 
    NumbersOnly() 
    { 
     T valid; 
     ValidateType(valid); 
    }; 
}; 

obtendrá un error si se intenta crear una NumbersOnly que no tiene una sobrecarga de ValidateType :

NumbersOnly<int> justFine; 
NumbersOnly<SomeClass> noDeal; 

Answer 5

De hecho, no hay necesidad de hacerlo más estricto. Eche un vistazo a la versión de cadena (usando el estilo de constructor predeterminado aconsejado por Chris Jester-Young) here ...

Tenga cuidado, también, para desbordamientos: puede necesitar un tipo más grande para contener resultados intermedios (o resultados de salida) Bienvenido al ámbito de la metaprogramación, entonces :)

Answer 6

Así es como lo hace.

Comenta la especialización de la plantilla para el doble, por ejemplo ... y no te permitirá llamar a esa función con el doble como parámetro. El truco es que si intentas llamar a la suma con un tipo que no está entre las especializaciones de IsNumber, entonces se llama a la implementación genérica, y esa implementación hace algo no permitido (llamar a un constructor privado).

El mensaje de error NO es intuitivo a menos que cambie el nombre de la clase IsNumber a algo que suene como un mensaje de error.

#include <vector> 
#include <iostream> 

using namespace std; 

template<class T> struct IsNumber{ 
private: 
IsNumber(){} 
}; 

template<> struct IsNumber<float>{ 
    IsNumber(){}; 
}; 

template<> struct IsNumber<double>{ 
    IsNumber(){}; 
}; 

template<> struct IsNumber<int>{ 
    IsNumber(){}; 
}; 

template <typename T> 
T sum(vector<T>& a) 
{ 
IsNumber<T> test; 
T result = 0; 
int size = a.size(); 
for(int i = 0; i < size; i++) 
{ 
    result += a[i]; 
} 

return result; 
} 




int main() 
{ 
vector<int> int_values; 
int_values.push_back(2); 
int_values.push_back(3); 
cout << "Integer: " << sum(int_values) << endl; 

vector<double> double_values; 
double_values.push_back(1.5); 
double_values.push_back(2.1); 
cout << "Double: " << sum(double_values); 

return 0; 
} 

Answer 7

Esto es posible mediante el uso de SFINAE, y hace más fácil mediante el uso de ayudantes de cualquiera de Boost o C++ 11

Boost:

#include <vector> 
#include <boost/utility/enable_if.hpp> 
#include <boost/type_traits/is_arithmetic.hpp> 

template<typename T> 
    typename boost::enable_if<typename boost::is_arithmetic<T>::type, T>::type 
     sum(const std::vector<T>& vec) 
{ 
    typedef typename std::vector<T>::size_type size_type; 
    T result; 
    size_type size = vec.size(); 
    for(size_type i = 0; i < size; i++) 
    { 
    result += vec[i]; 
    } 

    return result; 
} 

C++ 11:

#include <vector> 
#include <type_traits> 

template<typename T> 
    typename std::enable_if<std::is_arithmetic<T>::value, T>::type 
     sum(const std::vector<T>& vec) 
{ 
    T result; 
    for (auto item : vec) 
    result += item; 
    return result; 
}