Knowing how pointers to variables and objects are used does not intuitively
lead to the concept of em(pointers to members) hi(pointer: to member). Even if
the return types and parameter types of member functions are taken into
account, surprises can easily be encountered.  For example, consider the
following class:
        verb(    class String
    {
        char const *(*d_sp)() const;

        public:
            char const *get() const;
    };)

For this class, it is not possible to let tt(char const *(*d_sp)() const)
point to the tt(String::get) member function as tt(d_sp) cannot be given the
address of the member function tt(get).

    One of the reasons why this doesn't work is that the variable tt(d_sp) has
hi(scope: global)i(global scope) (it is a pointer to em(a) function, not a
pointer to a function within tt(String)), while the member function tt(get) is
defined within the tt(String) class, and thus has tt(class scope). The fact
that tt(d_sp) is a data member of the class tt(String) is irrelevant
here. According to tt(d_sp)'s definition, it points to a function living
somewhere em(outside) of the class.

Consequently, to define a pointer to a member (either data or function, but
usually a function) of a class, the scope of the pointer must indicate
hi(scope: class)i(class scope).  Doing so, a pointer to the member
tt(String::get) is defined like this:
        verb(    char const *(String::*d_sp)() const;)

So, by prefixing the tt(*d_sp) pointer data member by tt(String::), it is
defined as a pointer in the context of the class tt(String). According to its
definition it is em(a pointer to a function in the class tt(String), not
expecting arguments, not modifying its object's data, and returning a pointer
to constant characters).
