समारोह छिपने और C++

Question

मेरे भ्रम की स्थिति से आता है "सी ++ प्राइमर 5 वीं संस्करण" खंड 13.3 का उपयोग कर-घोषणा, पेज 518.

बहुत सावधान पाठकों को आश्चर्य हो सकता क्यों swap अंदर using घोषणा के लिए घोषणाओं को छिपा नहीं करता HasPtrswap का संस्करण।

मैंने इसके संदर्भ को पढ़ने की कोशिश की लेकिन अभी भी समझ में नहीं आया। क्या कोई इसे थोड़ा सा समझा सकता है? धन्यवाद। प्रश्न का कोड नमूना यहां दिया गया है।

कक्षा Foo मान लें कि h नामक एक सदस्य है, जिसमें HasPtr टाइप किया गया है।

void swap(HasPtr &lhs, HasPtr &rhs) 
{...} 

void swap(Foo &lhs, Foo &rhs) 
{ 
    using std::swap; 
    swap(lhs.h, rhs.h); 
} 

क्यों HasPtr के लिए swap छुपी नहीं है जो जबकि using std::swap भीतरी दायरे में है बाहरी दायरे में घोषित किया जा रहा है? धन्यवाद।

Answer 1

क्योंकि using std::swap; मतलब यह नहीं है "अब से, हर 'स्वैप' std::swap का उपयोग करना चाहिए", लेकिन "वर्तमान क्षेत्र में std से swap के सभी भार के लाने"।

इस मामले में, प्रभाव वही है जैसे आपने फ़ंक्शन के अंदर using namespace std; लिखा था।

Answer 2

प्रभावी सी ++ तीसरा संस्करण स्कॉट Meyers द्वारा (आइटम 24)

compilers कॉल स्वैप करने के लिए देखते हैं, वे आह्वान करने के लिए सही स्वैप के लिए खोज। सी ++ के नाम देखने नियम सुनिश्चित करें कि इस इस मामले में टी

वैश्विक क्षेत्र में या प्रकार के रूप में एक ही नाम स्थान में किसी भी टी विशिष्ट स्वैप मिलेगा और कोड के दूसरे खंड में, compilers एक के लिए देखो HasPtr स्वैप और यदि उन्हें यह नहीं मिलता है तो वे std में सामान्य संस्करण पर वापस आते हैं।

Answer 3

उपयोग घोषणा का मतलब सभी std :: स्वैप अधिभारों पर विचार करना है जैसे कि उन्हें फ़ंक्शन के समान नामस्थान में परिभाषित किया गया था। चूंकि उपयोग फ़ंक्शन किसी फ़ंक्शन बॉडी में दिखाई देता है, इसलिए इसका अस्थायी रूप से प्रभाव पड़ता है: उस दायरे में।

यह निम्न करने के लिए प्रभाव में समान होता है:

void swap(HasPtr &lhs, HasPtr &rhs) 
{...} 

void swap(int &lhs, int &rhs) { std::swap(lhs, rhs); } 
void swap(char &lhs, char &rhs) { std::swap(lhs, rhs); } 
// etc. for other std::swap overloads of common types 

void swap(Foo &lhs, Foo &rhs) 
{ 
    swap(lhs.h, rhs.h); 
    // the other overloads of swap go out of scope here. 
} 

अधिक भार का नियमित रूप से नियम यह सुनिश्चित करें कि पहले स्वैप एक कहा जाता हो जाता है। यह "स्वैप" नामक स्थानीय चर घोषित करने के विपरीत है, जो पहले अधिभार को छुपाएगा।

Answer 4

का उपयोग कर-घोषणाusing std::swap कार्यों आप HasPtr और Foo स्वैप करने के लिए घोषणा की है छिपा नहीं है। यह नाम swap नामित क्षेत्र में std नामस्थान बनाता है। इसके साथ, std::swap ओवरलोड रिज़ॉल्यूशन में भाग ले सकते हैं।

सी ++ 11 स्टैंडर्ड से:

7.3.3 घोषणा का उपयोग कर

1 एक का उपयोग कर-घोषणा कथात्मक क्षेत्र में एक नाम का परिचय जो का उपयोग कर-घोषणा में प्रकट होता है।

का उपयोग कर-घोषणा:

using typename_ऑप्टनेस्टेड-नाम-विनिर्देशक अयोग्य-आईडी;
using ::अयोग्य-आईडी;

सदस्य एक का उपयोग कर-घोषणा में निर्दिष्ट नाम कथात्मक क्षेत्र में घोषित किया जाता है जो का उपयोग कर-घोषणा दिखाई देता हो। [नोट: केवल निर्दिष्ट नाम घोषित किया गया है; में एक गणना नाम निर्दिष्ट करते हुए घोषणा-घोषणामें घोषणाकर्ता के घोषित क्षेत्र का उपयोग करके अपने गणक घोषित नहीं करता है। अंत टिप्पणी] एक का उपयोग कर-घोषणा नाम एक निर्माता (3.4.3.1), यह परोक्ष कंस्ट्रक्टर्स का एक सेट कक्षा में वाणी हैं, जिसमें का उपयोग कर-घोषणा प्रकट होता है (12.9); अन्यथा में निर्दिष्ट नाम-घोषणा किसी अन्य इकाई के नाम के लिए समानार्थी है।

आपके मामले में, तुम हो:

void swap(Foo &lhs, Foo &rhs) 
{ 
    using std::swap; 
    swap(lhs.h, rhs.h); 
} 

using std::swap; घोषणा कथात्मक क्षेत्र में std नाम स्थान है, जो swap(Foo&, Foo&) समारोह का मुख्य भाग है से नाम swap परिचय देता है। वैश्विक नामस्थान से swap नाम फ़ंक्शन के शरीर में अभी भी पहुंच योग्य है।

यदि आपने जो पोस्ट किया है वह फ़ंक्शन की संपूर्णता है, तो आपको using std::swap घोषणा की आवश्यकता नहीं है। तुम बस के साथ मिल सकता है:

void swap(Foo &lhs, Foo &rhs) 
{ 
    swap(lhs.h, rhs.h); 
} 

swap(HasPtr &lhs, HasPtr &rhs) के बाद से समारोह से दिख रहा है।

अब, नीचे दिए गए उदाहरण को देखें।

struct Bar {}; 

void swap(Bar& lhs, Bar& rhs) 
{ 
} 

struct Foo 
{ 
    int a; 
    Bar b; 
}; 

void swap(Foo& lhs, Foo& rhs) 
{ 
    swap(lhs.a, rhs.a); // A problem 
    swap(lhs.b, rhs.b); 
} 

लाइन में चिह्नित A problem के बाद से वहाँ कोई समारोह swap नामित कि तर्क के रूप में प्रकार int& की दो वस्तुओं के साथ काम कर सकते हैं एक समस्या है। आप निम्न विधियों में से एक का उपयोग कर कि ठीक कर सकते हैं:

1. उपयोग std::swap स्पष्ट रूप से।

   void swap(Foo& lhs, Foo& rhs) 
   { 
       std::swap(lhs.a, rhs.a); 
       swap(lhs.b, rhs.b); 
   } 
   

2. समारोह में std::swap परिचय दें।

   void swap(Foo& lhs, Foo& rhs) 
   { 
       using std::swap; 
       swap(lhs.a, rhs.a); 
       swap(lhs.b, rhs.b); 
   } 
   

Answer 5

वास्तव में, HasPtr के लिए swap जबकि भीतरी दायरे में using std::swap छिपा हुआ है, लेकिन इस मामले में आंतरिक दायरे में std::swap बाहरी दायरे में HasPtr के लिए swap के समान है।