Deducción de la plantilla para función basada en su tipo de devolución?

Question

Me gustaría ser capaz de utilizar la deducción plantilla para lograr lo siguiente:

GCPtr<A> ptr1 = GC::Allocate(); 
GCPtr<B> ptr2 = GC::Allocate(); 

en lugar de (lo que tengo actualmente):

GCPtr<A> ptr1 = GC::Allocate<A>(); 
GCPtr<B> ptr2 = GC::Allocate<B>(); 

Mi función Asignar actual se parece a esto:

class GC 
{ 
public: 
    template <typename T> 
    static GCPtr<T> Allocate(); 
}; 

¿Sería esto posible desprender el extra < a> B y <>?

Gracias

Answer 1

Eso no se puede hacer. El tipo de devolución no forma parte de la deducción de tipo, sino que es el resultado de haber coincidido con la firma de plantilla adecuada. Puede, sin embargo, esconderse de la mayoría de los usos como:

// helper 
template <typename T> 
void Allocate(GCPtr<T>& p) { 
    p = GC::Allocate<T>(); 
} 

int main() 
{ 
    GCPtr<A> p = 0; 
    Allocate(p); 
} 

Ya sea que la sintaxis es en realidad ni mejor ni peor que el inicial GCPtr<A> p = GC::Allocate<A>() es otra cuestión.

P.S. C++ 11 le permitirá omitir una de las declaraciones de tipo:

auto p = GC::Allocate<A>(); // p is of type GCPtr<A> 

Answer 2

Puede intentar usar una macro para ello. Aparte de eso, no veo cómo se supone que funciona con solo una declaración.

#define ALLOC(ptrname,type) GCPtr<type> ptrname = GC::Allocate<type>() 

ALLOC(ptr1,A); 

Johannes 'points are valid. El problema >> se soluciona fácilmente. Pero creo que tienen comas como parte del tipo requiere el preprocesador C99 varargs extensión:

#define ALLOC(ptrname,...) GCPtr<__VA_ARGS__> ptrname = GC::Allocate<__VA_ARGS__>() 

ALLOC(ptr1,SomeTemplate<int,short>); 

Answer 3

De la misma manera no se puede sobrecargar las funciones del tipo de cambio, no se puede hacer la deducción de plantilla en él. Y por la misma razón - si f() es una plantilla/sobrecarga que devuelve algo, ¿qué tipo de uso aquí:

f(); 

Answer 4

La única cosa que puedo pensar en: hacer que asignar una plantilla no que devuelve un no -template objeto proxy que tiene un operador de conversión de plantilla, que hace el trabajo real:

template <class T> 
struct GCPtr 
{ 

}; 

class Allocator 
{ 
public: 
    template <class T> 
    operator GCPtr<T>() { return GCPtr<T>(); } 
}; 

class GC 
{ 
public: 
    static Allocator Allocate() { return Allocator(); }//could give a call-back pointer? 
}; 

int main() 
{ 
    GCPtr<int> p = GC::Allocate(); 
} 

Answer 5

Usted podría ir a la ruta opuesta.

Si está utilizando un compilador al día (MSVC 2010, que debería salir en un par de días, o la versión actual de GCC) y no les importa confiar en C++ 0x características:

auto ptr1 = GC::Allocate<A>(); 
auto ptr2 = GC::Allocate<B>(); 

le ahorraría el extra <A> y <B>, simplemente no está en el lado derecho. :)

Answer 6

(Esta respuesta es la misma que @UncleBens, pero un poco más general, ya que perfecto transmita ningún argumento.)

Esto es muy útil en lenguajes como Haskell, donde, por ejemplo, se llevará a read una cadena como entrada y la analizará de acuerdo con el tipo de devolución deseado.

(Aquí es sample code on ideone.)

En primer lugar, comenzar con la función foo cuyo tipo de retorno deseamos deducir:

template<typename Ret> 
Ret foo(const char *,int); 
template<> 
std::string foo<std::string>(const char *s,int) { return s; } 
template<> 
int   foo<int  >(const char *,int i) { return i; } 

Cuando se le preguntó por una cadena, que va a devolver la cadena que está en su primer argumento Cuando se le pide un int, devolverá el segundo argumento.

Podemos definir una función auto_foo que se puede utilizar de la siguiente manera:

int main() { 
     std::string s = auto_foo("hi",5); std::cout << s << std::endl; 
     int   i = auto_foo("hi",5); std::cout << i << std::endl; 
} 

---

Para que esto funcione, necesitamos un objeto que va a almacenar temporalmente los argumentos de la función, y también ejecutar la función cuando se le pide que convert para el tipo de retorno deseada:

#include<tuple> 

template<size_t num_args, typename ...T> 
class Foo; 
template<typename ...T> 
class Foo<2,T...> : public std::tuple<T&&...> 
{ 
public: 
     Foo(T&&... args) : 
       std::tuple<T&&...>(std::forward<T>(args)...) 
     {} 
     template< typename Return > 
     operator Return() { return foo<Return>(std::get<0>(*this), std::get<1>(*this)); } 
}; 
template<typename ...T> 
class Foo<3,T...> : std::tuple<T&&...> 
{ 
public: 
     Foo(T&&... args) : 
       std::tuple<T&&...>(std::forward<T>(args)...) 
     {} 
     template< typename Return > 
     operator Return() { return foo<Return>(std::get<0>(*this), std::get<1>(*this), std::get<2>(*this)); } 
}; 

template<typename ...T> 
auto 
auto_foo(T&&... args) 
     // -> Foo<T&&...> // old, incorrect, code 
     -> Foo< sizeof...(T), T&&...> // to count the arguments 
{ 
     return    {std::forward<T>(args)...}; 
} 

Además, los trabajos anteriores para dos o arg arg funciones de tres, no es difícil ver cómo extender eso.

¡Esto es mucho código para escribir! Para cada función a la que aplicará esto, podría escribir una macro que haga esto por usted. Algo como esto en la parte superior de su archivo:

REGISTER_FUNCTION_FOR_DEDUCED_RETURN_TYPE(foo); // declares 
         // necessary structure and auto_??? 

y entonces se podría utilizar auto_foo en su programa.