Question

A point from the ISO C++ draft (n3290): 3.4.3.2/1 Namespace members

If the nested-name-specifier of a qualified-id nominates a namespace,
the name specified after the nested-name-specifier is looked up in
the scope of the namespace. If a qualified-id starts with ::, the
name after the :: is looked up in the global namespace. In either
case, the names in a template-argument of a template-id are looked up
in the context in which the entire postfix-expression occurs.

Here can any one explain about the BOLD part …. and from earlier c++03 draft to c++0x draft he added

If a qualified-id starts with ::, the name after the :: is looked up
in the global namespace.

can any one explain with an example program please

Answer 1

::S is a qualified-id.

In the qualified-id ::S::f, S:: is a nested-name-specifier.

In informal terms, a nested-name-specifier is the part of the id that

• begins either at the very beginning of a qualified-id or after the initial scope resolution operator (::) if one appears at the very beginning of the id and
• ends with the last scope resolution operator in the qualified-id.

Very informally, an id is either a qualified-id or an unqualified-id. If the id is a qualified-id, it is actually composed of two parts: a nested-name specifier followed by an unqualified-id.

Given:

struct  A {
    struct B {
        void F();
    };
};

• A is an unqualified-id.
• ::A is a qualified-id but has no nested-name-specifier.
• A::B is a qualified-id and A:: is a nested-name-specifier.
• ::A::B is a qualified-id and A:: is a nested-name-specifier.
• A::B::F is a qualified-id and both B:: and A::B:: are nested-name-specifiers.
• ::A::B::F is a qualified-id and both B:: and A::B:: are nested-name-specifiers.

Another example:

#include <iostream>
using namespace std;

int count(0);                   // Used for iteration

class outer {
public:
    static int count;           // counts the number of outer classes
    class inner {
    public:
        static int count;       // counts the number of inner classes
    };
};

int outer::count(42);            // assume there are 42 outer classes
int outer::inner::count(32768);  // assume there are 2^15 inner classes
                                 // getting the hang of it?

int main() {
    // how do we access these numbers?
    //
    // using "count = ?" is quite ambiguous since we don't explicitly know which
    // count we are referring to.
    //
    // Nested name specifiers help us out here

    cout << ::count << endl;        // The iterator value
    cout << outer::count << endl;           // the number of outer classes instantiated
    cout << outer::inner::count << endl;    // the number of inner classes instantiated
    return 0;
}

EDIT:

In response to your comment, I believe that statement simply means that the arguments of a template are handled w.r.t the context and line by which they are declared. For example,

in f.~foo();, foo is looked up within f., and within the scope of foo<int>, it is valid to refer to it just with with foo.