Najlepsza praktyka: porządkowanie publicznego / chronionego / prywatnego w definicji klasy?

Rozpoczynam nowy projekt od podstaw i chcę, aby był czysty / miał dobre standardy kodowania. W jakiej kolejności doświadczeni programiści tutaj lubią układać rzeczy w klasie?

O: 1) metody publiczne 2) metody prywatne 3) metody publiczne 4) metody prywatne

B: 1) vary publiczne 2) vars prywatne 3) metody publiczne 4) metody prywatne

C: 1) metody publiczne 2) metody publiczne 3) metody prywatne 4) metody prywatne

Generalnie lubię umieszczać publiczne zmienne statyczne na górze, ale czy publiczna metoda statyczna powinna być wymieniona przed twoim konstruktorem, czy też konstruktor powinien być zawsze wyświetlany jako pierwszy? Coś w tym rodzaju...

Wiem, że jest to trudne, ale zastanawiałem się tylko: jakie są najlepsze praktyki w tym zakresie?

PS: nie, nie używam Cc #. Wiem. Jestem luddystą.

W Clean Code Robert C. Martin radzi programistom, aby zawsze umieszczali zmienne składowe na szczycie klasy (najpierw stałe, potem prywatne elementy członkowskie), a metody powinny być uporządkowane w taki sposób, aby czytały jak historię, która nie powoduje czytelnik musi za bardzo skakać po kodzie. Jest to bardziej rozsądny sposób organizowania kodu niż modyfikator dostępu.

Najlepszą praktyką jest konsekwencja .

Osobiście wolę stawiać publicnajpierw metody, potem protectedmetody, potem privatemetody. Dane członków powinny być generalnie zawsze prywatne lub chronione, chyba że masz dobry powód, aby tego nie robić.

Moje uzasadnienie dla umieszczania publicmetod na górze jest takie, że definiuje interfejs dla twojej klasy, więc każdy, kto przegląda twój plik nagłówkowy, powinien mieć możliwość natychmiastowego zobaczenia tych informacji.

W ogóle, privatea protectedczłonkami są mniej ważne dla większości ludzi szukających w pliku nagłówkowym, chyba że rozważa modyfikację wewnętrzne klasy. Utrzymywanie ich „z dala od drogi” zapewnia, że ​​informacje te są przechowywane tylko w przypadku konieczności ich poznania , co jest jednym z ważniejszych aspektów hermetyzacji.

Myślę, że mam inną filozofię w tej sprawie niż większość. Wolę grupować powiązane elementy razem. Nie mogę znieść konieczności skakania dookoła do pracy z klasą. Kod powinien płynąć, a użycie raczej sztucznej kolejności opartej na dostępności (publicznej, prywatnej, chronionej itp.) Lub instancji w porównaniu ze statyczną lub składową w porównaniu z właściwością i funkcją nie pomaga w utrzymaniu ładnego przepływu. Więc jeśli nave sposób publiczny Method, który jest realizowany przez prywatnych metod pomocniczych HelperMethodA, HelperMethodBitd wtedy zamiast mieć te metody daleko od siebie w pliku, będę trzymać je blisko siebie. Podobnie, jeśli mam metodę wystąpienia, która jest implementowana metodą statyczną, zgrupuję je również razem.

Więc moje zajęcia często wyglądają tak:

class MyClass {
    public string Method(int a) {
        return HelperMethodA(a) + HelperMethodB(this.SomeStringMember);
    }

    string HelperMethodA(int a) { // returns some string }

    string HelperMethodB(string s) { // returns some string }

    public bool Equals(MyClass other) { return MyClass.Equals(this, other); }

    public static bool Equals(MyClass left, MyClass right) { // return some bool }

    public double SomeCalculation(double x, double y) {
        if(x < 0) throw new ArgumentOutOfRangeException("x");
        return DoSomeCalculation(x, y); 
    }

    const double aConstant;
    const double anotherConstant;
    double DoSomeCalculation(double x, double y) {
        return Math.Pow(aConstant, x) * Math.Sin(y) 
            + this.SomeDoubleMember * anotherConstant;
    }       
}

Osobiście lubię mieć publiczne na górze, chronione, a potem prywatne. Powodem tego jest to, że gdy ktoś otworzy nagłówek, najpierw zobaczy, do czego ma dostęp, a następnie więcej szczegółów, gdy przewinie w dół.

Nie trzeba patrzeć na szczegóły implementacji klasy, aby jej użyć, wtedy projekt klasy nie jest dobrze wykonany.

Bardzo mnie to obchodziło. W ciągu ostatnich kilku lat, używając nowoczesnych IDE, prawie wszystko jest tylko 1 lub 2 naciśnięcia klawiszy, pozwoliłem moim standardom znacznie się rozluźnić. Teraz zaczynam od statyki, zmiennych składowych, a potem konstruktorów nie martwię się o to zbytnio.

W C # pozwalam Resharper automatycznie organizować rzeczy.

To byłoby moje zamówienie

1. Zmienne statyczne
2. Metody statyczne
3. Zmienne publiczne
4. Zmienne chronione
5. Zmienne prywatne
6. Konstruktorzy
7. Metody publiczne
8. Metody chronione
9. Metody prywatne

Stosuję następujące zasady:

• statyczne przede wszystkim
• zmienne przed konstruktorami przed metodami (uważam, że konstruktory należą do kategorii metod)
• publiczny przed chroniony przed prywatnym

Chodzi o to, aby zdefiniować obiekt (dane) przed zachowaniami (metodami). Statyki należy oddzielić, ponieważ nie są one tak naprawdę częścią obiektu ani jego zachowania.

Generalnie zgadzam się z porządkiem publicznym, chronionym, prywatnym, a także z danymi statycznymi, danymi członków, porządkiem funkcji członków.

Chociaż czasami grupuję jak członkowie (pobierający i ustawiający), generalnie wolę wymieniać członków w grupie ALFABETYCZNIE, aby łatwiej było ich zlokalizować.

Lubię też układać dane / funkcje w pionie. I tabulację / spację w prawo, aby wszystkie nazwy były wyrównane w tej samej kolumnie.

Każdemu z nich, jak mówi Elzo, nowoczesne IDE ułatwiły znajdowanie członków i ich modyfikatorów dzięki kolorowym ikonom w rozwijanych menu i tym podobnych.

Uważam, że dla programisty ważniejsze jest, aby wiedział, do czego została zaprojektowana klasa i jak można się po niej spodziewać.

Tak więc, jeśli jest to Singleton, najpierw umieszczam semantykę (statyczna klasa getInstance ()).

Jeśli jest to konkretna fabryka, najpierw umieszczam funkcję getNew () i funkcje register / initialize.

... i tak dalej. Kiedy mówię najpierw, mam na myśli wkrótce po c'tors i d'tor - ponieważ są one domyślnym sposobem tworzenia instancji dowolnej klasy.

Następujące funkcje znajdują się wtedy w:

1. logiczna kolejność wywołań (np. initialize (), preProcess (), process (), postProcess ()) lub
2. powiązane funkcje (takie jak akcesoria, narzędzia, manipulatory itp.),

w zależności od tego, czy klasa miała być przede wszystkim magazynem danych z niektórymi funkcjami, czy dostawcą funkcji z kilkoma członkami danych.

Niektóre edytory, takie jak Eclipse i jego potomstwo, pozwalają na zmianę kolejności w widoku konspektu zmiennych i metod, alfabetycznie lub jak na stronie.

Kolejność publicznych, po których następują chronione i prywatne, jest dla mnie bardziej czytelna. Lepiej jest opisać logikę klas w komentarzach na górze pliku nagłówkowego i rozkazami wywołania funkcji, aby zrozumieć, jaka dawka klasy i algorytmy są używane w środku.

Używam Qt c ++ od jakiegoś czasu i widzę nowe rodzaje słów kluczowych, takie jak signali slotwolę zamawiać dalej jak powyżej i podzielić się z wami moim pomysłem tutaj.

#ifndef TEMPLATE_H
#define TEMPLATE_H


class ClassName
{
    Q_OBJECT
    Q_PROPERTY(qreal startValue READ startValue WRITE setStartValue)
    Q_ENUMS(MyEnum)

public:

    enum MyEnum {
        Hello = 0x0,
        World = 0x1
    };

    // constructors

    explicit ClassName(QObject *parent = Q_NULLPTR);
    ~ClassName();

    // getter and setters of member variables

    // public functions (normal & virtual) -> orderby logic

public slots:

signals:

protected:

    // protected functions it's rule followed like public functions


private slots:

private:

    // methods

    // members

};

#endif // TEMPLATE_H