Possono esserci due sezioni pubbliche in una classe? Se sì allora perché? E in quali circostanze lo facciamo?

Question

C'è qualcosa che mi infastidisce sulle lezioni. Ad esempio

class A 
{ 
public: 
    A() 
    { 
    ..... 
    ..... 
    } 

    void cleanup() 
    { 
    .... 
    .... 
    .... 
    } 

public: 
    UINT a; 
    ULONG b; 
}; 

Nell'esempio precedente ci sono due sezioni pubbliche. Nella prima sezione sto definendo un costruttore e un metodo e nella seconda sezione sto dichiarando i membri dei dati. È la classe di cui sopra, ad es. Possiamo farlo? Se sì allora perché è necessario e in quali circostanze dovremmo usarlo? Dal momento che possiamo fare l'intera cosa in una sezione, perché ci sono due sezioni?

Answer 1

I qualificatori di accesso si applicano semplicemente al codice che segue fino al prossimo qualificatore. Non ci sono restrizioni sul numero o sull'ordine di tali qualificatori.

In genere non è necessario ripetere lo stesso qualificatore di accesso in una classe, e ciò potrebbe confondere il lettore. Possono anche avere un effetto sul layout di una classe, poiché i membri dei dati che seguono lo stesso qualificatore devono essere disposti nell'ordine in cui sono dichiarati, ma non esiste tale restrizione tra i qualificatori.

Answer 2

La classe è corretta, pubblica è solo un qualificatore di accesso e verrà applicata fino alla successiva qualifica o alla dichiarazione di fine classe. Non c'è limite al numero di questi qualificatori di accesso (pubblici, privati, protetti) che puoi avere in una classe. Per quanto riguarda il motivo per cui è utile, aiuta a scrivere le dichiarazioni di classe nel modo desiderato. Ad esempio, potrei desiderare che tutte le funzioni membro (pubbliche, protette o private) dichiarate prima dei membri di dati privati ​​(ad esempio).

Answer 3

Come dice Marcelo, è possibile utilizzare le qualificazioni pubbliche, private e protette tutte le volte che si desidera. "Quando" è interamente personale. Alcune persone piace questo:

class AClass 
{ 
public: 
    // all the public stuff 
protected: 
    // all the protected stuff 
private: 
    // all the private stuff 
}; 

ma personalmente (e questo è davvero solo una preferenza personale) mi piace fare questo:

class AClass 
{ 
    // constructors and destructors 
public: 
    // public cons/dest 
protected: 
    // protected cons/dest 
private: 
    // private cons/dest 

    // accessors 
public: 
protected: 
private: 

    // methods 
public: 
protected: 
private: 

    // members 
public: 
protected: 
private: 
}; 

Sentitevi liberi di venire con il proprio stile, qualunque cosa tu' re comodo con. Non esiste un modo giusto o sbagliato di farlo. Cerca di essere coerente.

Answer 4

Sì, è corretto, ma personalmente preferisco avere solo una sezione pubblica in cima alla classe, ecco dove i programmatori guardano prima quando esaminano una nuova classe. È quindi più facile vedere quali parti dovrebbero essere accessibili e quali no, invece di sfogliare l'intera intestazione della classe.

Answer 5

Come spiega @Marcelo Cantos's answer, questo è consentito. Quando scrivi il codice da solo, dovresti evitare questo, poiché porta solo a confusione quando gli altri leggono il tuo codice. L'unico posto in cui io abbia mai visto questo nella vita reale è nel codice generato da vari maghi MFC. Ogni volta che aggiungi qualcosa alla tua classe usando una procedura guidata, aggiungerebbe una sezione aggiuntiva alla fine della lezione.

Answer 6

Di solito provo ad organizzare la dichiarazione della classe in modo che sia facile per gli altri usare la suddetta classe.

Il solito è così: public/protected/private, in questo ordine, perché semplifica la vita dei lettori.

• Le persone che usano la classe possono smettere di leggere una volta raggiunto il tag protected, qualsiasi cosa dopo non è la loro preoccupazione.
• Le persone che derivano dalla classe possono smettere di leggere una volta raggiunto il tag private, qualsiasi cosa dopo i dettagli dell'implementazione.

Questo, unito con non scrivere il codice dei metodi al loro punto di dichiarazioni, rende per un facile da leggere interfaccia.

ci sono comunque un paio di trucchi:

• quando si utilizza la programmazione metatemplate, potrebbe essere necessario dichiarare tipi prima, metodi dopo, così si finisce con 2 serie di public/protected/private
• quando si utilizza il Chiave idioma (anziché friend), si dispone di una sezione public che è in realtà dedicata solo a una piccola porzione degli utenti ed è la migliore isolata nella parte inferiore della normale sezione public o dopo la sezione protected.

Infine, come per commentare il problema layout tra gli attributi. Incapsulamento significa che gli attributi dovrebbero essere private. Quindi, o hai un struct e tutto è public o hai una classe e tutto è private, mescolando i due mezzi che rompono l'incapsulamento, e questo è un bug in divenire.