Konwencja nazewnictwa dla par cers i seterów

Question

Dla tych, którzy nazywają was zmiennymi członkowskimi bez specjalnej notacji, jak m_foo lub foo_, jak nazywasz parametry swoim lekarzom i seterom?

Niektóre opcje próbowałem tak daleko ...

Obj(int foo) : foo(foo) { } 
void set_foo(int foo) { this->foo = foo; } 

Obj(int _foo) : foo(_foo) { } 
void set_foo(int _foo) { foo = _foo; } 

Obj(int a_foo) : foo(a_foo) { } // a for "argument" 
void set_foo(int a_foo) { foo = a_foo; } 

Obj(int init_foo) : foo(init_foo) { } 
void set_foo(int new_foo) { foo = new_foo; } 

Answer 1

ja zawsze pójść na Param lub Arg przyrostkiem ale tylko wtedy, gdy jest to konieczne ujednoznacznienie.

Obj(int fooArg) : foo(fooArg) 

Answer 2

Używam foo_, lepiej niż _foo ponieważ nie będzie kolidować z nazwami funkcji wykonawczych i słów kluczowych.

Answer 3

staram się postępować zgodnie z pierwszą literę nazwy parametru, który jest ustawiony, a disambiguate z tym ...

void setFoo(int f) { foo = f; } 

Dla prostego seter, dla jednej zmiennej, to jest całkiem dobrze jasne.

Także ja często zrobić

int setFoo(const int f) { foo = f; } 

więc mogę strunowe rzeczy razem.

Answer 4

Idę z

Obj(int foo) : mFoo(foo) { } 
void setFoo(int foo) { mFoo = foo; } 

w moich programach. Dla konstruktorów kopiowanie i operator =, i zazwyczaj nazywać

Obj(Obj const& that):mFoo(that.mFoo) { } 

dla operatorów, jadę z

Obj operator+(Obj const& lhs, Obj const& rhs) { ... } 

Ponieważ te są l EFT H i s IDE oraz jego odpowiednik. h h .

Answer 5

Dla klas:

Obj(int foo) : _foo(foo) {}; 

Na elemencie:

obj_t(int foo_) : foo(foo_) {}; 

Seter:

Obj.setFoo(int foo) { _foo = foo; } 

jestem z litb sprawie wykorzystania lhs i rhs dla połączeń operatorskich.

Używam camelCase dla funkcji członka klasy i names_with_underscores dla pól i metod struktury.

Answer 6

Podążyłem konwencją Microsoftu dotyczącą zmiennych zmiennych prefiksowanych z m_, np. m_foo. W mojej obecnej firmie konwencja jest końcowym podkreśleniem zmiennych składowych: foo_.

Generalnie, jeśli pracujesz sam, użyj konwencji, którą lubisz. Jeśli pracujesz w zespole, używaj tego, co zgadza się zespół. Najważniejsza jest spójność w podstawie kodu, a nie w konkretnej konwencji.

Answer 7

Unikam (przez uniknięcie tego, że nigdy nie używam) podkreślenia jako pierwszego znaku dowolnego identyfikatora. Wiem, że to przesada, ale warte wysiłku.

Przeczytaj to: What are the rules about using an underscore in a C++ identifier?

Choć nie jest to regułą, że ograniczenie korzystania z podkreśleniem i wolą sprawę wielbłąda, aby moje zmienne czytelny. Ale to tylko osobiste preferencje i nie mam nic przeciwko czytaniu kodu, który z niego korzysta.

Ponadto nigdy nie nazywam parametrów tak jak moje zmienne składowe. Kompilator nie pomoże złapać tego rodzaju błędów, które może wygenerować (a to wszystko polega na tym, aby kompilator wykonał prawdziwą pracę, aby można było wykonać ekspresywną pracę, której nie może wykonać kompilator).

int X::setWork(int work) 
{ 
    this->work = work; // OK. But more Java like. 

    work = work;  // Compiler won't see that problem. 
} 

int X::setWork(int newWork) 
{ 
    work = newWork; // A bit harder to get wrong. 
} 

Answer 8

Numer dwa ma problemy jako konwencja, chociaż w twoim przypadku może być nieszkodliwy. Nazwa, która ma wiodące podkreślenie, po którym występuje wielka litera, jest zarezerwowana dla implementacji, a wszystkie nazwy z wiodącymi podkreśleniami są zarezerwowane w kontekście globalnym. Jeśli nigdy nie masz członków klas rozpoczynających się od wielkich liter (ja nie), jesteś bezpieczny zgodnie z konwencją, jak pokazano (używając _foo tylko jako argumentu funkcji), ale nie lubię konwencji nazewnictwa, które są w pobliżu granic.

Answer 9

Zawsze to zrobić:

Obj(int foo) : foo(foo) {} 

grałem w gry z dołączanie śmieszne symbole aż pewnego czasu mam dotkniętych tym:

Obj(Bar& b) : b_(b_) {} 

widać błąd? (Tak, b_ jest prywatną zmienną referencyjną członka). Kompilował bez ostrzeżenia. Kosztowało mnie 3 dni debugowania (wtedy byłem wtedy zielonym programistą).

Teraz zawsze używam tej samej nazwy, aby uniknąć literówek (i kolejnych awarii). Na liście inicjalizacji nie ma dwuznaczności. Ta część języka została zaprojektowana tylko dla tego przypadku, więc skorzystaj z niej.

Answer 10

nazwać rzeczywiste członkom spływu podkreślenia, więc mogę to zrobić:

Foo(int bar) : bar_(bar) { } 

Powodem jest to, aby można było korzystać z funkcji getter bez niczego podobnego getBar() (bar() jest lepiej).

Answer 11

robię to tak:

obj(int foo) : _foo(foo) { } 
int foo() const { return _foo; } 
void foo(int value) { _foo = value; } 

Jedynym Trick o to, aby upewnić się, że list po podkreślenia jest małe. Jednak wszędzie unikam wielkich liter w nazwach identyfikatorów, ponieważ jest niezgodny z konwencjami używanymi przez standardową bibliotekę (która używa foo_bar_baz dla wszystkich identyfikatorów).

Answer 12

I wykonaj Google C++ Style Guide

Nazwy zmiennych są małe, podkreślenia między słowami.Zmienne składowe klasy mają końcowe znaki podkreślenia. Na przykład: my_exciting_local_variable, my_exciting_member_variable_.