为什么 :: (scope) 与空左操作数一起使用？

Question

我已经见过几次了，我一直在挠头想知道为什么......

例如：（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));
}

这个例子无需 ::（作用域）运算符即可工作，那么为什么它们还在那里呢？

Answer 1

这基本上意味着“获取全局范围的函数，而不是当前可见的函数”。

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

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

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

Answer 2

假设您有以下内容：

void bar()
{
}

struct Foo
{
    void bar();
};

如果您想从成员函数 Foo::bar 调用全局函数 bar，您可以使用左侧为空的语法：

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

Answer 3

它强制进行绝对名称解析。
如果没有它，名称解析将相对于类/函数命名空间路径进行搜索。

因此，假设 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.
            }
        }
    }
}

Answer 4

这是为了强制在全局范围内查找符号。

void foo() {} // 1

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

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

Answer 5

以这种方式使用作用域运算符意味着您引用的是全局作用域。

为了节省我宝贵的时间和击键次数，请查看没有作用域的作用域解析运算符 。

Answer 6

:: 用于直接从对象外部访问该对象。