Warum kann ich auto für einen privaten Typ verwenden?

Ich war irgendwie überrascht, dass der folgende Code kompiliert und ausgeführt wird (vc2012 & gcc4.7.2)

class Foo {
    struct Bar { int i; };
public:
    Bar Baz() { return Bar(); }
};

int main() {
    Foo f;
    // Foo::Bar b = f.Baz();  // error
    auto b = f.Baz();         // ok
    std::cout << b.i;
}

Ist es richtig, dass dieser Code gut kompiliert wird? Und warum ist es richtig? Warum kann ich autoeinen privaten Typ verwenden, während ich seinen Namen nicht verwenden kann (wie erwartet)?

Die Regeln für autosind größtenteils dieselben wie für den Abzug von Vorlagentypen. Das veröffentlichte Beispiel funktioniert aus demselben Grund, aus dem Sie Objekte privaten Typs an Vorlagenfunktionen übergeben können:

template <typename T>
void fun(T t) {}

int main() {
    Foo f;
    fun(f.Baz());         // ok
}

Und warum können wir Objekte privaten Typs an Vorlagenfunktionen übergeben, fragen Sie? Weil nur auf den Namen des Typs nicht zugegriffen werden kann. Der Typ selbst ist weiterhin verwendbar, weshalb Sie ihn überhaupt an den Clientcode zurückgeben können.

Die Zugriffskontrolle wird auf Namen angewendet . Vergleichen Sie mit diesem Beispiel aus dem Standard:

class A {
  class B { };
public:
  typedef B BB;
};

void f() {
  A::BB x; // OK, typedef name A::BB is public
  A::B y; // access error, A::B is private
}

Diese Frage wurde sowohl von chill als auch von R. Martinho Fernandes bereits sehr gut beantwortet.

Ich konnte die Gelegenheit einfach nicht verpassen, eine Frage mit einer Harry-Potter-Analogie zu beantworten:

class Wizard
{
private:
    class LordVoldemort
    {
        void avada_kedavra()
        {
            // scary stuff
        }
    };
public:
    using HeWhoMustNotBeNamed = LordVoldemort;

    friend class Harry;
};

class Harry : Wizard
{
public:
    Wizard::LordVoldemort;
};

int main()
{
    Wizard::HeWhoMustNotBeNamed tom; // OK
    // Wizard::LordVoldemort not_allowed; // Not OK
    Harry::LordVoldemort im_not_scared; // OK
    return 0;
}

https://ideone.com/I5q7gw

Vielen Dank an Quentin, der mich an die Harry-Lücke erinnert hat.

So fügen Sie zu den anderen (gut) Antworten, hier ist ein Beispiel von C ++ 98 , die zeigt , dass das Problem wirklich nicht mit dem zu tun hat autoüberhaupt

class Foo {
  struct Bar { int i; };
public:
  Bar Baz() { return Bar(); }
  void Qaz(Bar) {}
};

int main() {
  Foo f;
  f.Qaz(f.Baz()); // Ok
  // Foo::Bar x = f.Baz();
  // f.Qaz(x);
  // Error: error: ‘struct Foo::Bar’ is private
}

Die Verwendung des privaten Typs ist nicht verboten, es wurde nur der Typ benannt. Das Erstellen einer unbenannten temporären Datei dieses Typs ist beispielsweise in allen Versionen von C ++ in Ordnung.