perché protetto non protegge il membro in questa classe?

Question

class Base { 
    protected: 
     union { 
      struct { 
       bool bBold : 1; 
       bool bFakeBold : 1; 
      }; 
      int a; 
     }; 
    public: 
     bool isBold() { 
      return bBold; 
     } 
}; 

classe Test:

#include <assert.h> 
#include <stdio.h> 

int main() 
{ 
    Base d; 
    d.bBold = false; 
    assert(d.isBold() == false); 
    d.bBold = true; 
    assert(d.isBold() == true); 
    printf("good"); 
    return 0; 
} 

Sia msvc11 e g ++ compilare senza alcun errore.

Perché?

Answer 1

Il seguente codice non è corretto per lo standard.

 struct { 
      bool bBold : 1; 
      bool bFakeBold : 1; 
     }; 

E 'GNU-extension

Tuttavia, clang dà l'errore, quando si tenta di ottenere l'accesso a bBold, quindi, è probabilmente MSVC/GCC bug (tutto dipende realizzazione di questa estensione, credo, perché se prova ad accedere al membro a - riceverai l'errore corretto).

Quindi, dal momento che è C-extension, in cui non abbiamo specificatori di accesso, sembra che i membri di questa struttura anonima vengano inseriti nella sezione public.

Answer 2

Il privato/protetto protegge solo i campi definiti nella stessa classe della parola chiave. Se si potrebbe fare il seguente trucco:

class Foo { 
    private: 
    class Bar { 
     public: 
     int x; 
    } 
    public: 
    typedef Bar PublicBar; 
} 

è ancora possibile accedere Foo::PublicBar::x

struct X { ... } è oggigiorno in C++ sinonimo di class X { public: ... }. Anche i campi sindacali sono pubblici.

Nel tuo caso, è possibile nasconderlo nel seguente modo:

class Base { 
protected: 
    union X { 
     struct { 
      bool bBold : 1; 
      bool bFakeBold : 1; 
     }; 
     int a; 
    }; 
    X x; 
public: 
    bool isBold() { 
     return x.bBold; 
    } 
}; 

Ora x è privata e la definizione di unione interiore non "fuga" in pubblico.

Answer 3

Come già accennato, le strutture senza nome sono un'estensione non standard. Poiché questa è un'estensione non standard, è valida per diversi compilatori implementarlo in modo leggermente diverso. Tuttavia, per le unioni anonime, esiste la stessa domanda. esempio modificato:

class C { 
    union { 
     union { 
      int i; 
     }; 
    }; 
}; 
int main() { 
    C c; 
    c.i = 0; 
    return c.i; 
} 

Questo dovrebbe causare una fase di compilazione errore/avviso/o diagnostica, ma GCC felicemente lo accetta. Testato con 4.5.3 e 4.7.2 di Ideone. Sospetto che questo sia un bug in GCC e, se MSVC lo accetta, anche un bug in MSVC.