Question

Before asking, I had refer to this older question. But I have still queries.

struct B1 {
  virtual void fun () = 0;
};
struct B2 {
  void fun () { cout<<"B2::fun()\n"; }
  void fun (int i) {}
};
struct D : B1, B2 {
  using B2::fun;  // This line doesn't help
};

int main ()
{
  B1 *pB1 = new D;  // Error: cannot allocate 'D' because 'B1::fun()' is abstract
  pB1->fun();
}

1. Any reason for C++ standard not accepting, inherited member functions to resolve pure virtual mechanism ?
2. Why using keyword doesn’t help resolving this error ? (compiler: linux-64 g++)
3. Which function is used for using keyword, B2::fun() or B2::fun(int) ? (there is no ambiguity for that line)

Answer 1

Which function is used for using keyword, B2::fun() or B2::fun(int) ? (there is no
ambiguity for
that line )

From ISO/IEC 14882:2003(E) 7.3.3.12

When a using-declaration brings names from a base class into a derived class scope, member functions in the derived class override and/or hide member functions with the same name and parameter types in a base class (rather than conflicting).

[Example:
    struct B { 
        virtual void f(int);
        virtual void f(char); 
        void g(int); 
        void h(int);
    };

    struct D : B { 
        using B::f;
        void f(int);   // OK: D::f(int) overrides B::f(int);

        using B::g; 
        void g(char);  // OK

        using B::h; 
        void h(int);   // OK: D::h(int) hides B::h(int)
    };

    void k(D* p) {
        p->f(1);    //calls  D::f(int)
        p->f(’a’);  //calls  B::f(char)  // Notice the call being resolved
        p->g(1);    //calls  B::g(int)
        p->g(’a’);  //calls  D::g(char)
    }

— end example] 

[Note: two using-declarations may introduce functions with
the same name and the same parameter types. If, for a call to an unqualified
function name, function overload resolution selects the functions introduced
by such using-declarations, the function call is ill-formed. ]

So, in the example you provided there is no ambiguity at all. Depending up on the parameter passed, call to a method can be decided.