Dominance (C++)

For other uses, see Dominance.

In the C++ programming language, dominance refers to a particular aspect of C++ name lookup in the presence of inheritance. When the compiler computes the set of declarations to which a particular name might refer, declarations in very-ancestral classes which are "dominated" by declarations in less-ancestral classes are hidden for the purposes of name lookup. In other languages or contexts, the same principle may be referred to as "name masking" or "shadowing".

The algorithm for computing name lookup is described in section 10.2 [class.member.lookup] of the C++11 Standard. The Standard's description does not use the word "dominance", preferring to describe things in terms of declaration sets and hiding. However, the Index contains an entry for "dominance, virtual base class" referring to section 10.2.

Example without diamond inheritance

void f(double, double);  // at global scope

struct Grandparent {
    void f(int);
    void f(double, double);
};

struct Parent : public Grandparent {
    void f(int);  // hides all overloads of Grandparent::f
};

struct Child : public Parent {
    void g() { f(2.14, 3.17); }  // resolves to Parent::f
};

In the above example, Child::g contains a reference to the name f. However, the program as a whole contains four declarations of the name f. In order to figure out which f is meant, the compiler computes an overload set containing all the declarations which are not hidden at the point of the call. The declaration of f at global scope is hidden by Grandparent::f, and in turn Grandparent::f is hidden by Parent::f. Thus the only declaration which is considered by overload resolution is Parent::f — and the result in this case is a diagnostic, because the call-site provides two arguments where Parent::f expects only one.

It is often surprising to new C++ programmers that the declaration of Parent::f dominates and hides all of the more-ancestral declarations, regardless of signature; that is, Parent::f(int) dominates and hides the declaration of Grandparent::f(double, double) even though the two member functions have very different signatures.

It is also important to observe that in C++, name lookup precedes overload resolution. If Parent::f had multiple overloads (for example f(int) and f(double, double)), the compiler would choose between them at overload-resolution time; but during the name-lookup phase we are concerned only with choosing among the three scopes Grandparent::f, Parent::f, and ::f. The fact that Grandparent::f(double, double) would have been a better overload than f(int) is not part of the compiler's consideration.

Example with diamond inheritance

struct Grandparent {
    void f(int);
    void f(double, double);
};

struct Mother : public Grandparent {
    void f(int);  // hides all overloads of Mother::Grandparent::f
};

struct Father : public Grandparent { };

struct Child : public Mother, Father {  // Mother::Grandparent is not the same subobject as Father::Grandparent
    void g() { f(2.14, 3.17); }  // ambiguous between Mother::f and Father::Grandparent::f
};

In the above example, the compiler computes an overload set for f which contains both Mother::f and Father::Grandparent::f. The compiler produces a diagnostic indicating that the program is ill-formed because the name f is ambiguous.

Example with virtual inheritance

struct Grandparent {
    void f(int);
    void f(double, double);
};

struct Mother : public virtual Grandparent {
    void f(int);  // hides all overloads of Mother::Grandparent::f
};

struct Father : public virtual Grandparent { };

struct Child : public Mother, Father {  // Mother::Grandparent is the same subobject as Father::Grandparent
    void g() { f(2.14, 3.17); }  // resolves to Mother::f
};

In this final example, the name f once again unambiguously refers to Mother::f, because Mother::f hides the f declared in its Grandparent subobject. The Standard calls out this surprising case in an informative note (§10.2 paragraph 10):

When virtual base classes are used, a hidden declaration can be reached along a path through the subobject lattice that does not pass through the hiding declaration. This is not an ambiguity.

Even if Child itself were to inherit virtually from Grandparent, there would be no ambiguity in name lookup. However, if Child were to inherit non-virtually from Grandparent (i.e., struct Child : public Mother, Father, Grandparent), then the name would again be ambiguated (between the fs declared in the two Grandparent subobjects).

See also

• Multiple inheritance
• C3 linearization