Както знаете, конвенцията за именуване е набор от правила за избор на последователност от знаци, която да се използва за идентификатори, които обозначават променливи, типове, функции, класове, обекти и други обекти в изходния код и документацията.

Най-важната причина за използването на конвенция за именуване е да се намалят усилията, необходими за четене и разбиране на изходния код; също така много компании са създали свой собствен набор от конвенции.

В тази средна публикация искам да споделя с вас набор от прости и ясни правила за писане на по-добър, красив, ефективен и най-четлив CPP код както в Windows, така и в Linux среда, ясно с незначителна модификация на кода, тъй като Linux и Windows имат различен набор на конвенцията за именуване.

В тази рамка предоставям набор от правила за следните обекти (ще го допълня в бъдеще):

  • Локална променлива
  • Глобална променлива
  • Функции
  • Класове
  • Методи
  • Полета
  • Структура
  • Аргументи
  • Обекти
  • Пространства от имена
  • Шаблони

Нарекох тази конвенция за кодиране Milad CPP Syntex (MCS) за в бъдеще, като се позовавах на тях и също така дадох този шанс на себе си да работя по нея за комисията и общността на CPP.

Променливи

Въз основа на моя опит, определянето на променливи с първия знак от техния тип и техните класове за съхранение е най-добрият начин да ги изразите на ниво изходен код.

В следващия пример тази конвенция за именуване на променливи е показана в Windows (Visual Studio) и Linux (NeoVim):

Тъй като Microsoft използва нотацията Camel за именуване на собствените си API и променливи на Windows OS, трябва да използваме и тази нотация. В Linux, за разлика от Windows, имаме различен подход към именуване на обекти.

Linux използва поредица от малки букви от знаци с подчертаване за именуване на променливи, функции или други обекти, така че трябва да дефинираме нашите променливи и други обекти въз основа на тази конвенция за именуване в името на съвместимостта със самата среда. Горният код се основава на този стандарт, който Linux следва.

Свободно стоящи функции

Когато програмираме с процедурната парадигма в съвременния CPP, функциите и структурите са най-важните единици за нас.

Функциите и структурата за именуване с описателно и самостоятелно име са толкова важни за писане и четене на CPP кода както в Windows, така и в Linux OS.

Въпреки това, тъй като интерфейсите на ядрото на Windows (API или COM интерфейси) като WriteConsole са наименувани с камилски стил и също символ с главна буква в началото на техните дефиниции, както и C функции, дефинирани с символ с малка буква и кратки описателни имена като wcslen, трябва да използваме подобна конвенция с интерфейсите на Windows за нашите дефинирани от потребителя свободностоящи функции.

Така че най-добрият начин за дефиниране на отделна функция в Windows е използването на нотацията Camel с главни букви в началото като PrintMessage в горния пример.

За разлика от Windows, по-добре е да дефинираме дефинираните от потребителя функции в Linux с малки букви и да разделяме всяка дума с подчертаване, защото всичко в Linux от POSIX и SUS интерфейсите до C/C++ библиотеките се основава на малки букви, разделяне на долна черта и кратко имена.

Функции (и методи) Аргументи

Както знаете, има фина разлика между променливата аргументи и другите типове променливи. Така че трябва да правим известна разлика между аргументите и другите променливи в нашия изходен код.

Няма значение в каква среда пишем cpp код, трябва да посочим аргументи с префикс като arg_ или arg или други префикси, за да ги направим възможно най-ясни, както в следния пример.

Същото с Windows, трябва да следваме това правило и в Linux. Това прави нашия код самоописателен, самостоятелен и красив. Сега можем просто да прочетем кода и да го интерпретираме без никакво объркване с други типове обекти.

Структура и класове

Има набор от разлики между класовете и структурите в CPP езика, но концепцията за тях е подобна една на друга (поне от гледна точка на обектно-ориентираното програмиране).

Въпреки това, когато пишем cpp код с OOP или процедурна парадигма, се нуждаем съответно от класове и структури.

Така че трябва да имаме добре дефинирана конвенция, за да ги дефинираме, защото те са най-важните субекти от обектно-ориентираното и процедурно парадигмално програмиране, а също и софтуерното инженерство/разработка с модерен cpp.

За да дефинираме чертежи на класове и структура, трябва да използваме дефиниции, базирани на главни букви и Camel, като следния пример:

Също така, трябва да имате предвид дефинициите на метода в примера за схема на структура. Подобно на отделните функции, ние трябва да дефинираме методи (Функции в класовете или структурите) също с главни букви в началото им и Camel нотация.

Също така се препоръчва да се дефинира екземплярът на обекта на информационния план с главна буква O в Windows и o_ в Linux. В следващия пример дефинирам клас със същата концепция на горната структура.

В Linux трябва да дефинираме горния код с малка модификация в дефинициите на методите, а също и екземпляр на обект. Препоръчва се навсякъде да следваме конвенцията за именуване на Linux. Поради това е по-добре в Linux да дефинираме методи като други функции с малки букви и подчертаване.

Въпреки това, с тази нотация можем да разберем кой сега не е обикновен дефиниран от потребителя обект. Също така, трябва да се погрижите за една важна концепция при именуване на полета, когато пишете код с C++. За съжаление, някои програмисти използват двойно подчертаване в началото на името на своя член на полетата, което прави недефинирано поведение на практика, тъй като компилаторът използва __ в началото на техния идентификатор. Така че не трябва да дефинираме член на полета с двойни долни черти, защото:

Използването на два последователни знака за долна черта ( __ ) в началото на идентификатора или единична водеща долна черта, последвана от главна буква, е запазено за реализации на C++ във всички обхвати. Трябва да избягвате използването на една водеща долна черта, последвана от малка буква за имена с файлов обхват поради възможни конфликти с текущи или бъдещи запазени идентификатори.

Въпреки това е по-добре да дефинираме полета от клас с техния тип и достъпност. Например в горния пример дефинирам всички полета с pf (публично поле), за да направя разлика между полетата на класа с други обекти.

Сега, с просто наблюдение, можем да видим разликата между всеки елемент в нашия изходен код. В допълнение, нашият код вече е станал по-четлив, също така неговата простота е значително подобрена.

Шаблони

Шаблоните са в основата на общото програмиране, което включва писане на код по начин, който е независим от всеки конкретен тип. Шаблонът е план или формула за създаване на общ клас или функция. Библиотечните контейнери като итератори и алгоритми са примери за общо програмиране и са разработени с помощта на концепцията на шаблона.

Въпреки това, в повечето от примерния код, документацията и... когато някой ще дефинира шаблон, той използва ‹typename T› или нещо подобно. Но това намалява четенето на изходния код. Трябва да използваме смислени думи, а не само T или Tr или...

Освен това в Linux трябва да използваме същата конвенция за именуване на шаблон за нашия код. Това прави нашия код толкова смислен, колкото е възможно, както когато сме въвлечени в метапрограмиране.

Използвах горната конвенция за именуване в кариерата си от 2012 г. насам. Мисля, че това е най-полезната конвенция за именуване за професионалисти, а също и за начинаещи, за да разгледат вашия код и да го разберат. Ако имате някакви коментари, не се колебайте да ми ги изпратите.