Hintergrundinformation: Dies wurde in Visual Studio 2008 erkannt und in Visual Studio 2013 erneut bestätigt. G ++ schrie den Code an, während Visual die Verletzung der privaten Vererbung stillschweigend akzeptierte.

In Visual C ++ haben wir also den folgenden Code:

class Base {};
class Derived : Base {};      // inherits privately. Adding explicitly the
                              //    keyword private changes nothing

int main()
{
   std::auto_ptr<Base>(new Derived) ;   // compiles, which is NOT EXPECTED
   std::auto_ptr<Base> p(new Derived) ; // Does not compile, which is expected
}

Warum würde das erste (temporäre) auto_ptr kompilieren? Ich habe es im Debug-Modus verwendet. Es hat genau das getan, was mit einer öffentlichen Vererbung zu tun hat (ruf den richtigen Konstruktor usw. an).

Als ich mich fragte, ob das Problem möglicherweise bei der auto_ptr-Implementierung lag (wir wissen es nie ...), reduzierte ich das Problem bei diesem eigenständigen Code:

class Base {};
class Derived : Base {};

template <typename T>
class Ptr
{
   T * m_p;

   public :
      Ptr(T * p_p)
         : m_p(p_p)
      {
      }
} ;

int main()
{
   Ptr<Base>(new Derived) ;   // compiles, which is NOT EXPECTED
   Ptr<Base> p(new Derived) ; // Does not compile, which is expected
}

Wieder erwartete ich, dass der Code NICHT kompiliert wird, da Derived privat von Base erbt.

Aber wenn wir eine temporäre erstellen, funktioniert es.

Und wir können es nicht auf std :: auto_ptr schieben.

Enthält der Standard etwas (entweder 98 oder 11 oder 14), das ich verpasst habe, oder handelt es sich um einen Fehler?