Comment faire pour compilateur savoir quelle surcharge d'une fonction appeler pour éviter toute ambiguïté?

Question

J'ai un code comme ci-dessous et je ne comprends pas pourquoi exactement le compilateur ne peut pas déduire le constructeur à utiliser quand l'instance de classe D est créée. J'ai supprimé à la fois copier et déplacer constructeur de sorte que la seule alternative serait d'utiliser une (base &)

Est-ce il y a une façon de dire compilateur d'utiliser A (base &) constructeur, en plus de coulée * ce à la base & .

class Base {}; 

class A 
{ 
    private: 
    Base& m_b; 
    public: 

    A(Base& b) :m_b(b) {} 
    A(const A&) = delete; 
    A(A&&) = delete; 
}; 

class D : public Base, public A 
{ 
    public: 
    D():A(*this){} 

}; 

int main() 
{ 
    D(); 
} 

L'erreur que je reçois est la suivante:

main.cpp: In constructor 'D::D()': 
main.cpp:17:16: error: call of overloaded 'A(D&)' is ambiguous 
    D():A(*this){} 
       ^
main.cpp:10:5: note: candidate: A::A(const A&) <deleted> 
    A(const A&) = delete; 
    ^
main.cpp:9:5: note: candidate: A::A(Base&) 
    A(Base& b) :m_b(b) {} 

Answer 1

Ajouter un casting:

D():A(static_cast<Base&>(*this)){} 

Cela forcera l'expression à avoir le type qui correspond à votre surcharge désirée. La simple suppression d'une fonction ou d'un c'tor ne la supprime pas du jeu de surcharge, ce qui explique l'ambiguïté de cette fonction. Cela rendrait seulement le compilateur considérer le programme comme mal formé si la fonction est choisie de toutes les surcharges disponibles.

Answer 2

Vous pouvez lancer le pointeur avant déréférencement il:

D() :A(*(Base*)this) {} 

ou

D() :A(*static_cast<Base*>(this)) {}