"plantillas" un espacio de nombres

Question

me gustaría construir algo como esto:

File 1: 
template<typename Vector> 
namespace myNamespace { 
    class myClass1{ myClass1(Vector v) {...} } 
} 

File 2: 
template<typename Vector> 
namespace myNamespace { 
    class myClass2{ myClass2(Vector v) {...} } 
} 

Por supuesto esto no es posible porque no se puede espacios de nombres de plantilla. En su lugar, podría usar una estructura en lugar de un espacio de nombres, pero luego no puedo extender las funciones del espacio de nombres sobre varios archivos.

¿Hay alguna solución para tal problema?

PD: Sé que podría diseñar las clases, pero luego tendría que especificar qué tipo de vector quiero usar en cualquier momento que cree una nueva clase.

Answer 1

el seguimiento de su comentario:

En lugar de escribir

using namespace myNamespace<int>;

clases sólo tiene que utilizar con plantilla y escribir esto en su lugar (o cualquier variación):

typedef myNamespace::myClass1<int> myClass1Int; 
typedef myNamespace::myClass2<int> myClass2Int; 

tiendo a Creo que es mejor ser explícito sobre qué tipos se utilizan en lugar de intentar hacer algo como importar un instan particular. ción de un espacio de nombres.

¿Puede describir más completamente el problema que le hace pensar que los espacios de nombres con plantillas serían útiles?

Y recuerde que siempre puede escribir una función gratuita make_myClass1 para deducir el tipo de plantilla para usted.

Answer 2

No puede hacer eso, pero puede proporcionar diferentes espacios de nombres y tiposdef (no es que yo lo apruebe).

namespace template_impl { 
    template <typename V> 
    class myClass1_tmpl {...}; 
    template <typename V> 
    class myClass2_tmpl {...}; 
} 
namespace myns_Vector1 { 
    typedef ::template_impl::myClass1_tmpl<Vector1> myClass1; 
    typedef ::template_impl::myClass2_tmpl<Vector1> myClass2; 
} 
void foo() { 
    using namespace myns_Vector1; 
    myClass1 mc1; 
} 

Answer 3

De todos modos, mis clases tienen varios parámetros de plantilla. Ahora he creado este enfoque:

#include <string> 
#include <iostream> 

namespace myNamespace { 
    template<typename _integer, typename _string> 
    struct s { 
    typedef _integer integer; 
    typedef _string string; 
    }; 

    template<class T> 
    class classA { 
    public: 
    static typename T::integer intFunc() { return 1; } 
    static typename T::string stringFunc() { return "hallo"; } 
    }; 
} 


int main() { 
    using namespace myNamespace; 

    typedef s<int, std::string> types1; 
    typedef s<unsigned int, char*> types2; 

    std::cout << classA<types1>::intFunc() << std::endl; 
    std::cout << classA<types1>::stringFunc() << std::endl; 

    std::cout << classA<types2>::intFunc() << std::endl; 
    std::cout << classA<types2>::stringFunc() << std::endl; 

} 

y yo creo que voy a la combino con el enfoque de Mark B!

¡Salud, muchachos!