2010-07-23 23 views
8

me gustaría construir algo como esto:"plantillas" un espacio de nombres

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.

+1

Acerca de su PS: ¿Cómo cree que tener un espacio de nombres con plantillas eliminaría la necesidad de especificar el tipo de vector al crear instancias de clases? Todavía necesitarías al menos algo así como (de ficción) 'using namespace myNamespace ; ' – stakx

+1

Estoy con stakx en esto. ¿Y qué es eso 'int' en tu código? – sbi

+0

Sí, pero luego podría hacer algo como esto: int function1() { usando el espacio de nombres myNamespace ; myClass1 c1 = myClass1 (5); myClass2 c2 = myClass2 (2); } int function2() { usando el espacio de nombres myNamespace ; myClass1 c1 = myClass1 ('a'); myClass2 c2 = myClass2 ('b'); } Lo siento, ese int es incorrecto, lo eliminaré. ¿Cómo pego el código aquí correctamente? – Manuel

Respuesta

5

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.

+0

Probablemente sea una buena idea. – Manuel

+2

@Mark B Sé que esta es una pregunta muy antigua, pero ¿y si quieres algo así como una clase 'Util' con solo métodos estáticos?¿No sería mejor usar un espacio de nombres para eso? – AJC

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; 
} 
0

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!

Cuestiones relacionadas