C ++: Namespaces - हेडर और सोर्स फाइल्स का सही तरीके से उपयोग कैसे करें?

Question 1

दो स्रोत फ़ाइलों की एक जोड़ी पर विचार करें: एक इंटरफ़ेस घोषणा फ़ाइल ( *.hया *.hpp) और इसके कार्यान्वयन फ़ाइल ( *.cpp)।

*.hफ़ाइल को निम्न की तरह होने दें :

namespace MyNamespace {
  class MyClass {
  public:
    int foo();
  };
}

मैंने स्रोत फ़ाइलों में नाम स्थान का उपयोग करने के लिए दो अलग-अलग प्रथाओं को देखा है:

*.cpp प्रैक्टिस दिखाना # 1:

#include "MyClass.h"
using namespace MyNamespace;

int MyClass::foo() { ... }

*.cpp अभ्यास दिखा रहा है # 2:

#include "MyClass.h"
namespace MyNamespace {

  int MyClass::foo() { ... }

}

मेरा प्रश्न: क्या इन दोनों प्रथाओं में कोई अंतर है और क्या एक दूसरे से बेहतर माना जाता है?

Question 2

एक कोड पठनीयता के दृष्टिकोण से, संभवतः इस कारण से # 2 विधि का उपयोग करना मेरी राय में बेहतर है:

आप usingएक समय में कई नामस्थान हो सकते हैं , और उस पंक्ति के नीचे लिखी गई कोई भी वस्तु या कार्य उन नामस्थानों में से किसी एक का नामकरण कर सकते हैं (नामकरण संघर्ष को रोकते हुए)। किसी namespaceब्लॉक में पूरी फ़ाइल को लपेटना अधिक स्पष्ट है, और आपको नए कार्यों और चर को घोषित करने की अनुमति देता है जो कि .cpp फ़ाइल में भी उस नामस्थान से संबंधित हैं।

Question 3

सबसे स्पष्ट वह विकल्प है जो आपने नहीं दिखाया:

int MyNamespace::MyClass::foo()
{
    //  ...
}

यह भी बहुत क्रिया है; ज्यादातर लोगों के लिए बहुत ज्यादा। चूंकि using namespaceनाम संघर्ष के लिए एक रसीद है, कम से कम मेरे अनुभव में, और बहुत सीमित दायरे और स्थानों को छोड़कर बचा जाना चाहिए, मैं आमतौर पर आपके # 2 का उपयोग करता हूं।

Question 4

क्या इन दोनों प्रथाओं में कोई अंतर है

हाँ। # 1 और # 2 क्रमशः एक प्रयोग-निर्देश और एक नेमस्पेस परिभाषा के उदाहरण हैं। वे इस मामले में प्रभावी रूप से समान हैं लेकिन अन्य परिणाम हैं। उदाहरण के लिए, यदि आप एक नए पहचानकर्ता का परिचय देते हैं, तो MyClass::fooइसका एक अलग दायरा होगा:

# 1:

using namespace MyNamespace;
int x;  // defines ::x

# 2:

namespace MyNamespace {
  int x;  // defines MyNamespace::x
}

क्या एक को दूसरे से बेहतर माना जाता है?

# 1 पेशेवरों: थोड़ा और अधिक; मुश्किल से MyNamespaceअनजाने में कुछ परिचय । विपक्ष: मौजूदा पहचानकर्ताओं में अनायास ही खींच सकता है।

# 2 पेशेवरों: अधिक स्पष्ट है कि मौजूदा पहचानकर्ताओं और नई पहचानकर्ताओं की घोषणाओं की परिभाषाएँ दोनों से संबंधित हैं MyNamespace। विपक्ष: अनायास ही पहचानकर्ताओं को पेश करना आसान हो जाता है MyNamespace।

# 1 और # 2 दोनों की आलोचना यह है कि वे एक संपूर्ण नामस्थान का उल्लेख कर रहे हैं, जब आप केवल सदस्यों की परिभाषा के बारे में परवाह करते हैं MyNamespace::MyClass। यह भारी-भरकम है और यह खराब इरादे का संचार करता है।

# 1 का एक संभावित विकल्प एक प्रयोग-घोषणा है जिसमें केवल उस पहचानकर्ता को शामिल किया जाता है जिसमें आप रुचि रखते हैं:

#include "MyClass.h"
using MyNamespace::MyClass;

int MyClass::foo() { ... }

Question 5

मैं यह भी जोड़ना चाहूंगा कि यदि आप किसी कारण के कारण किसी cpp फ़ाइल में टेम्पलेट विशेषज्ञता को लागू करने का निर्णय लेते हैं और using namespaceआप पर भरोसा करते हैं तो आप निम्नलिखित समस्या में भाग लेंगे:

// .h file
namespace someNameSpace
{
  template<typename T>
    class Demo
    {
      void foo();
    };
}

// .cpp file
using namespace someNameSpace;

template<typename T>
void Demo<T>::foo(){}

// this will produce
// error: specialization of 'template<class T> void someNameSpace::Demo<T>::foo()' in different namespace [-fpermissive]
template<>
void Demo<int>::foo(){}

अन्यथा यदि आप # 2 विधि लागू करते हैं तो यह ठीक होगा।

Question 6

मैं एक और तरीका जोड़ना चाहता हूँ, प्रयोग-घोषणा का उपयोग करके :

#include "MyClass.h"
using MyNamespace::MyClass;

int MyClass::foo() { ... }

अगर क्लास में कई फंक्शन्स हैं तो यह आपको कई बार नेमस्पेस नाम टाइप करने से बचाता है