class Base
{
public:
protected:
    void test();
};

class Derived : public Base
{
public:
    using Base::test;
};


int main()
{
    using namespace std;
    Derived d;
    d.test();
    vector<Derived> v;
    &Derived::test;
    for_each(v.begin(), v.end(), mem_fun_ref(&Derived::test));
}

d.test();

class Base
{
public:
protected:
    void test(){}

    int a;
};

class Derived : public Base
{
public:
    using Base::test;
    using Base::a;
    //Base::a;
};


void mem_fun_test()
{
    Derived d;
    d.test();
    d.a = 10;
    int Derived::* pa = &Derived::a;

    d.*pa = 100;
    void (Derived::* f)() =  &Derived::test;    
}

Compiling...
main.cpp
c:\...\main.cpp(31) : error C2248: 'Base::test' : cannot access protected member declared in class 'Base'
c:\...\main.cpp(9) : see declaration of 'Base::test'
c:\...\main.cpp(6) : see declaration of 'Base'
Build log was saved at "file://c:\...\BuildLog.htm"
mem_fun_test — 1 error(s), 0 warning(s)

Your Comeau C/C++ test results are as follows:

Comeau C/C++ 4.3.9 (Mar 27 2007 17:24:47) for ONLINE_EVALUATION_BETA1
Copyright 1988-2007 Comeau Computing. All rights reserved.
MODE:strict errors C++ C++0x_extensions

А>>

For the purpose of overload resolution, the functions which a 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

DB>Объясни, пожалуйста, как эта цитата связана с исходным примером и как она объясняет ошибки компиляции?

&Derived::test;

error C2248: 'Base::test' : cannot access protected member declared in class 'Base'

class A
{
public:
    A operator + (const A)const;
};

class B : public A
{
public:
   //using A::operator + ;
};

B operator + (const B &, const A &);

int main()
{
   A a;
   B b;
   b + a;
}

struct A{
   virtual void f();
};
struct B: A{
   using A::f;
   void f();
};

D>struct A{
D>   virtual void f();
D>};
D>struct B: A{
D>   using A::f;
D>   void f();
D>};

//дополним ваш код
int main()
{
   B b;
   b.f();
}
D>

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);
};
121
ISO/IEC 14882:2003(E)  ISO/IEC
7.3.3 The usingdeclaration 7 Declarations
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)
p->g(1); //calls B::g(int)
p->g(’a’); //calls D::g(char)
}

The alias created by the using-declaration has the usual accessibility for a member-declaration.
[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]

class Base
{
public:
protected:
    void test();
};

class Derived : public Base
{
public:
    using Base::test;
};


int main()
{
    using namespace std;
    Derived d;
    d.test();
    vector<Derived> v;
    &Derived::test;
    for_each(v.begin(), v.end(), mem_fun_ref(&Derived::test));
}

struct a{
    virtual void f();
};

struct b : virtual public a{
    virtual void f();
};

struct c : b, virtual a{
    using a::f;
};

int main()
{
    using namespace std;
    с d;
    d.f(); //b по стандарту
    vector<с> v;
    for_each(v.begin(), v.end(), mem_fun_ref(&с::f));//угадайте какая? 
}