¿firma de tipo de un constructor de plantilla con plantilla habilitada?

Question

Normalmente declaro mis clases y plantillas, y luego defino sus métodos después (en el mismo archivo de encabezado, por supuesto). Simplemente me resulta más fácil leer de esa manera. Bueno, me he encontrado con un caso en el que no puedo encontrar una firma de tipo de trabajo para usar en una definición fuera de clase. Aquí está un ejemplo simplificado de lo que estoy haciendo, que ilustra el problema:

template <class T> 
struct Foo 
    { 
    Foo(T a, T b); 

    template 
     < class Iterator 
     , enable_if< is_iterator<Iterator> > 
     > 
    Foo 
     (Iterator first 
     , Iterator last 
    ); 
    }; 

template <class T> 
Foo<T>::Foo(T a, T b) 
{ ... } 

template <class T> 
template 
    < class U 
    , WHAT_GOES_HERE? 
    > 
Foo<T>::Foo(U f, U l) 
{ ... } 

He intentado varias cosas en la ranura WHAT_GOES_HERE para tratar de obtener una firma coincidente, y me siguen fallando. Necesito el enable_if para distinguir el caso donde uno pasa en dos objetos de tipo T, y cuando uno pasa en un par de iteradores. El código funciona bien si el constructor con plantilla se define dentro de la plantilla principal, que es como lo hace actualmente el código, pero prefiero mover la definición fuera de la declaración.

EDIT: debería mencionar que no puedo volver a utilizar enable_if < ...> en la definición, porque enable_if < ...> asigna un valor predeterminado para su tipo, que no se puede hacer en una definición que no es también una declaración.

Answer 1

No lo haría de esa manera. He aquí los cambios que haría:

template <class T> 
struct Foo 
    { 
    Foo(T a, T b); 

    template 
     < class Iterator 
     > 
    Foo 
     (Iterator first 
     , Iterator last 
     , typename enable_if<is_iterator<Iterator> >::type* = 0 
    ); 
    }; 

template <class T> 
Foo<T>::Foo(T a, T b) 
{ ... } 

template <class T> 
template 
    < class U 
    > 
Foo<T>::Foo(U f, U l, typename enable_if< is_iterator<U> >::type*) 
{ ... } 

Esto es directamente de la documentación para enable_if.

Answer 2

¿Es esto lo que estás tratando de lograr? [No tengo un rasgo de tipo is_iterator, así que he reelaborado su ejemplo utilizando los rasgos de tipo C++ 0x y las bibliotecas de utilidades. Debería funcionar de la misma manera con las bibliotecas TR1 y Boost.]

#include <utility> 
#include <type_traits> 

template <typename T> 
struct S 
{ 
    // Constructor (1) 
    S(T, T); 

    // Constructor (2) 
    template <typename U> 
    S(U, U, typename std::enable_if<std::is_integral<U>::value>::type* = 0); 
}; 

template <typename T> 
S<T>::S(T, T) 
{ } 

template <typename T> 
template <typename U> 
S<T>::S(U, U, typename std::enable_if<std::is_integral<U>::value>::type*) 
{ } 

int main() 
{ 
    S<double> a(1.0, 2.0); // uses (1) 
    S<double> b(1, 2);  // uses (2) 
} 

Answer 3

El más simple que puede hacer es:

template<class Iterator> 
Foo 
    (Iterator first 
    , typename enable_if<is_iterator<Iterator>, Iterator>::type last 
); 

Answer 4

template <class T> 
struct Foo 
    { 
    Foo(T a, T b); 

    template <class Iterator 
     ,  class = typename std::enable_if 
         <is_iterator<Iterator>::value> 
         ::type 
     > 
    Foo 
     (Iterator first 
     , Iterator last 
    ); 
    }; 

template <class T> 
Foo<T>::Foo(T a, T b) 
{ } 

template <class T> 
template 
    < class U 
    , class > 
Foo<T>::Foo(U f, U l) 
{ }