struct A
{
   virtual void fun(){}
};

struct B:virtual public A
{
   void fun(){}
};

struct C:B, virtual A
{
    using A::fun;
};

void foo()
{
   C c;
   c.fun();//Стандарт говорит, что здесь д.б. вызван final overrider
   //это так? а то у меня вызывается A::fun.
}

А>struct A
А>{
А>   virtual void fun(){}
А>};

А>struct B:virtual public A
А>{
А>   void fun(){}
А>};

А>struct C:B, virtual A
А>{
А>    using A::fun;
А>};

А>void foo()
А>{
А>   C c;
А>   c.fun();//Стандарт говорит, что здесь д.б. вызван final overrider
А>   //это так? а то у меня вызывается A::fun.
А>}

R>void foo()
R>{
R>   C c;
R>   A* pa = &c;
R>   c.fun();   // Вот тут вызывается A::fun

   pa->>fun(); // А вот тут B::fun - хехе, так на то и виртуальная функция. Здесь все
// правильно, это и есть final overrider

}

R>>void foo()
R>>{
R>>   C c;
R>>   A* pa = &c;
R>>   c.fun();   // Вот тут вызывается A::fun
L_L>
   pa->>>fun(); // А вот тут B::fun - хехе, так на то и виртуальная функция. Здесь все
L_L>// правильно, это и есть final overrider
L_L>
L_L>}

L_L>

namespace A
{
 void fun();
};

void f()
{
  using namespace A;
  fun(); // это место приводится к A::fun
}

struct A 
{ 
  virtual void fun() {}
}; 

struct B:virtual public A 
{ 
  void fun() {} 
}; 

struct C:B, virtual A 
{ 
  using A::fun; // (0)
}; 

void foo() 
{ 
  C c; 
  c.fun(); // C::fun() == A::fun() (1)

  A* p = &c;
  p->fun(); // полиморфный вызов   (2)
}

#include <stdio.h>
struct A
{
   virtual void fun(){ printf("A::f\n"); }
};

struct B:virtual public A
{
   virtual void fun(){ printf("B::f\n"); }
};

struct C:B, virtual A
{
    using A::fun;
};

void g(C* pc)
{
 pc->fun();
}

void main()
{
   C c;
   A* pa = &c;
   c.fun();    // A::fun
   g(&c);      // B::fun
   pa->fun();  // B::fun
}

J>Именно это и написано в Стандарте прямо над цитируемым примером. (Правда, там не упоминается вмт )

...
  c.f(); // calls B::f(), the final overrider
...

А>> struct A
А>> {
А>>   virtual void fun(){}
А>> };

А>> struct B:virtual public A
А>> {
А>>   void fun(){}
А>> };

А>> struct C:B, virtual A
А>> {
А>>    using A::fun;
А>> };

А>> void foo()
А>> {
А>>   C c;
А>>   c.fun();//Стандарт говорит, что здесь д.б. вызван final overrider
А>>   //это так? а то у меня вызывается A::fun.
А>> }
А>>

The rules for member lookup (10.2) are used to determine the final overrider for a virtual
function in the scope of a derived class but ignoring names introduced by using-declarations.

#include <iostream>

struct A
{
  virtual void fun(int) { std::cout << "A::fun(int)" << std::endl;   }
  void fun(float)       { std::cout << "A::fun(float)" << std::endl; }
};

struct B : virtual A
{
  void fun(int)   { std::cout << "B::fun(int)" << std::endl; }
  void fun(float) { std::cout << "B::fun(float)" << std::endl; }
};

struct C : B, virtual A
{
  using A::fun;
};

int main()
{
  C c;
  c.fun(10);    // B::fun(int)
  c.fun(1.0f);  // A::fun(float)

  A* p = &c;
  p->fun(10);   // B::fun(int)
  p->fun(1.0f); // A::fun(float)
}

> como main_nv.cpp
Comeau C/C++ 4.3.0.1 (Aug 21 2002 15:45:32) for MS_WINDOWS_x86
Copyright 1988-2002 Comeau Computing.  All rights reserved.
MODE:strict warnings C++

> aout
B::fun(int)
A::fun(float)
B::fun(int)
A::fun(float)

> cl /GX main_nv.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

main_nv.cpp
Microsoft (R) Incremental Linker Version 7.10.3077
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:main_nv.exe
main_nv.obj

> main_nv
B::fun(int)
A::fun(float)
B::fun(int)
A::fun(float)

> bcc32 main_nv.cpp
Borland C++ 5.6 for Win32 Copyright (c) 1993, 2002 Borland
main_nv.cpp:
Turbo Incremental Link 5.60 Copyright (c) 1997-2002 Borland

> main_nv
B::fun(int)
A::fun(float)
B::fun(int)
A::fun(float)

R> #include <stdio.h>
R> struct A
R> {
R>    virtual void fun(){ printf("A::f\n"); }
R> };

R> struct B:virtual public A
R> {
R>    virtual void fun(){ printf("B::f\n"); }
R> };

R> struct C:B, virtual A
R> {
R>     using A::fun;
R> };

R> void g(C* pc)
R> {
R>  pc->fun();
R> }

R> void main()
R> {
R>    C c;
R>    A* pa = &c;
R>    c.fun();    // A::fun
R>    g(&c);      // B::fun
R>    pa->fun();  // B::fun
R> }
R>

> cl main2.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.10.3077 for 80x86
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

main2.cpp
Microsoft (R) Incremental Linker Version 7.10.3077
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:main2.exe
main2.obj

> main2
B::f
B::f
B::f

10.3 Explicit qualification with the scope operator (5.1) suppresses the virtual call mechanism.

class A
{
public:
    virtual void fun();
};

class A1
{
public:
    virtual void fun();
};

class B:public A
{
public:
    void fun();
};

class C:public A1
{
public:
};

class D:public B, public C
{
public:
    using C::fun;
};

void g()
{
    D d;
    d.fun();
}