"template" uno spazio dei nomi

Question

mi piacerebbe costruire qualcosa di simile:

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

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

Naturalmente questo non è possibile perché non si può namespace template. Invece potrei usare una struct invece di uno spazio dei nomi, ma poi non posso diffondere le funzioni dello spazio dei nomi su più file.

Esiste una soluzione per tale problema?

PS: So che potrei modellare le classi, ma poi dovrei specificare quale tipo di vettore voglio usare in qualsiasi momento creo una nuova classe.

Answer 1

Facendo seguito a un commento:

Invece di scrivere

using namespace myNamespace<int>;

classi Basta usare su modelli e scrivere questo posto (o qualsiasi altra cosa variazione):

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

tendo a penso sia meglio essere espliciti su quali tipi vengono usati piuttosto che provare a fare qualcosa come importare un particolare instan tiation di uno spazio dei nomi.

Puoi descrivere più dettagliatamente il problema che ti fa pensare che gli spazi dei nomi basati su modelli sarebbero utili?

E ricorda che puoi sempre scrivere una funzione libera make_myClass1 per dedurne il tipo di modello.

Answer 2

Non è possibile farlo, ma è possibile fornire diversi spazi dei nomi e typedef (non che io lo approvi).

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

In ogni caso, le mie classi hanno diversi parametri di modello. Ora ho creato questo approccio:

#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; 

} 

e penso di combinarlo con l'approccio di Mark B!

Cheers, ragazzi!