Perché è :: (scope) utilizzato con l'operando sinistro a sinistra?

Question

L'ho visto alcune volte adesso e mi sono grattato la testa chiedendomi perché ...

Come esempio: (http://www.codeguru.com/forum/showthread.php? t = 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)); 
} 

Questo esempio funziona senza gli operatori :: (scope) in modo perché sono ancora lì?

Answer 1

Fondamentalmente significa "ottenere la funzione con ambito GLOBAL, anziché quella attualmente visibile".

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

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

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

Answer 2

È per forzare il simbolo a essere esaminato nell'ambito globale.

void foo() {} // 1 

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

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

Answer 3

L'utilizzo dell'operatore di ambito in questo modo indica che si sta facendo riferimento all'ambito globale.

Per risparmiare tempo prezioso e sequenze di tasti, controlla scope resolution operator without a scope.

Answer 4

Diciamo che avere il seguente:

void bar() 
{ 
} 

struct Foo 
{ 
    void bar(); 
}; 

Se si desidera chiamare la funzione globale bar dalla funzione membro Foo::bar si utilizza la sintassi con la sinistra vuota:

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

Answer 5

Il :: viene utilizzato per concedere l'accesso a un oggetto direttamente dall'esterno dell'oggetto.

Answer 6

Forza una risoluzione nome assoluta.
Senza il nome viene cercata la risoluzione relativa al percorso dello spazio dei nomi della classe/delle funzioni.

Quindi assumere Pulsante sinistro() è nella gerarchia dello spazio dei nomi:

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() 
      } 
     } 
    } 
} 

diventa più interessante se si dispone di un nome nidificato:

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. 
      } 
     } 
    } 
}