"templating" एक namespace

Question

मैं कुछ इस तरह का निर्माण करना चाहते हैं:

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

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

बेशक

यह संभव नहीं है, क्योंकि आप टेम्पलेट नामस्थान नहीं कर सकता। इसके बजाय मैं एक नाम स्थान के बजाय एक struct इस्तेमाल कर सकते हैं, लेकिन फिर मैं कई फ़ाइलों पर नाम स्थान कार्यों का प्रसार नहीं कर सकते।

वहाँ ऐसी समस्या के लिए किसी भी समाधान है?

पीएस: मुझे पता है कि मैं कक्षाओं को टेम्पलेट कर सकता हूं, लेकिन फिर मुझे यह निर्दिष्ट करना होगा कि मैं किस वेक्टर प्रकार का उपयोग करना चाहता हूं, जब भी मैं एक नई कक्षा बनाउंगा। इसके बजाय

using namespace myNamespace<int>;

बस टेम्प्लेट का उपयोग वर्गों लिखने के

और इस के बजाय लिखने (या जो भी परिवर्तन):

Answer 1

अपनी टिप्पणी पर बाद

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

मैं के लिए करते हैं ऐसा लगता है कि किसी विशेष इंस्टेंस को आयात करने की तरह कुछ करने की कोशिश करने के बजाय किस प्रकार का उपयोग किया जा रहा है, इसके बारे में स्पष्ट होना बेहतर है एक नामस्थान का tiation।

क्या आप समस्या का पूरी तरह से वर्णन कर सकते हैं जो आपको लगता है कि टेम्पलेट नामस्थान उपयोगी होंगे?

और याद रखें कि आप हमेशा के लिए टेम्पलेट प्रकार को कम करने के लिए make_myClass1 मुफ्त फ़ंक्शन लिख सकते हैं।

Answer 2

आप ऐसा नहीं कर सकते हैं, लेकिन आप अलग-अलग नामस्थान और टाइपपीफ प्रदान कर सकते हैं (ऐसा नहीं कि मैं इसका समर्थन करता हूं)।

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

वैसे भी, मेरे वर्गों में कई टेम्पलेट पैरामीटर हैं। अब मैं इस दृष्टिकोण बनाया:

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

} 

और मुझे लगता है कि मैं मार्क बी के दृष्टिकोण के साथ संयोजित करेंगे!

चीयर्स, लोग!