1. line breaks must be LF (line feed, single '\n' character without carriage return '\r' character).
2. braces with short aggregate initialization, short lambda expression can be on same line.

std::array<std::pair<int, float>> arrName{{ { 0, 0.0f } }};
bool fnName = [&x](const auto& name) { return name.x > x; };

3. each brace must be on it's own line, except when enclosed body are empty.

void Function()
{
	int iName = 0;
}

void EmptyFunction() { };

4. one-line body statements, must be on new-line.

if (bCondition)
	Function();

while (bCondition)
	Function();

for (int i = 0; i < n; i++)
	Function(i);

1. must be placed after pointer/reference to align them on left side, except declarations of multiple variables.

void* pName = nullptr;
char *szNameFirst = nullptr, *szNameSecond = nullptr;
std::string& strName = "name";
std::string&& strName = "name";

2. must be placed around assignment/ternary/binary but not unary/member operators.

iName = -iName;
uName = (uName & 0x2);
bName = (bName ? true : false);

3. must be placed after keyword in the flow control statements.

while (bName)
{
	if (bName)
		bName = !bName;
}

4. must be placed between empty curve/square braces, such as list initialization, constructor with initializer list, lambda capture etc, but not aggregate initialization.

int iName = { };
std::array<std::pair<int, float>> arrName{{ { 0, 0.0f } }};

Name_t(const int iName) :
	iName(iName) { }

auto fnName = [ ](int& nNameCount) { nNameCount++; };

5. must be placed after comma and colon, except conditions when new line must be placed instead.

int iName = 0, iSecondName = 0;

class CDerived : IBase { };

Name_t(const int iName) :
	iName(iName) { }

• hot words:

  1. @todo: <explanation> - explains things to do/fix/improve in the future.

  2. @note: <info> - recommended information for the user to read.

  3. @test: [date] <reason> - explains things to test for the some reason.

  4. @credits: <author> - credentials of the author of the used/referenced code.

1. preferred to be in lowercase, except when the extra attention is required.
2. stylistic comments must be written in doxygen style, with spaces around colon.
3. multi-line comments less than 5 lines must be written in C++ style (double-slash and triple-slash for stylistic), otherwise C style must be used (slash with asterisk and slash with double-asterisk for stylistic).

1. the name must be written in UPPER_SNAKE_CASE.

#define Q_NAME

2. arguments must be written in UPPER_SNAKE_CASE.

#define Q_STRINGIFY(PLAIN_NAME) #PLAIN_NAME

3. arguments must be enclosed in parenthesis if they can be used as an expression.

#define Q_NAME(X) ((X) / 3.0f)
float flName = Q_NAME(5.0f - 8.0f);

4. expression must be enclosed in parenthesis.

#define Q_NAME (-1)

5. if the macro is publicly exposed, then it must be prefixed with 'Q' to indicate that its part of the q-tee collection.

#define Q_NAME

6. if the macro should be used only internally, then it must be prefixed with '_'.

#define _Q_INTERNAL

1. when comparing an unknown value with a constant/keyword value, first must be on the left side of comparison.

if (flName < 0.0f || flName > M_PI)

2. check for pointer validity shouldn't look like a boolean check and must be compared explicitly with keyword.

if (pName != nullptr)

3. check for result of expression when it may not be in range [0, 1] shouldn't look like a boolean check and must be compared explicitly.

if ((uName & 0xAF) != 0U)

• number literals:

  1. differentiate numbers use with lowercase hex/binary/exponent/binary-exponent literals.

   unsigned int uNameAddress = 0x1EE7;
   unsigned int uNameBits = 0b1100100;
   float flNamePower = 0x1p4f;

  2. specify number data type with UPPERCASE (except float, with lowercase) type literal.

   unsigned int uName = 0U;
   long lName = 0L;
   long long llName = 0LL;
   long double ldName = 0.0L;
   float flName = 0.0f;

  3. wrap long constant numbers with apostrophe literal.

   int iName = 2'147'483'648;

• string literals

  1. wrap string that frequently contain code escapes with UPPERCASE raw string literal.

   std::string strName = R"(no new \n line)";

  2. specify string/character encoding with case-sensetive literal.

   wchar_t wName = L'\u2764';
   std::wstring wstrName = L"\u2764"s;
   char8_t uchName = u8'\u00AE';
   std::u8string ustrName = u8"\u2764"s;
   char16_t uchName = u'\u2764';
   std::u16string ustrName = u"\u2764"s;
   char32_t uchName = U'\U0010FFFF';
   std::u32string ustrName = U"\U0010FFFF"s;

  3. specify string type with custom literal.

   std::string strName = "string"s;
   std::string_view strName = "string"sv;

1. function name must be written in PascalCase.

void FunctionName();

1. variable name must be written in camelCase and prefixed with Hungarian notation of the data type that listed below or based on STL/WinAPI.

   • pointer:

     1. if the variable supposed to be a handle of any data type, prefix with 'h' overriding any other prefix.

      HANDLE hName = nullptr;

     2. if the variable is a function argument and supposed to be used as output, prefix with 'p' and append the variable's data type if specified.

      void Function(unsigned int* puOutput);

     3. if none of the conditions are met, prefix with 'p' overriding any other data type prefix.

      std::uint32_t* pName = &uAddress;

   • function:

     1. no additional conditions.

      void (*fnName)() = nullptr;

   • container:

     1. fixed-size C/C++/STL massive variable must be prefixed with 'arr'.

      char arrName[20] = { };
      std::array<char, 20U> arrName = { };

     2. varying-size C/C++/STL container variable must be prefixed with 'vec'.

      int* vecName = malloc(nSize);
      int* vecName = new int[nSize];
      std::vector<int> vecName = { };

   • boolean:

     1. no additional conditions.

      bool bName = false;

   • integer:

     1. if the variable is unsigned, prefix becomes 'u' regardless the data type, except long qualifiers, where it must be prepended instead.

      std::uint8_t uNameByte = 0U;
      std::uint16_t uNameWord = 0U;
      std::uint32_t uNameDword = 0U;
      std::uint64_t ullNameQword = 0ULL;

     2. if the variable supposed to indicate index/count/size/enumerator, prefix becomes 'n' regardless the data type.

      std::ptrdiff_t nNameIndex = arrName.find(...);
      std::size_t nNameSize = arrName.size();
      std::ptrdiff_t nNameCount = arrName.size() - arrInvalidName.size();
      ENameMode nNameMode = NAME_MODE_FIRST;

     3. if none of the conditions are met.

      char chName;
      short shName;
      int iName;
      long long llName;

   • floating point:

     1. no additional conditions.

      float flName = 0.0f;
      double dlName = 0.0;
      long double ldName = 0.0L;

   • string:

     1. if the variable a zero-terminated string it must be prefixed with 'sz' and safe wrapped string variables with 'str'.

      const char* szName = "";
      std::string strName = ""s;

     2. if the variable a string of the next base character types: wchar_t, char8_t, char16_t, char32_t it must prepend characters's data type to the prefix.

      const wchar_t* wszName = L"Example";
      const char8_t* uszName = u8"Example";
      const char16_t* uszName = u"Example";
      const char32_t* uszName = U"Example";
      std::wstring wstrName = L"Example"s;
      std::u8string ustrName = u8"Example"s;
      std::u16string ustrName = u"Example"s;
      std::u32string ustrName = U"Example"s;

     3. if the variable a string with template-based character type, it must prepend 't' to the prefix.

      template <typename T>
      void FunctionName(const T* tszName, const std::basic_string_view<T> tstrName);

     4. if the variable is a single character.

      char chName = '\0';
      wchar_t wchName = L'\000';
      char8_t uchName = u8'\u0000';
      char16_t uchName = u'\u0000';
      char32_t uchName = U'\U00000000';

   • other:

     1. if the data type of the variable is part of the STL.

      std::filesystem::path pathName = { };
      std::ifstream ifsName = { };
      std::ofstream ofsName = { };

     2. if the data type of the variable is part of the WinAPI.

      DWORD dwName = 0UL;
      WORD wName = 0U;
      BYTE dName = 0U;
      WPARAM wName = 0U;
      LPARAM lName = 0L;
      HRESULT hName = 0L;
      LRESULT lName = 0L;

2. if variable defined as auto type, and final type is known, it still requires to include Hungarian notation.

auto iName = 0;

3. if variable is a numeric constant known at compile-time, then it must be prefixed with 'k'.

constexpr int kPiDigitsCount = 6;
constexpr double kPi = 3.141592;

4. if none of the conditions are met, then Hungarian notation is redundant.

Unknown_t unknownName = { };

1. must be suffixed with '_t' to indicate that it's a structure.

struct Name_t;

1. if the class is either abstract or interface (has a virtual table and no variables), then it must be prefixed with 'I'.

class IName;

2. must be prefixed with 'C' to indicate that it's a class.

class CName;

1. must be prefixed with 'E' to indicate that it's an enumeration.

enum EName : int { };

2. the name of the each enumerator must be written in UPPER_SNAKE_CASE.

enum EName : int
{
	NAME_FIRST = 0,
	NAME_SECOND
};

1. it is preferred the name to be written in UPPER_SNAKE_CASE.

namespace F;

2. it is preferred to give a namespace short and generalized name.

namespace NT;

3. if the child namespace is part of a particular module, then it must be named or prefixed by at least one letter of the module name

_gui/font.h

namespace GUI::F;