Az előző tananyagrészben arról már volt szó, hogy milyen szabályokat kell betartani egy változó elnevezése esetén (amik egyébként más dolgok, pl tömbök, függvények, osztályok, objektumok elnevezése esetén is érvényesek). Ebben a tananyagrészben nem az elnevezési szabályokról lesz szó, hanem arról, hogy (egyesek szerint) hogyan érdemes és hogyan nem érdemes elnevezni a változókat (például milyen szavakat használjunk, azokat hogyan válasszuk el egymástól, satöbbi).
előző tananyagrész: változók, konstansok, literálok
következő tananyagrész: gyakori műveletek
Ebben a témában egyesek vérremenő vitákat folytatnak, én itt csak néhány alapvető tudnivalót ismertetek azok számára, akiknek teljesen ismeretlen a téma, nem állítom, hogy ennek a tananyagnak az elnevezései a legtökéletesebbek :)
Általában az egyes szervezetek/cégek meghatározzák, hogy a fennhatóságuk alatt álló projektek forráskódjában hogyan kell eljárni a változók elnevezése és egyéb design patternek tekintetében.
Szavak elválasztása
Átláthatóbbá teszi a kódot, ha a nevekben (azonosítókban) nem csak egybeírjuk a több szóból álló nevekben a szavakat, hanem valahogy szemmel láthatóan elválasztjuk őket egymástól. Ennek a két legismertebb módja a snake_case és a camelCase.
snake_case
A C++ nyelvben talán a legnépszerűbb elnevezési stílus a snake_case, amely szerint az egyes szavak közé egy alsóvonalat írunk a nevekben (azonosítókban). Példák változók definiálása (létrehozása) esetén:
int variable_example_1{};double variable_example_2{};std::string variable_example_3;C++-ban sokan ezt használják tömbök, függvények, osztályok, objektumok elnevezéséhez is. Az egyetlen kivétel talán a preprocesszor makrók, bár azok meg C++-ban kerülendőek.
Pl. a C++ standard library std::vector adatszerkezetének a push_back taggfüggvénye jó példa a snake_case elnevezési stílusra.
camelCase
Alighanem a világ legnépszerűbb elnevezési stílusa a camelCase, mellyel C++ nyelvben is jó eséllyel találkozhatunk, de a Java és C# nyelvekben szinte biztos, hogy a legtöbb programozó ezt használja, amely szerint a szavakat egybe írjuk, az első szó kis betűvel kezdődik, a további szavak pedig nagy betűvel kezdődnek.
Példák változók definiálása esetén:
int variableExample1{};
double variableExample2{};
std::string variableExample3;
UpperCamelCase
Esetleg PascalCase-nek is szokták nevezni. Például Javaban, C#-ban, és nyilván Pascalban találkozhatunk vele. Javaban például a camelCase-el együtt használják (az osztályok neveit szokták UpperCamelCase szerint írni, a változók és függvények neveit pedig lowerCamelCase szerint), akár ugyanígy találkozhatunk vele a C++ nyelvben is.
Példa osztályok esetén:
class ClassExample {
//private member variables
int memberExample1;
std::string memberExample2;
//other private member variables and member functions
//[...]
public:
//constructor(s)
//[...]
//member functions
int getMember1() { return memberExample1; }
std::string getMember2() { return memberExample2; }
//other public members and member functions
//[...]
};Jól látható, hogy csak az osztály neve van UpperCamelCase szerint írva, az osztály adattagjai és tagfüggvényei pedig lowerCamelCase szerint.
MACRO_CASE
Más néven ALL_CAPS vagy SCREAMING_SNAKE_CASE vagy esetleg más nyelvek esetén CONST_CASE, de a C++ nyelvben csak a preprocesszor makrók elnevezésénél ajánlott a használata, konstansok (const típusminősítővel ellátott változók), esetleg enumok esetén ellenjavallt.
Egyéb
Léteznek még egyéb, a fentiekhez hasonló elnevezési konvenciók, amikkel kevesebb eséllyel találkozunk a C++ nyelvben. Ezek jellemzően vagy a fentiek kombinációi (pl. alsóvonalat tartalmaznak és nagybetűvel is kezdődnek az egyes szavak), esetleg alsóvonal helyett kötőjel van bennük.
A kötőjel használata azonosítókban viszont C, C++, C#, Java, Javascript, PHP, stb nyelvekben nem engedélyezett, fordítási/értelmezési hibát okoz.
Melyiket válasszuk?
A C++ standard library a snake_case-t alkalmazza és a Core Guidelines is ennek a használatát javasolja. Persze nem kötelező ezt használni minden C++ projektben, és könnyen találkozhatunk olyan C++ projektekkel, forrásfájlokkal, ahol nem ezt vagy nem csak ezt használják.
Elképzelhető, hogy egy projektben például a fentiek közül többet is használnak, viszont jó esetben mindig más dolgok (pl. változókhoz lowerCamelCase, osztályokhoz UpperCamelCase) elnevezéséhez.
Esetleg az is előfordulhat, hogy egy projekten belül több libraryt is használunk (nem csak a C++ standard libraryt), és a különböző libraryk eltérő design patterneket használnak. Ezen természetesen nem tudunk (de ha esetleg tudunk, akkor sem érdemes) változtatni.
- isocpp.org - prefer underscore_style names
- isocpp.org - identifier name conventions
- isocpp.org - use a consistent naming style
Angol vagy magyar nevek?
Sokan megvetik a magyar változónevek használatát, mert nagyobb projektekben jó eséllyel nem magyar anyanyelvű programozókkal dolgozunk együtt, illetve ha azt szeretnénk, hogy a kódunkat más is megtekinthesse (pl. hibajavítás vagy véleménynyilvánítás céljából), akkor is több helyen megkérdezhetjük, ha angol elnevezéseket, angol kommenteket használunk a kódunkban.
Érvek a magyar változónevek mellett:
- biztosan nem fog ütközni a programnyelv kulcsszavaival, azonosítóival
- elvileg a külföldi hackerek dolgát megnehezíti az olyan programnyelveknél, ahol más is láthatja a forrást (pl. kliens oldali webfejlesztés)
Milyen információk szerepeljenek vagy ne szerepeljenek a nevekben?
Egy változó neve utaljon a benne tárolt tartalomra
Az egyik legáltalánosabb tanács, hogy egy egy változót annak megfelelően nevezzünk el, hogy milyen jellegű adatot fogunk benne tárolni. Például ha egy stringben valamilyen idézetet tárolunk, akkor nevezzük el quote-nak, vagy idezetnek, vagy ha például egy int típusú változóban pl. egy tömb elemszámát tároljuk, akkor nevezzük array_size-nak, array_legnth-nek vagy size-nak, illetve length-nek, esetleg elemszamnak, de ne n-nek.
Eszerint tehát nem javasolt a semmitmondó változónevek használata, például: a, b, x, y, n.
A number1, number2, str1, str2 bizonyos esetben elfogadhatóak. Például ha egy függvény két szám átlagát számolja ki, ott nem nagyon lehet különösebb értelmet adni a változók nevének, minthogy egyik szám, másik szám.
double avg(double p_num1, double p_num2) { return (p_num1+p_num2)/2; }A változó szerepének jelentőségét tükrözze a nevének a hossza
Például egy random generált számot, számokat létrehozó függvényben az intervallum alsó és felső határát nem kell túl hosszú névvel ellátni (pl. intval_begin, intval_end, lowest_value, highest_value), ehelyett elég csak a min és max elnevezések használata.
Határeset például a matematikai képletekben használt változók. Például egy kör kerületét vagy területét kiszámoló kódrészletben nem muszáj a sugarat radius-nak nevezni, elég az r elnevezés, mert ott valószínűleg mindenki számára nyilvánvaló, hogy mit jelent az r.
Hasonlóan egy másodfokú egyenlet eredményét kiszámoló kódrészletben használhatunk a, b, c, illetve x nevű változókat, mert aki látott már másodfokú egyenletet, tudni fogja, hogy ezek mit jelentenek (ha pedig nem látott, akkor könnyen utána tud nézni pl. wikipédián).
Típus a nevekben (Hungarian notation)
Találkozhatunk olyan kódokkal, ahol egy változónak a nevében megadják a változó típusát (akár rövidítve). Pl. i_min, i_max, i_size, d_avg.
Ezt kerülendőnek tekintik, mivel fejlesztői környezetekben vagy programozást segítő funkciókkal ellátott text editorokban létezik olyan funkció, hogy ha jobb klikkel kattintunk egy változó (vagy esetleg tömb, függvény, osztály, objektum, satöbbi) nevére, akkor a "go to definition" menüpontot választva a fejlesztői környezet vagy text editor megnyitja a kód azon részét, ahol a változó létre lett hozva, és ott láthatjuk a típusát is.
Függvények paraméterei, osztályok adattagjai
Előfordul, hogy a függvények paramétereinek nevét meg szeretnék különbözni a függvényen belül létrehozott (úgynevezett lokális) változókétól, ezért a függvények paramétereinek nevét p_-vel szokták kezdeni, pl. p_size.
Szintén előfordul, hogy az osztályok adattagjainak nevét meg szeretnék különböztetni a tagfüggvények változóitól, ezért az osztályok adattagjai nevének az elejére m_-et szoktak írni.
Mértékegység a nevekben
//
Egyéb tanácsok
//
http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es8-avoid-similar-looking-names
https://www.learncpp.com/cpp-tutorial/keywords-and-naming-identifiers/
https://www.fluentcpp.com/2017/01/30/how-to-choose-good-names/
https://ib-krajewski.blogspot.com/2020/05/a-study-in-bad-naming.html
Összefoglalók
https://hu.wikipedia.org/wiki/Elnevez%C3%A9si_konvenci%C3%B3k_(programoz%C3%A1s)
előző tananyagrész: változók, konstansok, literálok
következő tananyagrész: gyakori műveletek
