"khuôn mẫu" một không gian tên

Question

Tôi muốn xây dựng một cái gì đó như thế này:

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

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

Tất nhiên điều này là không thể bởi vì bạn không thể không gian tên mẫu. Thay vào đó tôi có thể sử dụng một cấu trúc thay vì một không gian tên, nhưng sau đó tôi không thể lan truyền các chức năng không gian tên trên một số tệp.

Có giải pháp nào cho vấn đề như vậy không?

PS: Tôi biết tôi có thể tạo mẫu cho các lớp, nhưng sau đó tôi phải chỉ định loại véc tơ nào tôi muốn sử dụng bất cứ khi nào tôi tạo một lớp mới.

Answer 1

Theo dõi trên nhận xét của bạn:

Thay vì viết

using namespace myNamespace<int>;

lớp Chỉ cần sử dụng templated và viết những dòng này thay vì (hoặc bất kỳ biến thể):

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

Tôi có xu hướng nghĩ rằng tốt hơn là phải rõ ràng về những loại nào đang được sử dụng thay vì cố gắng làm điều gì đó như nhập một instan cụ thể tiation của một không gian tên.

Bạn có thể mô tả đầy đủ hơn về vấn đề khiến bạn cho rằng không gian tên được tạo khuôn mẫu có hữu ích không?

Và hãy nhớ rằng bạn luôn có thể viết hàm miễn phí make_myClass1 để suy ra loại mẫu cho bạn.

Answer 2

Bạn không thể làm điều đó, nhưng bạn có thể cung cấp các không gian tên và typedef khác nhau (không phải là tôi xác nhận nó).

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

Dù sao, các lớp của tôi có nhiều thông số mẫu. Bây giờ tôi đã tạo cách tiếp cận này:

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

} 

và tôi nghĩ tôi sẽ kết hợp nó với cách tiếp cận của Mark B!

Chúc mừng các bạn!