„szablonów” przestrzeń nazw

Question

Chciałbym zbudować coś takiego:

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

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

Oczywiście nie jest to możliwe, ponieważ nie można szablonów nazw. Zamiast tego mógłbym użyć struct zamiast przestrzeni nazw, ale wtedy nie mogę rozprzestrzenić funkcji przestrzeni nazw na kilka plików.

Czy istnieje rozwiązanie tego problemu?

PS: Wiem, że mogłem zaprojektować klasy, ale wtedy musiałbym określić, jaki typ wektora chcę użyć w dowolnym momencie, kiedy tworzę nową klasę.

Answer 1

Nawiązując do Twojego komentarza:

Zamiast pisać

using namespace myNamespace<int>;

wystarczy użyć na matrycy klasy i napisać to zamiast (lub cokolwiek zmienność):

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

bywam uważam, że lepiej jest mówić otwarcie o tym, jakie typy są używane, niż próbować zrobić coś takiego jak importowanie określonego instanu tacji przestrzeni nazw.

Czy można dokładniej opisać problem, który powoduje, że szablony mogą być przydatne w miejscach nazw?

Pamiętaj, że zawsze możesz napisać darmową funkcję make_myClass1, aby wydedukować typ szablonu dla siebie.

Answer 2

Nie można tego zrobić, ale można podać różne przestrzenie nazw i typy maszyn (nie to, że je popieram).

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

W każdym razie, moje zajęcia mają kilka parametrów szablonu. Teraz stworzyłem tego podejścia:

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

} 

i myślę, że będę połączyć je z podejściem Mark B.!

Pozdrowienia, chłopaki!