Question about :: operator

[C_Sparky]

whats the difference between:

return ::CallNextHookEx(sg_hGetMsgHook, code, wParam, lParam);

and

return CallNextHookEx(sg_hGetMsgHook, code, wParam, lParam);

Also, I've seen source which calls a class member function by

object::function();

How is it doing this, since I call functions like:

object.function();

I think I read about that long ago, I'm not too experienced with c++ classes however.

[Elysia]

It's the scope operator. In the first example, the difference is that the first one will always look in the global namespace. The second will look in whatever current namespace it's in plus the global namespace. So if you a function named A in the global namespace and in namespace B and you happen to be defining a function inside namespace B and you to use the global function A, you prefix it with :: to use the global one.

The second syntax depends on what object and function is. The :: operator can be used to access members of a namespace. Any static members inside a class are said to be part of the class's namespace. Thus, to access them, you would type the class's name followed by :: and the name of whatever you want to access.

[King Mir]

Namespace isn't the proper term here. It simply defines a identifier scope.

But the other parts are right. :: is used to access static methods, while . is used to access regular "instance" methods.

[grumpy]

Namespace isn't the proper term here. It simply defines a identifier scope.

A namespace is an alternative name for an identifier scope.

[cpjust]

I've heard some people say that ::function() means run function() from the previous namespace (ex. for nested namespaces) and others say it means the global namespace.

From my tests (with VC++ 2008) it means the global namespace, but if anyone has a copy of the Standard, can you see which is true?

[tabstop]

Why yes, I can!




Oh, you probably wanted to know what the answer was.

Members declared by a using-declaration can be referred to by explicit qualification just like other member
names (3.4.3.2). In a using-declaration, a prefix :: refers to the global namespace.

There's also this, in the context of expressions instead of using declarations:

The operator :: followed by an identifier, a qualified-id, or an operator-function-id is a primaryexpression.
Its type is specified by the declaration of the identifier, qualified-id, or operator-function-id.
The result is the entity denoted by the identifier, qualified-id, or operator-function-id. The result is an
lvalue if the entity is a function or variable. The identifier, qualified-id, or operator-function-id shall have
global namespace scope or be visible in global scope because of a using-directive (7.3.4). [Note: the use of
:: allows a type, an object, a function, an enumerator, or a namespace declared in the global namespace to
be referred to even if its identifier has been hidden (3.4.3). ]

[Mario F.]

A namespace is an alternative name for an identifier scope.

Hmm, no. A class defines a class scope. A namespace defines a namespace scope. A namespace declarative region differs from a class declarative region in that it can be unnamed and it can span across several translation units.

A namespace is an optionally-named declarative region. The name of a namespace can be used to access entities declared in that namespace; that is, the members of the namespace. Unlike other declarative regions, the definition of a namespace can be split over several parts of one or more translation units.