Соглашение о присвоении имен для параметрических усилителей ctors и методов set

Я использую нечто _, это лучше, чем _foo, так как это не будет конфликтовать с реализацией определенные имена функций и ключевые слова.

Я иду с

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

в моих программах. Для конструкторов копии и оператора =, я склонен называть его

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

Для операторов я иду с

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

Поскольку это - левая сторона и правая сторона ее.

Я склонен следовать за первой буквой параметра, который устанавливается, и снимите неоднозначность с этим...

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

Для простого метода set, для одной переменной, это вполне прилично ясно.

Кроме того, я часто делаю это

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

таким образом, я могу представить вещи в виде строки вместе.

Я всегда делаю это:

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

Я раньше играл в игры с добавлением забавных символов до одного времени, я был поражен этим:

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

Можно ли видеть ошибку? (Да, b_ является ссылочной переменной члена парламента, не занимающего официального поста). Это скомпилировало без предупреждения. Стою мне 3 дней отладки (я был зеленым программистом затем).

Теперь я всегда использую то же имя для предотвращения опечаток (и последующие катастрофические отказы) как этот. В списке инициализации нет никакой неоднозначности. Эта часть языка была разработана только для этого случая, поэтому используйте в своих интересах его.

Я избегаю (избегают средний, никогда не используют), подчеркивание как первый символ любого идентификатора. Я знаю его излишество, но стоящий усилия.

Чтение это: Каковы правила об использовании подчеркивания в идентификаторе C++?

Хотя не правило я ограничиваю использование подчеркивания и предпочитаю, чтобы Camel-регистр сделал мои переменные читаемыми. Но это - просто персональное предпочтение, и я не возражаю читать код, который использует его.

Дополнительно я никогда не называю параметры тем же как мои членские переменные. Компилятор не поможет Вам поймать вид ошибок, которые это может генерировать (и это - все о том, чтобы заставлять компилятор сделать реальную работу, таким образом, можно сделать выразительную работу, которую компилятор не может сделать).

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.
}

Я всегда иду для суффикса Param или Arg, но только когда разрешение неоднозначности необходимо.

Obj(int fooArg) : foo(fooArg)

Я раньше следовал конвенции Microsoft добавления префикса членских переменных с m_, как m_foo. В моей текущей компании конвенция является запаздывающим подчеркиванием для членских переменных: foo_.

Обычно, если Вы работаете собой, затем используйте любую конвенцию, которую Вы любите. Если Вы работаете в команде, используйте то, что согласует команда. Полная непротиворечивость в кодовой базе - то, что важно, не конкретная конвенция.

Номер два имеет проблемы как конвенцию, хотя в Вашем случае это могло быть безопасно. Имя, которому следовал за начальным символом подчеркивания символ верхнего регистра, резервируется для реализации, и все имена с начальными символами подчеркивания резервируются в глобальном контексте. Если у Вас никогда нет участников класса, начинающих с прописных букв (я не делаю), Вы в безопасности с конвенцией как показано (использующий _foo только в качестве аргумента функции), но мне не нравятся соглашения о присвоении имен что юбка в какой-либо степени пределы.

Для классов:

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

Для структур:

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

Метод set:

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

Я с litb на использовании lhs и rhs для вызовов оператора.

Я использую camelCase для функций членства класса, и names_with_underscores для полей структуры и методов.

Я называю фактические члены с завершающими знаками подчеркивания, поэтому я делаю следующее:

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

Причина в том, что я могу использовать функции получения без чего-либо вроде getBar () (bar () лучше).

Я делаю это вот так:

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

Единственная уловка - убедиться, что буква, следующая за подчеркиванием, является строчной. Однако я везде избегаю прописных букв в именах идентификаторов, поскольку это несовместимо с соглашениями, используемыми стандартной библиотекой (которая использует foo_bar_baz для всех идентификаторов).

Я следую Руководству по стилю Google C ++

Все имена переменных пишутся в нижнем регистре с подчеркиванием между словами. Переменные-члены класса имеют в конце символы подчеркивания. Например: my_exciting_local_variable, my_exciting_member_variable _.