C++ imperfect (四) -- override and/or hide member functions in the base class

      When a  using-declaration brings names from a base class into a derived class scope, member functions and member function templates in the derived class override and/or hide member functions and member function  templates  with  the  same  name,  parameter-type-list  (8.3.5),  cv-qualification,  and  ref-qualifier (if  any)  in  a  base class (rather than conflicting).  ( ISO/IEC 14882:2011(E)  § 7.3.3 )

    Example:

#include <iostream>

using namespace std;

struct B
{
    virtual void f(int)
    {
        cout<<"struct B member[virtual void f(int)] called"<<endl;
    };

    virtual void f(char)
    {
        cout<<"struct B member[virtual void f(char)] called"<<endl;
    };

    void g(int)
    {
        cout<<"struct B member[void g(int)] called"<<endl;
    };

    void h(int)
    {
        cout<<"struct B member[void h(int)] called"<<endl;
    };
};

struct D : B
{
    using B::f;
    void f(int) // OK: D::f(int) overrides B::f(int);
    {
        cout<<"struct D member[void f(int)] called"<<endl;
    };

    using B::g;
    void g(char) // OK
    {
        cout<<"struct D member[void g(char)] called"<<endl;
    };

    using B::h;
    void h(int) // OK: D::h(int) hides B::h(int)
    {
        cout<<"struct D member[void h(int)] called"<<endl;
    };
};

void k(D* p)
{
    p->f(1); // calls D::f(int)
    p->f('a'); // calls B::f(char)
    p->g(1); // calls B::g(int)
    p->g('a'); // calls D::g(char)
    p->h(1); // calls D::h(int)
}

int main(int argc, char* argv[])
{
    D test;

    k(&test);

    return 0;
}

result:

struct D member[void f(int)] called
struct B member[virtual void f(char)] called
struct B member[void g(int)] called
struct D member[void g(char)] called
struct D member[void h(int)] called

     For  the  purpose  of  overload  resolution,  the  functions  which  are  introduced  by  a  using-declaration  into  a derived class will be treated as though they were members of the derived class.  In particular, the implicit this  parameter  shall  be  treated  as  if  it  were  a  pointer  to  the  derived  class  rather  than  to  the  base  class. This has no effect on the type of the function, and in all other respects the function remains a member of  the base class.   

     The access rules for inheriting constructors are speci?ed in 12.9; otherwise all instances of the name mentioned  in a  using-declaration shall be accessible.  In particular, if a derived class uses a  using-declaration to access  a  member  of  a  base  class,  the  member name shall  be accessible.  If  the  name  is  that  of  an overloaded member  function,  then  all  functions  named  shall  be accessible.  The  base  class  members  mentioned  by  a using-declaration shall be visible in the scope of at least one of the direct base classes of the class where the using-declaration is speci?ed. 
[ Note:  Because a  using-declaration designates a base class member (and not a member subobject or a member function of a base class subobject), a using-declaration cannot be used to resolve inherited member ambiguities.  For example,

            struct   A {  int  x();  };
            struct   B :  A {  };
            struct   C :  A {
              using   A::x;
               int  x(int);
            };

            struct   D :  B,  C {
              using   C::x;
               int  x(double);
            };
            int  f(D*  d)  {
              return   d->x();       // ambiguous:  B::x  or  C::x
            }

 — end note ]

    The  alias  created  by  the  using-declaration  has  the  usual  accessibility  for  a  member-declaration.   [ Note:  A using-declaration  that  names  a  constructor  does  not  create  aliases;  see  12.9 for  the  pertinent  accessibility  rules.   — end note ]
[ Example:

            class   A {
            private:
                 void  f(char);
            public:
                 void  f(int);
            protected:
                 void  g();
            };

            class   B :  public  A  {
              using   A::f;          // error:  A::f(char)  is inaccessible
            public:
              using   A::g;          // B::g  is a public synonym for  A::g
            };

— end example ]