Perché viene utilizzata una funzione non valida anziché una conversione implicita?

Question

Questo è il mio Snippet:

class Base{}; 

class Derived : private Base{}; 

template<class T> 
class Wrapper 
{ 
    public: 
     template<typename T2> 
     Wrapper(T2&&) 
     { } 
}; 

// Function declarations 
void func(Base& param); 
void func(Wrapper<Derived>); 
void funcUnambiguous(Wrapper<Derived>); 


// Here is the Call: 
Derived d = Derived(); 
func(d);    // <- Error 

GCC 4.9 mi dà: error: 'Base' is an inaccessible base of 'Derived'

Mentre faccio

Derived d = Derived(); 

funcUnambiguous(d); 

funziona bene.

Sembra che qualsiasi funzione che richiede solo un cast economico, anche se non valida, nasconde le funzioni implicite, ma costose. Qualcuno ha idea?

Answer 1

Aggiornato, grazie a @ T.C. ctor

Wrapper 's è un modello conversione definita dall'utente, quindi la non-templateconversione standard sequenza sovraccarico con Base& prevale. Il controllo di accesso viene eseguito solo dopo il selezionando il sovraccarico, che è troppo tardi nel tuo caso.

Le regole complete sono complicate, altre possono essere trovate here, guarda la sezione "La migliore funzione valida".