c++ - template - que es una plantilla web

Plantillas de plantillas variables y reenvío perfecto

Question

Esta pregunta sobre el patrón del generador de objetos me hizo pensar en formas de automatizarlo.

Esencialmente, quiero automatizar la creación de funciones como std::make_pair , std::bind1st y std::mem_fun para que en lugar de tener que escribir una función diferente para cada tipo de clase de plantilla, pueda escribir una sola plantilla de plantilla variadica que maneja todos los casos a la vez. El uso de esta función sería como:

make<std::pair>(1, 2);         // equivalent to std::make_pair(1, 2)
make<std::binder2nd>(&foo, 3); // equivalent to std::bind2nd(&foo, 3);

¿Es posible escribir esta función make ? He intentado esto, pero no funciona en GCC 4.5 o 4.6:

template <template <typename...> class TemplateClass, typename... Args>
TemplateClass<Args...> make(Args&&... args)
{
    return TemplateClass<Args...>(std::forward<Args>(args)...);
}

Si trato de llamar (por ej.) make<std::pair>(1, 2) simplemente obtengo

error: no matching function for call to ''make(int, int)''

¿He obtenido la sintaxis incorrecta aquí?
¿O es esto correcto y GCC está equivocado?
¿O esto es fundamentalmente imposible en C ++ 0x?

[editar]

La propuesta N2555 parece sugerir que esto está permitido y GCC afirma haberlo implementado en GCC4.4 .

Answer 1

Eso es exactamente correcto. Esperaría que funcionara. Entonces creo que GCC está equivocado al rechazar eso. FWIW:

#include <utility>

template <template <typename...> class TemplateClass, typename... Args>
TemplateClass<Args...> make(Args&&... args)
{
    return TemplateClass<Args...>(std::forward<Args>(args)...);
}

int main() {
  make<std::pair>(1, 2);
}


// [js@HOST2 cpp]$ clang++ -std=c++0x main1.cpp
// [js@HOST2 cpp]$

Answer 2

Esta es probablemente una peculiaridad de GCC. Puedo hacer que lo siguiente funcione con una instantánea de desarrollador (no tengo una copia de 4.6 en este momento):

template<
    template<typename...> class TemplateClass
    , typename... Args

    , typename Result = TemplateClass<Args...>
    // Also works with the arguably more correct
    // , typename Result = TemplateClass<
    //     typename std::decay<Args>::type...
    // >
>
Result
make(Args&&... args)
{ /* as before */ }

Answer 3

Esto es bastante make_shared tomar make_shared , por ejemplo. El objetivo de make_shared es que haya ahorros de eficiencia en el tiempo de ejecución para usarlo. Pero, ¿qué pasaría si tratara de usar make<std::shared_ptr> ? No creas que eso funcionará. ¿O qué tal los tipos donde solo algunos de los argumentos constructor son argumentos de plantilla, y el resto no? Por ejemplo, make<std::vector, int>(other_vector.begin(), other_vector.end()); - los tipos de los iteradores no participan, pero los pasas de todos modos.

Es imposible escribir una función de make genérica.

En cuanto al estándar, bien, podría haberse eliminado fácilmente desde entonces. Tendría que verificar el FDIS.