खाली बाएं हाथ के ऑपरेंड के साथ :: (स्कोप) का उपयोग क्यों किया जाता है?

Question

मैंने इसे कुछ बार देखा है, और मैं अपने सिर को खरोंच कर रहा हूं कि क्यों ...

उदाहरण के रूप में: (http://www.codeguru.com/forum/showthread.php? टी = 377394)

void LeftClick () 
{ 
    INPUT Input={0}; 
    // left down 
    Input.type  = INPUT_MOUSE; 
    Input.mi.dwFlags = MOUSEEVENTF_LEFTDOWN; 
    ::SendInput(1,&Input,sizeof(INPUT)); 

    // left up 
    ::ZeroMemory(&Input,sizeof(INPUT)); 
    Input.type  = INPUT_MOUSE; 
    Input.mi.dwFlags = MOUSEEVENTF_LEFTUP; 
    ::SendInput(1,&Input,sizeof(INPUT)); 
} 

यह उदाहरण :: (स्कोप) ऑपरेटरों के बिना काम करता है तो वे वहां क्यों हैं?

Answer 1

इसका मूल रूप से अर्थ है "वर्तमान में दृश्यमान की बजाय वैश्विक स्कोप्ड फ़ंक्शन प्राप्त करें"।

void SendInput() { /* (1) */ 
} 

namespace derp { 
    void SendInput() { /* (2) */ 
    } 

    void LeftClick() { 
     ... 
     ::SendInput(); /* matches (1) */ 
     SendInput(); /* matches (2) */ 
    } 
} 

Answer 2

यह वैश्विक दायरे पर प्रतीक को देखने के लिए मजबूर करना है।

void foo() {} // 1 

namespace A 
{ 
    void foo() {} // 2 

    void bar() 
    { 
     foo(); // 2 
     ::foo(); // 1 
    } 
} 

Answer 3

इस फैशन में स्कोप ऑपरेटर का उपयोग करना मतलब है कि आप वैश्विक दायरे का जिक्र कर रहे हैं।

मुझे मूल्यवान समय और कीस्ट्रोक बचाने के लिए, scope resolution operator without a scope देखें।

void bar() 
{ 
} 

struct Foo 
{ 
    void bar(); 
}; 

आप सदस्य समारोह Foo::bar आप खाली बाएं हाथ की ओर के साथ सिंटैक्स का उपयोग से वैश्विक समारोह bar कॉल करने के लिए चाहते हैं:

Answer 4

कहते हैं कि तुम निम्न होना चलें

void Foo::bar() 
{ 
    // Call the global bar function, not recursively call myself 
    ::bar(); 
} 

Answer 5

:: वस्तु के बाहर से किसी ऑब्जेक्ट तक पहुंच प्रदान करने के लिए उपयोग किया जाता है।

Answer 6

यह एक पूर्ण नाम संकल्प को मजबूर करता है।
इसके बिना नाम संकल्प वर्ग (ओं)/फ़ंक्शंस नेमस्पेस पथ के सापेक्ष खोजा जाता है।

तो मान LeftClick() नाम स्थान पदानुक्रम में है:

namespace Level1 
{ 
    namespace Level2 
    { 
     namespace Level3 
     { 
      LeftClick() 
      { 
       ::SendInput(); // Absolute path only. SendInput in global namespace 
       SendInput();  // Relative path (Note resolved at compile time) 
            // 
            // Looks for the function here (in this order) 
            // ::Level1::Level2::Level3::SendInput() 
            // ::Level1::Level2::SendInput() 
            // ::Level1::SendInput() 
            // ::SendInput() 
      } 
     } 
    } 
} 

यदि आप एक नेस्टेड नाम है यह और अधिक दिलचस्प हो जाता है:

namespace Level1 
{ 
    namespace Level2 
    { 
     namespace Level3 
     { 
      LeftClick() 
      { 
       ::Test::Action(); // Absolute Path: Function Action() 
            //    in namespace Test 
            //    in global namespace 

       Test::Action(); // Relative Path: Function Action() 
            //    in namespace Test 
            //    in current namespace path. 
            // 
        // It will Look for Test (in this order) 
        // ::Level1::Level2::Level3::Test 
        // ::Level1::Level2::Test 
        // ::Level1::Test 
        // ::Test 
        // 
        // In the first Test (and only the first) it finds it will 
        // try and resolve the Action() function. If it is not there 
        // it is a compile time error. 
      } 
     } 
    } 
}