C++ di accesso di classe Verbosity

Question

Una classe "classica" C++ (solo alcune dichiarazioni casuali) potrebbe essere simile al seguente:

class Foo 
{ 
public: 
    Foo(); 
    explicit Foo(const std::string&); 
    ~Foo(); 

    enum FooState 
    { 
    Idle, Busy, Unknown 
    }; 

    FooState GetState() const; 
    bool GetBar() const; 
    void SetBaz(int); 

private: 
    struct FooPartialImpl; 

    void HelperFunction1(); 
    void HelperFunction2(); 
    void HelperFunction3(); 

    FooPartialImpl* m_impl; // smart ptr 
    FooState m_state; 
    bool m_bar; 
    int m_baz; 
}; 

ho sempre trovato questo tipo di specifica livello di accesso brutta e difficile da seguire se il programmatore originale non ha organizzato ordinatamente le sue "regioni di accesso".

---

Dando uno sguardo allo stesso frammento in # stile Java/C, otteniamo:

class Foo 
{ 
    public: Foo(); 
    public: explicit Foo(const std::string&); 
    public: ~Foo(); 

    public: enum FooState 
    { 
    Idle, Busy, Unknown 
    }; 

    public: FooState GetState() const; 
    public: bool GetBar() const; 
    public: void SetBaz(int); 

    private: struct FooPartialImpl; 

    private: void HelperFunction1(); 
    private: void HelperFunction2(); 
    private: void HelperFunction3(); 

    private: FooPartialImpl* m_impl; // smart ptr 
    private: FooState m_state; 
    private: bool m_bar; 
    private: int m_baz; 
}; 

A mio parere, questo è molto più facile da leggere in un colpo di testa, perché lo specificatore di accesso è di destra vicino all'obiettivo, e non a un gruppo di linee. Ho trovato questo particolarmente vero quando si lavora con il codice del modello di solo header che non è stato separato nella solita coppia "* .hpp/*. Inl". In questo scenario, le dimensioni delle implementazioni di funzioni hanno sopraffatto questa piccola ma importante informazione.

---

La mia domanda è semplice e deriva dal fatto che non ho mai visto nessun altro attivamente fare questo nel loro codice C++.

Supponendo che non disponga di un IDE abilitato per "Visualizzazione di classe", esistono alcuni ovvi inconvenienti nell'utilizzo di questo livello di verbosità?

Qualsiasi altro suggerimento di stile è benvenuto!

Answer 1

"Quando a Roma, fa come i romani."

I, avendo trascorso molto tempo con Java, come lo stile di specificare gli specificatori di accesso per ogni campo e metodo separatamente. Tuttavia, quando sto programmando in C++, uso sempre lo stile mostrato nel tuo primo frammento di codice.

Answer 2

Personalmente, trovo molto fastidioso dover specificare il qualificatore di accesso per ogni simbolo. Rende le cose più difficili da leggere, non più facili, e incoraggia la pessima abitudine di mescolare liberamente le cose private e pubbliche attraverso la definizione della classe. Vedo questo tipo di casino tutto il tempo. In C#, provo a mitigare questo con #region private, ecc., Che si spera incoraggia i futuri manutentori a mantenere le cose pulite.

Answer 3

Non c'è niente di sbagliato in questo, anche se alzerai le sopracciglia. Il vantaggio principale di tenere separati gli specificatori di accesso è che incoraggia tutti i membri e i metodi privati ​​in cima alla classe - insieme.

Se la tua classe è troppo grande per adattarsi a uno screenfull di quello che probabilmente dovrebbe essere suddiviso in più di una classe, e/o tutte le funzioni implicitamente inline dovrebbero essere esplicitamente dichiarate in linea con l'implementazione spostata fuori dalla classe.

Answer 4

Lo svantaggio di quest'ultimo approccio è che viene raramente eseguito, e non è una buona idea sorprendere gli altri sviluppatori in questo modo e richiede che il modificatore di accesso venga digitato un milione di volte. L'utilizzo dell'approccio tradizionale consentirà di risparmiare dover digitare ripetutamente il modificatore ripetutamente ed è anche l'approccio previsto.

Answer 5

In effetti, semanticamente non fa alcuna differenza, ma farai a te stesso e ai tuoi colleghi un grande favore se seguirai semplicemente ciò che è accettato.

Personalmente mi piace la mia classe in questo modo:

struct S { 
    S(int m) : m(m) { } 
    S(const S& o); 
    S& operator=(const S& o); 

    void f() const; 
    std::string g(); 

private: 
    void help(); 

private: 
    int m; 
}; 

Ma io cambierò i miei modi, senza pensarci due volte se commetto in un repository che non è strettamente mia, perché so quanto riconoscente sarei se qualcuno volesse affidare il proprio codice ai miei repository seguendo le mie dogane.