Который является лучшим для повторяющейся части кода?

Если ваша функция получает доступ к состоянию, но не изменяет его, используйте константную функцию-член.

Ваш случай:

Если это ваша функция 1) не требует доступа к какому-либо члену кода, и 2) относится к этому классу, затем сделайте его статической функцией вашего класса.

Таким образом становится ясно, что он не изменяет состояние и не основан на состоянии объекта.

Еще один случай, о котором вы не упомянули:

Есть еще одна вещь, которую вы можете сделать. И это сделано для того, чтобы ваш SharedPart принял указатель на функцию-член и вызвал его, а затем обработал его основное тело. Если у вас много First (), Second (), Third (), Fourth (), ... таких функций, это может привести к меньшему дублированию кода. Таким образом, вам не нужно постоянно вызывать SharedPart (); в конце каждой функции-члена, и вы можете повторно использовать First (), Second (), THird (), .. . без вызова SharedPart () кода.

Я бы сказал:

• Это, вероятно, не имеет значения, так что это не столько «лучшая практика», сколько «просто не делай ничего сумасшедшего».
• Если class и все его члены определены в его заголовке, тогда, вероятно, лучше всего подойдет частная статическая функция-член, поскольку она четко указывает «не для клиентов». Но есть способы сделать это для функции, не являющейся членом: не документируйте ее, добавьте комментарий «не для клиентов» и поместите все это в пространство имен beware_of_the_leopard .
• Если Функции-члены класса определены в файле .cpp, тогда небольшие вспомогательные функции, подобные этой, лучше всего использовать в качестве бесплатных функций в файле .cpp. Либо статические, либо в анонимном пространстве имен.

Сделать его функцией, не являющейся членом

Общий фрагмент кода не требует доступа к каким-либо членам класса.

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

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

Вот это пример того, что я имею в виду:

namepsace Astuff{
  class A{...};

  void sharedPart(){...};

  void first(const A& a);
  void second(const A& a);
}

void Astuff::first(const A& a){
   a.first();
   sharedPart();
}

статическая функция-член, константа нестатическая функция-член или локальная function.

Как правило, это должна быть функция-член другого класса или, по крайней мере, нестатический член самого класса. Если эта функция вызывается только из членов экземпляра класса - вероятно, для ее логического значения требуется экземпляр, даже если синтаксис этого не делает. Может ли что-либо, кроме этого объекта, предоставлять значимые параметры или использовать результат?

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

Заимствование примеров из комментария Брайана: если эта функция изменяет глобальное состояние, она должна быть членом класса глобального состояния; если эта функция записывает в файл, она должна быть членом класса формата файла; если это обновляющий экран, он должен быть членом ... и т. д. Даже если это простое арифметическое выражение, может быть полезно сделать его членом (статическим или нет) некоторого класса ArithmeticsForSpecificPurpose.

Или это может быть другой класс.

Или, если он член, он может быть виртуальным.

Есть много решений, и я бы не стал подчеркивать слишком много об этом. Как правило, я выбираю нестатическую функцию-член const по умолчанию, если у меня нет веской причины не делать это таким образом.

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

Сделать эту функцию нечленой, не дружественной. У Скотта Мейера есть прекрасное объяснение этого здесь (а также пункт 23 эффективного C ++ 3-го издания).

Практическое правило «постарайтесь сохранить его как можно более локальным, но настолько видимым, насколько это необходимо».

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

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

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

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

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

И последнее замечание: если вы выберете глобальную статическую функцию, появится " больше c ++ like "версия: анонимные пространства имен. У него есть приятное свойство, заключающееся в том, что он может фактически сохранять состояние, а также не позволяет пользователям даже пересылать объявление каких-либо его функций.

// in your .cpp file
namespace /*anonymous*/
{
   void foo()
   {
     // your code here
   }
};

void MyClass::FooUser1() { foo(); }
void MyClass::FooUser2() { foo(); }