Perché posso utilizzare l'auto su un tipo privato?

Question

Sono stato in qualche modo sorpreso che il seguente codice compilato ed eseguito (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; 
} 

È vero che questo codice compila bene? E perché è corretto? Perché posso usare auto su un tipo privato, mentre non posso usare il suo nome (come previsto)?

Answer 1

Le regole per auto sono, per la maggior parte, identiche a quelle per la deduzione del tipo di modello. L'esempio lavori inviati per lo stesso motivo è possibile passare oggetti di tipo private per funzioni template:

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

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

E perché siamo in grado di passare gli oggetti di tipo private per funzioni template, vi chiederete? Perché solo il nome del tipo è inaccessibile. Il tipo stesso è ancora utilizzabile, motivo per cui è possibile restituirlo al codice cliente.

Answer 2

Il controllo di accesso viene applicato ai nomi . Confronta con questo esempio dallo 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 
} 

Answer 3

Per aggiungere agli altri (buono) risposte, ecco un esempio da C++ 98 che illustra che la questione in realtà non ha a che fare con auto affatto

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 
} 

L'utilizzo del tipo privato non è vietato, era solo la denominazione del tipo. Creare un temporaneo senza nome di quel tipo va bene, per esempio, in tutte le versioni di C++.

Answer 4

Questa domanda ha già avuto una risposta molto buona sia dal freddo che da R. Martinho Fernandes.

io proprio non poteva lasciarsi sfuggire l'occasione per rispondere a una domanda con un'analogia Harry Potter:.

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

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