Какие ваши любимые идиомы стиля программирования C++

Напишите каждый аргумент метода или функции в отдельной строке, чтобы их можно было легко комментировать.

int ReturnMaxValue(
    int* inputList,   /* the list of integer values from which to get the maximum */
    long size,        /* count of the number of integer values in inputList */
    char* extraArgs   /* additional arguments that a caller can provide.    */
)

Задокументируйте возвращаемые значения в строке функции, чтобы их было очень легко найти.

int function(void) /* return 1 on success, 0 on failure */ 
{
    return 1;
};

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

bool MyObjects::isUpToSomething() ///< Is my object up to something 

(в сторону. Мои комментарии обычно не такие уж неубедительные.)

В операторах if при сложных условиях вы можете четко показать, на каком уровне каждое условие использует отступ.

if (  (  (var1A == var2A)
      || (var1B == var2B))
   && (  (var1C == var2C)
      || (var1D == var2D)))
{
   // do something
}

Мне нравится выстраивать код / ​​инициализации в «столбцы» ... Оказывается очень полезным при редактировании с помощью редактора, поддерживающего режим «столбец», а также мне кажется, что его намного легче читать ...

int myVar        = 1;    // comment 1
int myLongerVar  = 200;  // comment 2

MyStruct arrayOfMyStruct[] = 
{   
    // Name,                 timeout,   valid
    {"A string",             1000,      true    },   // Comment 1
    {"Another string",       2000,      false   },   // Comment 2 
    {"Yet another string",   11111000,  false   },   // Comment 3
    {NULL,                   5,         true    },   // Comment 4
};

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

int myVar = 1; // comment 1
int myLongerVar = 200; // comment 2

MyStruct arrayOfMyStruct[] = 
{   
    // Name, timeout, valid
    {"A string", 1000, true},// Comment 1
    {"Another string", 2000, false }, // Comment 2 
    {"Yet another string", 11111000,false}, // Comment 3
    {NULL, 5, true }, // Comment 4
};

Нет избранного, но я исправляю код воля, который имеет:

1. tabs - вызывает несовпадение во многих IDE и инструментах проверки кода, потому что они не всегда соглашаются с табуляцией в пробелах мода 8.
2. строки длиннее 80 столбцов - давайте посмотрим правде в глаза, более короткие строки читаются лучше. Мой мозг может анализировать большинство условных обозначений кодирования, если строки короткие.
3. строки с конечными пробелами - git будет жаловаться на них как на пробелы ошибки, которые отображаются как красные капли в различиях, что раздражает.

Вот однострочный способ поиска проблемных файлов:

git grep -I -E '<tab>|.{81,}|  *$' | cut -f1 -d: | sort -u

где <tab> - символ табуляции (регулярное выражение POSIX не выполняет \ t)

При создании перечислений поместите их в пространство имен, чтобы вы могли получить к ним доступ с осмысленным именем:

namespace EntityType {
    enum Enum {
        Ground = 0,
        Human,
        Aerial,
        Total
    };
}

void foo(EntityType::Enum entityType)
{
    if (entityType == EntityType::Ground) {
        /*code*/
    }
}

РЕДАКТИРОВАТЬ: Однако этот метод устарел в C++ 11. Вместо этого следует использовать Перечисление с ограничением (объявленный с enum class или enum struct): он более безопасен по типу, краток и гибок. В перечислениях в старом стиле значения помещаются во внешнюю область видимости. При нумерации в новом стиле они помещаются в область действия имени enum class. Предыдущий пример переписан с использованием перечисления с ограниченной областью видимости (также известного как строго типизированное перечисление):

enum class EntityType {
    Ground = 0,
    Human,
    Aerial,
    Total
};

void foo(EntityType entityType)
{
    if (entityType == EntityType::Ground) {
        /*code*/
    }
}

Есть и другие существенные преимущества от использования перечислений с ограниченными областями: отсутствие неявного приведения типов, возможное прямое объявление и возможность использовать настраиваемый базовый тип (не int по умолчанию).

re: ididak

Я исправляю код, который разбивает длинные операторы на слишком много коротких строк.

Посмотрим правде в глаза: это уже не 90-е. Если ваша компания не может позволить себе широкоформатные ЖК-дисплеи для своих кодеров, вам нужно найти лучшую работу :)

Мне очень нравится помещать небольшой оператор в одну строку с if

int myFunc(int x) {
   if (x >20) return -1;
   //do other stuff ....
}

Я всегда придираюсь и редактирую следующее:

• Лишние символы новой строки
• Нет новой строки в EOF

Полезно помещать имена функций в новую строку, чтобы вы могли использовать grep как

grep -R '^fun_name' .

для них. Я видел, что этот стиль используется для множества проектов GNU, и он мне нравится:

static void
fun_name (int a, int b) {
    /* ... */
}

Я обычно придерживаюсь KNF, описанного в * BSD СТИЛЬ (9)

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

void foo( int a, int b )
{
  int c = a + ( a * ( a * b ) );
  if ( c > 12 )
    c += 9;
  return foo( 2, c );
}

Я склонен ставить другое на все свои «если».

if (condition)
{
    complicated code goes here
}
else
{
    /* This is a comment as to why the else path isn't significant */ 
}

Хотя это раздражает моих коллег. С первого взгляда можно сказать, что во время кодирования я учел другой случай.

RAII: получение ресурсов - это инициализация

RAII может быть самой важной идиомой. Идея заключается в том, что ресурсы должны быть сопоставлены с объектами, чтобы время их жизни управлялось автоматически в соответствии с областью, в которой эти объекты объявлены.

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

Одним из основных преимуществ этого является то, что C++ гарантирует, что деструкторы вызываются, когда объект выходит за пределы области видимости, независимо от того, как контроль покидает эту область. Даже если возникнет исключение, все локальные объекты выйдут из области видимости, и связанные с ними ресурсы будут очищены.

void foo() {
  std::fstream file("bar.txt"); // open a file "bar.txt"
  if (rand() % 2) {
    // if this exception is thrown, we leave the function, and so
    // file's destructor is called, which closes the file handle.
    throw std::exception();
  }
  // if the exception is not called, we leave the function normally, and so
  // again, file's destructor is called, which closes the file handle.
}

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

RAII также менее известен как SBRM (Scope-Bound Resource Management).

Смотрите также:

• ScopeGuard позволяет коду «автоматически вызывать операцию отмены ... в случае возникновения исключения».

pImpl: указатель на реализацию

Идиома pImpl - очень полезный способ отделить интерфейс класса от его реализации.

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

Заголовок windows.h является здесь ярким примером. Мы можем захотеть обернуть HANDLE или другой тип Win32 внутри класса, но мы не можем поместить HANDLE в определение класса без необходимости включать windows.h везде, где используется класс.

Тогда решение состоит в том, чтобы создать пrivate IMPLementation или пointer-to-IMPLementation класса, и позволить публичной реализации хранить только указатель на частный и пересылать все методы-члены.

Например:

class private_foo; // a forward declaration a pointer may be used

// foo.h
class foo {
public:
  foo();
  ~foo();
  void bar();
private:
  private_foo* pImpl;
};

// foo.cpp
#include whichever header defines the types T and U

// define the private implementation class
class private_foo {
public:
  void bar() { /*...*/ }

private:
  T member1;
  U member2;
};

// fill in the public interface function definitions:
foo::foo() : pImpl(new private_foo()) {}
foo::~foo() { delete pImpl; }
void foo::bar() { pImpl->bar(); }

Реализация foo теперь отделена от общедоступного интерфейса, так что

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

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

Я бы предложил PIMPL или, как первоначально назвал его Джеймс Коплиен, «Handle Body».

Эта идиома позволяет полностью отделить интерфейс от реализации. При работе над переписыванием и повторным выпуском основного компонента промежуточного программного обеспечения CORBA эта идиома использовалась для полного отделения API от реализации.

Это практически исключило любую возможность обратного проектирования.

Отличный ресурс по идиомам C++ - отличная книга Джеймса Коплиена «Стили и идиомы расширенного программирования на C++». Настоятельно рекомендуется!

Редактировать: Как указано ниже Нилом, эта книга довольно устарела, и многие из его рекомендаций фактически включены в сам стандарт C++. Тем не менее, я по-прежнему считаю, что это источник полезной информации, особенно. в форме его Документ PLoP по идиомам C++, где многие идиомы были преобразованы в форму шаблона.

CRTP: любопытно повторяющийся шаблон шаблона

CRTP происходит, когда вы передаете класс в качестве параметра шаблона его базовому классу:

template<class Derived>
struct BaseCRTP {};

struct Example : BaseCRTP<Example> {};

Внутри базового класса он может получить производный экземпляр, в комплекте с производным типом, просто путем преобразования (работает либо static_cast, либо dynamic_cast):

template<class Derived>
struct BaseCRTP {
  void call_foo() {
    Derived& self = *static_cast<Derived*>(this);
    self.foo();
  }
};

struct Example : BaseCRTP<Example> {
  void foo() { cout << "foo()\n"; }
};

Фактически, call_foo был впрыснутый в производном классе с полным доступом к членам производного класса.

Не стесняйтесь редактировать и добавлять конкретные примеры использования, возможно, в другие сообщения SO.

Копирование-своп

Идиома copy-swap обеспечивает безопасное копирование. Это требует, чтобы были реализованы корректный ctor копирования и своп.

struct String {
  String(String const& other);

  String& operator=(String copy) { // passed by value
    copy.swap(*this); // nothrow swap
    return *this; // old resources now in copy, released in its dtor
  }

  void swap(String& other) throw() {
    using std::swap; // enable ADL, defaulting to std::swap
    swap(data_members, other.data_members);
  }

private:
  Various data_members;
};
void swap(String& a, String& b) { // provide non-member for ADL
  a.swap(b);
}

Вы также можете реализовать метод подкачки с помощью ADL (Argument Dependent Lookup) напрямую.

Эта идиома важна, потому что она обрабатывает самоназначение ^[1], обеспечивает строгую гарантию исключения ^[2] и часто очень проста в написании.

^[1] Несмотря на то, что самоназначение обрабатывается не настолько эффективно, насколько это возможно, предполагается, что это редкий, поэтому, если этого никогда не произойдет, на самом деле это будет быстрее.

^[2] Если возникает какое-либо исключение, состояние объекта (*this) не изменяется.

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

Полиморфизм времени компиляции

(Также известный как синтаксический полиморфизм и статический полиморфизм, в отличие от полиморфизма времени выполнения.)

С помощью шаблонных функций можно написать код, который полагается на конструкторы типов и сигнатуры вызовов семейств параметризованных типов, без необходимости вводить общий базовый класс.

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

Два простых примера:

#include <stdexcept>

template <typename T>
T twice(T n) {
  return 2 * n;
}

InIt find(InIt f, InIt l,
          typename std::iterator_traits<InIt>::reference v)
{
  while (f != l && *f != v)
    ++f;
  return f;
}   

int main(int argc, char* argv[]) {
  if (6 != twice(3))
    throw std::logic_error("3 x 2 = 6");

  int const nums[] = { 1, 2, 3 };
  if (nums + 4 != find(nums, nums + 4, 42))
    throw std::logic_error("42 should not have been found.");

  return 0;
}

Можно вызвать twice с любым обычным типом, для которого определен бинарный оператор *. Точно так же можно вызвать find() с любыми сопоставимыми типами и этой моделью Входной итератор. Один набор кода одинаково работает с разными типами, при этом общих базовых классов в поле зрения нет.

Конечно, на самом деле здесь происходит то, что один и тот же исходный код представляет собой расширенный для различных функций, зависящих от типа, во время создания экземпляра шаблона, каждая с отдельным сгенерированным машинным кодом. Принятие того же набора типов без шаблонов потребовало бы либо 1) отдельных рукописных функций с определенными сигнатурами, либо 2) полиморфизма времени выполнения через виртуальные функции.

Шаблон и крючок

Это способ обработать как можно больше во фреймворке и предоставить дверь или крюк для настройки пользователями фреймворка. Также известен как Hotspot и Шаблонный метод.

class Class {
  void PrintInvoice();     // Called Template (boilerplate) which uses CalcRate()
  virtual void CalcRate() = 0;  // Called Hook
}

class SubClass : public Class {
  virtual void CalcRate();      // Customized method
}

Описан Вольфганг Пре в его книге Шаблоны проектирования для объектно-ориентированной разработки программного обеспечения.

if / while / для выражений в скобках с пробелом

if (expression)  // preferred - if keyword sticks out more

против.

if (expression)  // looks too much like a void function call

Я предполагаю, что это означает, что мне нравится, что мои вызовы функций НЕ имеют разделителя пробелов

foo(parm1, parm2);

Публичный верх - частный даун

На первый взгляд это небольшая оптимизация, но с тех пор, как я перешел на это соглашение, у меня стало намного веселее изучать свои классы, особенно после того, как я не смотрел на них в течение 42 лет.

Чрезвычайно полезно иметь постоянную видимость участников, начиная от часто интересных и заканчивая скучными вещами, особенно когда код должен быть самодокументированным.

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

• Общедоступный, защищенный, частный
• затем Factory, ctor, dtor, копирование, замена
• затем класс Интерфейс В самом конце, в отдельном разделе private:, идут данные (в идеале только импли-указатель).

Это правило также очень помогает, если у вас есть проблемы с сохранением незагроможденного объявления класса.

class Widget : public Purple {
public:
    // Factory methods.
    Widget FromRadians (float);
    Widget FromDegrees (float);

    // Ctors, rule of three, swap
    Widget();
    Widget (Widget const&);
    Widget &operator = (Widget const &);
    void swap (Widget &) throw();

    // Member methods.
    float area() const;

    // in case of qt {{ 
public slots:
    void invalidateBlackHole();

signals:
    void areaChanged (float);
    // }}

protected:    
    // same as public, but for protected members


private:    
    // same as public, but for private members

private:
    // data
    float widgetness_;
    bool  isMale_;
};