R.10.1.1 Неоднозначности

Доступ к базовому классу должен быть задан однозначно. Доступ к

члену базового класса считается неоднозначным, если выражение,

используемое для доступа, задает более одной функции, объекта,

типа или элемента перечисления. Проверка на однозначность происходит

до проверки возможности доступа ($$R.11). Приведем пример:

class A {

public:

int a;

int (*b)();

int f();

int f(int);

int g();

};

class B {

int a;

int b();

public:

int f();

int g();

int h();

int h(int);

};

class C : public A, public B { };

void g(C* pc)

{

pc->a = 1; // ошибка: неоднозначность: A::a или B::a

pc->b(); // ошибка: неоднозначность: A::b или B::b

pc->f(); // ошибка: неоднозначность: A::f или B::f

pc->f(1); // ошибка: неоднозначность: A::f или B::f

pc->g(); // ошибка: неоднозначность: A::g или B::g

pc->g = 1; // ошибка: неоднозначность: A::g или B::g

pc->h(); // нормально

pc->h(1); // нормально

}

Если имя перегруженной функции установлено однозначно, то прежде

проверки возможности доступа происходит еще и разрешение перегрузки.

Неоднозначность можно устранить, уточняя используемое имя именем

класса, например, так:

class A {

public:

int f();

};

class B {

public:

int f();

};

class C : public A, public B {

int f() { return A::f() + B::f(); }

};

Если используются виртуальные базовые классы, до отдельной функции,

объекта, типа или элемента перечисления можно добраться несколькими

путями, двигаясь по направленному ацикличному графу, который

образуют базовые классы. Но это не является неоднозначностью.

Идентичное же использование невиртуальных базовых классов

порождает неоднозначность, поскольку в этом случае участвует в

задании доступа более одного вложенного объекта. Приведем пример:

class V { public: int v; };

class A { public: int a; };

class B : public A, public virtual V { };

class C : public A, public virtual V { };

class D : public B, public C { public: void f(); };

void D::f()

{

v++; // нормально

a++; // ошибка, неоднозначность: `a' в `D' входит дважды

}

Если используются виртуальные базовые классы, возможно что

двигаясь по направленному ацикличному графу, можно добраться более,

чем до одного имени функции, объекта или элемента перечисления. Это,

конечно, неоднозначность, но кроме случая, когда одно имя доминирует

над другими. Идентичное использование невиртуальных базовых классов

всегда приводит к неоднозначности, т.к. в этом случае всегда участвует

более одного вложенного объекта.

Считается, что имя B::f доминирует над именем A::f, если класс

A является для класса B базовым. Если одно имя доминирует над

другим, они не могут привести к неоднозначности: в ситуации выбора

используется всегда доминирующее имя. Приведем пример:

class V { public: int f(); int x; };

class B : public virtual V { public: int f(); int x; };

class C : public virtual V { };

class D : public B, public C { void g(); };

void D::g()

{

x++; // нормально: B::x доминирует над V::x

f(); // нормально: B::f() доминирует над V::f()

}

В результате явного или неявного преобразования указателя или ссылки

на производный класс в указатель или ссылку на один из его базовых

классов, эти указатель или ссылка должны указывать только на тот

же самый объект, который представляет базовый класс. Приведем пример:

class V { };

class A { };

class B : public A, public virtual V { };

class C : public A, public virtual V { };

class D : public B, public C { };

void g()

{

D d;

B* pb = &d;

A* pa = &d; // ошибка, неоднозначность: A из C или A из B?

v* pv = &d; // нормально: только один вложенный объект V

}