क्या होगा यदि मुझे हेडर में अनाम नामस्थान की आवश्यकता है?

Question

C++ में एक गुमनाम नाम स्थान के बराबर है:

namespace $$$$ { 
    //something 
} 
using namespace $$$$; 

कहाँ अद्वितीय पहचानकर्ता किसी तरह का $$$$ है। बेनामी नामस्थान तब कोड के लिए उपयोगी होता है जिसे संकलन इकाई के बाहर नहीं देखा जाना चाहिए।

अभी तक इतना अच्छा है, हालांकि हाल ही में मैंने टेम्पलेट्स के साथ कुछ कोड लिखना शुरू कर दिया है, ऐसे कोड को हेडर में होना चाहिए ताकि अज्ञात नेमस्पेस का उपयोग करने से ज्यादा अर्थ न हो क्योंकि हेडर के केवल समावेशन को अलगाव प्रभाव को खत्म कर दिया जाएगा।

फिर सवाल यह है कि, इन मामलों में सुझाए गए तरीके क्या हैं? मैंने निजी नामक नामित नामस्थान का उपयोग शुरू किया। यह वास्तव में ऐसे किसी भी व्यक्ति को नहीं रोकता है जो अंदर पहचानकर्ताओं का उपयोग करना चाहता है, लेकिन कम से कम यह नाम "निजी" नाम के नाम को कम कर देता है।

क्या बेहतर तरीके हैं? सुझाव?

Answer 1

अपने Privatenamespace (या अधिक लोकप्रिय detail का उपयोग करें) के साथ चिपकाएं। याद रखें कि सी ++ एक्सेस मैकेनिज्म के पीछे मुख्य विचार उन्हें दुरुपयोग करना मुश्किल है, असंभव नहीं। दुर्घटनाओं के खिलाफ खुद को सुरक्षित रखें, दुर्भावनापूर्ण हमलों नहीं।

Answer 2

यदि आप उस अलगाव के लिए बेताब हैं, तो अच्छी पुरानी फ़ाइल- static क्यों नहीं? यह undeprecated गया था:

template <typename T> 
static void foo() 
{} 

int main() 
{ 
    foo<char>(); 
} 

फिर, अगर आप केवल तब शायद आप केवल उस अनुवाद इकाई में हेडर में शामिल कर रहे हैं foo भीतर एक अनुवाद इकाई की जरूरत है, और फिर इसे बात जो भी यह है कि क्या नहीं है "एक शीर्षलेख में"। इसलिए, बस अन्य अनुवाद इकाइयों में टेम्पलेट्स शामिल न करें और आप पहले से ही अलगाव के अपने लक्ष्य को हासिल कर चुके हैं।

करने के लिए वास्तव में गारंटी अलगाव के लिए सभी संभव instantiations (अर्थात उन है कि आप इस टीयू के अंतर्गत बनाए गए सहित), इसके बाद के संस्करण के रूप में static का उपयोग या बस एक detail नाम स्थान का उपयोग कर अपने इरादे दस्तावेज़।

Answer 3

शीर्षलेख के भीतर टेम्पलेट कोड के कार्यान्वयन को छिपाने का सबसे सामान्य तरीका है detail नामक नामस्थान में कार्यान्वयन करना।

उदाहरण के लिए:

namespace cpputil { // my c++ utility library namespace 

    namespace detail { // implementation details of this libraries headers go here 

    // a functor private to the library 
    template<class T> 
    struct private_functor { 
     private_functor(const T& t) : _t(t) {} 
     void write(std::ostream& os) const { _t.write(os); } 
    private: 
     const T& _t; 
    }; 

    // an extension to std::ostream::operator<< 
    template<class T> 
    std::ostream& operator<<(std::ostream& os, const private_functor<T>& pf) 
    { 
     pf.write(os); 
     return os; 
    } 
    } 

    /// a public template function that is designed to allow an object to be emitted to a stream 
    /// returns a function object that calls T::write(std::ostream&) when placed into an 
    /// output stream 
    template<class T> 
    detail::private_functor emit(const T& t) { 
    return detail::private_functor<T>(t); 
    } 
} 

// can be used like this: 

int main() { 
    struct S { 
    void write(std::ostream& os) const { os << "{I am an S}"; } 
    }; 

    std::cout << cpputil::emit(S) << std::endl; 
    return 0; 
}