scope resolution operator without a scope

Question

In C++, what is the purpose of the scope resolution operator when used without a scope? For instance:

::foo();

Answer 1

referring to the global scope

Answer 2

When you already have a function named foo() in your local scope but you need to access the one in the global scope.

Answer 3

My c++ is rusty but I believe if you have a function declared in the local scope, such as foo() and one at global scope, foo() refers to the local one. ::foo() will refer to the global one.

Answer 4

It means global scope. You might need to use this operator when you have conflicting functions or variables in the same scope and you need to use a global one. You might have something like (this likely won't compile!):

void bar();    // this is a global function

class foo {
    void some_func() { ::bar(); }    // this function is calling the global bar() and not the class version
    void bar();                      // this is a class member
};

If you need to call the global bar() function from within a class member function, you should use ::bar() to get to the global version of the function.

Answer 5

Also you should note, that name resolution happens before overload resolution. So if there is something with the same name in your current scope then it will stop looking for other names and try to use them.

void bar() {};
class foo {
    void bar(int) {};
    void foobar() { bar(); } // won't compile needs ::bar()
    void foobar(int i) { bar(i); } // ok
}

Answer 6

What happens in this case? It compiles, but appears to use the wrong definition/signature when calling bar().

void bar(int) {};

class foo { void bar() { int i = 1; :: bar(i); }; }