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).
