¿Por qué se usa :: (scope) con el operando vacío de la mano izquierda?

Question

He visto esto algunas veces, y me he estado rascando la cabeza preguntándome por qué ...

Como un ejemplo: (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)); 
} 

Este ejemplo funciona sin los operadores :: (scope) entonces ¿por qué están incluso allí?

Answer 1

Esto significa básicamente "obtener la función de ámbito GLOBAL, en lugar de la función actualmente visible".

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

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

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

Answer 2

Es forzar que el símbolo se busque en el alcance global.

void foo() {} // 1 

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

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

Answer 3

Usando el operador alcance de esta manera significa que usted se refiere al ámbito global.

Para ahorrarme tiempo valioso y presionar las teclas, consulte scope resolution operator without a scope.

Answer 4

Digamos que tiene lo siguiente:

void bar() 
{ 
} 

struct Foo 
{ 
    void bar(); 
}; 

Si desea llamar a la función global bar de la función miembro Foo::bar utiliza la sintaxis con vacío a mano izquierda:

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

Answer 5

El :: se utiliza para dar acceso a un objeto directamente desde fuera del objeto.

Answer 6

Fuerza una resolución absoluta del nombre.
Sin él, se busca la resolución del nombre relativo a la ruta del espacio de nombres de clase/funciones.

Así asumir LeftClick() está en la jerarquía del espacio de nombres:

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

se vuelve más interesante si usted tiene un nombre anidado:

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