Dobre standardy programowania - nazewnictwo zmiennych

Witam,
chciałem się zapytać Was, bardziej doświadczonych programistów, czy macie jakieś swoje ulubione standardy nazywania zmiennych/obiektów w waszych programach? Chodzi mi o to, że właśnie stworzyłem klasę o nazwie nazwa_klasy i zastanawiam się jak nazwać obiekt takiej klasy O_o... Najbardziej by mi pasowała taka nazwa jak nazwa klasy, ale tak nie można :/. No i właśnie zastanawiam się nad wyrobieniem sobie jakiegoś standardu ;)

Często bywa również tak, że mam metodę w której przypisuję obiektom klasy wartości i wówczas również jest problem jak nazwać takie parametry... Chodzi mi o taki przykład

void metoda_przypisania_zmiennych(int A, double B)
{
this->A = A;
this->B = B;
}

bez this byłoby czytelniej, ale powstaje wówczas pytanie jak nazwać zmienne w parametrach funkcji, by je jakoś odróżnić...
pozdrawiam

Poczytaj: http://pl.wikipedia.org/wiki/Notacja_węgierska

A klasy ja nazywam np. CGame, a obiekt to małą literą np. game

Osobiście wszelkie parametry funkcji poprzedzam znakiem "_". W Twoim wypadku mogło by to wyglądać tak:

void metoda_przypisania_zmiennych(int _A, double _B)
{
this->A = _A;
this->B = _B;
}

Po pierwsze nazwa metody lub zmiennej ma odwzorowywać to co w niej naprawdę się znajduje. Za pół roku zobaczysz fragment:

void metoda_przypisania_zmiennych(int A, double B){} 

i co pomyślisz? Zaczniesz czytać kod żeby zrozumieć o co chodzi, a to jest problem.
Gdybyś np. napisał:

void ustalPozycje(int x, double y){} 

problemu by nie było.

Z takich lepszych standardów.
-Klasy zaczynasz dużą literą i potem camelCase.
-Metody i zmienne zaczynasz małą literą i potem camelCase.

Zmienne jednoliterowe lub z nazwą bez znaczenia generalnie odpadają z kilkoma wyjątkami (np. "i" przy iteracji).
Rozbijaj kod na jak najwięcej małych funkcji.

mcoder napisał(a):

Poczytaj: http://pl.wikipedia.org/wiki/Notacja_węgierska

O notacji węgierskiej czytałem, ale ona jest bez sensu - tam jest kilkadziesiąt typów... To jest nie do zapamiętania i wszystko się miesza i nie wygląda to zbyt estetycznie...

mcoder napisał(a):

A klasy ja nazywam np. CGame, a obiekt to małą literą np. game

Ja rozważałem pisać nazwy klas z dużych liter np. NAZWA_KLASY, ale doszedłem do wniosku, że to również nie wygląda zbyt estetycznie a do tego makra również są pisane dużymi literami i nie chcę by się to przeplatało...
W nazwach stosuję podkreślnik, ale również zamierzam z niego zrezygnować na rzecz: NazwaKlasy
Wówczas obiekty mógłbym nazywać np. tak NazwaKlasy nazwaklasy lub NazwaKlasy nazwa_klasy
Niestety ciągle się waHam...

AlfaLeporis napisał(a):

Osobiście wszelkie parametry funkcji poprzedzam znakiem "_". W Twoim wypadku mogło by to wyglądać tak:

void metoda_przypisania_zmiennych(int _A, double _B)
{
this->A = _A;
this->B = _B;
}

Ja kiedyś dawałem f_ co informowało, że jest to zmienna funkcji, ale również trochę się do tego zniechęciłem...

W C++ jest o tyle trudniej niż w innych językach, że pisze w nim bardzo dużo osób, które są już ugruntowane w dziedzinie programowania. Z racji braku oficjalnych zaleceń organizacji, która sprawuje nad nim pieczę (komitet standaryzacyjny) stosują standardy, które poznali gdzie indziej. Dlaczego, w przeciwieństwie do Javy, C# czy Pythona ciężko powiedzieć o tych jedynych i właściwych.

Najpierw zdefiniujmy kilka stylów: camelCase, _camelCase, PascalCase, underscore_case.

Takie są moje preferencje:
Nazwy klas: PascalCase.
Nazwy metod: PascalCase.
Parametry: camelCase.
Pola: _camelCase. Czasem nie poleca się rozwiązań z podkreśleniami z przodu z tego względu, że są to nazwy zarezerwowane dla wewnętrznej implementacji czy kompilatora. Nie ma z tym jednak większych problemów. Możesz też użyć camelCase_.
Zmienne: camelCase.

Inni jako nazwy funkcji i metod stosują camelCase, a jeszcze inni underscore_case (też bardzo czytelne, także dla parametrów i zmiennych).
Kiedyś bardzo popularna (w C++ i swojego czasu w PHP) była notacja węgierska, czyli z przedrostkiem oznaczającym typ albo zasięg zmiennej (np. m_cośtam czy lpszCośtam). Nadal można ją często zauważyć w kodach C++ Microsoftu (i nadal w nagłówkach WinAPI). Obecnie raczej wszyscy są zgodni, że to złe rozwiązanie.

Najważniejsze jest jednak to, by trzymać się jednego stylu w jednym projekcie. Nie ma nic gorszego niż brak konsekwencji.

Ale kombinujesz MichałWx... Po co chcesz cos wymyslac jakies swoje zasady?

Ja trzymam się takich standardów:

• Nazwy klas w ProperCase.
• Nazwy metod, funkcji, zmiennych i parametrów w camelCase.
• Prywatne pola w klasie camelCase z sufiksem _; tu dodam, że pola publiczne są naprawdę rzadkością – jeśli są, to camelCase.
• Akcesory pól prywatnych (jeśli są potrzebne) tak jak nazwa pola bez sufiksu (np. pole T foo_, getter T foo() const, setter T& foo()).
• Stałe najczęściej UPPER_CASE.
• Parametr template'owy oznaczający typ w UpperCase z prefiksem T (np. TOut); jeśli jest tylko jeden parametr, to po prostu T.
• Parametr remplate'owy oznaczający wartość w UpperCase.

Mały przykład:

const int CONST_VALUE = 123;

class MyClass {
public:
    MyClass(int bar) : bar_(bar) {
        double myVar = 3.14;
    }
    
    bool foo(int baz) const {
        return baz == bar_;
    }
    
    int bar() const {
        return bar_;
    }
    
    int& bar() {
        return bar_;
    }

private:
    int bar_;
};

int main() {
    MyClass myClass(7);
}

Opisywac moze nie bede, ale mniej-wiecej cos w tym stylu:

#define BUFFER_SIZE 256

const int CONST_VALUE = 123;
 
class MyClass
{
public:
    MyClass(int bar):
        bar(bar)
    {
        ;
    }
 
    int getBar() const
    {
        return this->bar;
    }
 
    void setBar(const int bar)
    {
        this->bar = bar;
    }
    
    bool porownanieBarow(const int) const;
 
private:
    int bar;
};

template<class T>
bool porownaj(const T& a, const T& b)
{
    return a == b;    
}

template<class Input, class Output>
void copy(const Input& first, const Input& last, Output& result)
{
    // ...
}

bool MyClass::porownanieBarow(const int bar) const
{
    return this->bar == bar;
}

 
int main()
{
    MyClass my_class(10);
    return 0;
}

Edit: Dodam jeszcze wywolanie duuuzych funkcji, raczej w formie ciekawostki ;>

std::copy(
	istream_iterator<char>(cin),
	istream_iterator<char>(),
	ostream_iterator<char>(cout)
);

Ja stosuję notację:

• klasy/przestrzenie nazw PascalCase z zachowaniem wielkości znaków w skrótach, czyli np. HTMLParser a nie HtmlParser
• metody small_caps_snake_case
• stałe BIG_CAPS_SNAKE_CASE
• zmienne i parametry small_caps_snake_case
• stanowcze nie notacji węgierskiej
• składowe prywatne z przedrostkiem m_