Дублікат коду за допомогою c ++ 11

Зараз я працюю над проектом, і у мене є наступне питання.

У мене є метод C ++, над яким я хочу працювати двома різними способами:

void MyFunction()
{
  foo();
  bar();
  foobar();
}

void MyFunctionWithABonus()
{
  foo();
  bar();
  doBonusStuff();
  foobar();
}

І я хотів би не дублювати мій код, оскільки фактична функція набагато довша. Проблема полягає в тому, що я ні за яких обставин не повинен додавати час виконання програми, коли MyFunction викликається замість MyFunctionWithABonus. Ось чому я не можу просто мати логічний параметр, який я перевіряю за допомогою порівняння C ++.

Моя ідея полягала б у використанні шаблонів C ++ для практично дублювання мого коду, але я не можу придумати спосіб, коли б у мене не було додаткового часу на виконання, і мені не потрібно дублювати код.

Я не фахівець із шаблонами, тому, можливо, чогось мені не вистачає.

Хтось із вас має ідею? Або це просто неможливо в C ++ 11?

За допомогою шаблону та лямбди ви можете зробити:

template <typename F>
void common(F f)
{
  foo();
  bar();
  f();
  foobar();
}

void MyFunction()
{
    common([](){});
}

void MyFunctionWithABonus()
{
  common(&doBonusStuff);
}

або ж ви можете просто створювати prefixта suffixфункціонувати.

void prefix()
{
  foo();
  bar();
}

void suffix()
{
    foobar();
}

void MyFunction()
{
    prefix();
    suffix();
}

void MyFunctionWithABonus()
{
    prefix();
    doBonusStuff();
    suffix();
}

Щось подібне буде робити добре:

template<bool bonus = false>
void MyFunction()
{
  foo();
  bar();
  if (bonus) { doBonusStuff(); }
  foobar();
}

Зателефонуйте через:

MyFunction<true>();
MyFunction<false>();
MyFunction(); // Call myFunction with the false template by default

Шаблону "потворного" можна уникнути, додавши до функцій кілька приємних обгортків:

void MyFunctionAlone() { MyFunction<false>(); }
void MyFunctionBonus() { MyFunction<true>(); }

Ви можете знайти деяку цікаву інформацію на цій техніці там . Це «стара» папір, але сама по собі техніка залишається абсолютно правильною.

За умови, що у вас є доступ до гарного компілятора C ++ 17, ви навіть можете продовжити техніку, використовуючи constexpr, якщо :

template <int bonus>
auto MyFunction() {
  foo();
  bar();
  if      constexpr (bonus == 0) { doBonusStuff1(); }
  else if constexpr (bonus == 1) { doBonusStuff2(); }
  else if constexpr (bonus == 2) { doBonusStuff3(); }
  else if constexpr (bonus == 3) { doBonusStuff4(); }
  // Guarantee that this function will not compile
  // if a bonus different than 0,1,2,3 is passer
  else { static_assert(false);}, 
  foorbar();
}

Беручи до уваги деякі коментарі, які OP зробив щодо налагодження, ось версія, яка вимагає doBonusStuff()збірки налагодження, але не випускає збірки (які визначають NDEBUG):

#if defined(NDEBUG)
#define DEBUG(x)
#else
#define DEBUG(x) x
#endif

void MyFunctionWithABonus()
{
  foo();
  bar();
  DEBUG(doBonusStuff());
  foobar();
}

Ви також можете використовувати assertмакрос, якщо ви хочете перевірити умову, і не вдасться, якщо вона хибна (але тільки для збірок; збірки випуску перевірку не виконають).

Будьте обережні, якщо у вас doBonusStuff()є побічні ефекти, оскільки ці побічні ефекти не будуть присутні у збірках випусків і можуть призвести до втрати припущень, зроблених у коді.

Ось невелика варіація відповіді Jarod42 із використанням різних шаблонів, щоб абонент міг надати нуль або одну бонусну функцію:

void callBonus() {}

template<typename F>
void callBonus(F&& f) { f(); }

template <typename ...F>
void MyFunction(F&&... f)
{
  foo();
  bar();
  callBonus(std::forward<F>(f)...);
  foobar();
}

Телефонний код:

MyFunction();
MyFunction(&doBonusStuff);

Інша версія, що використовує лише шаблони і не має перенаправляючих функцій, оскільки ви сказали, що не хочете зайвих витрат на виконання. Наскільки це швидко, це лише збільшує час компіляції:

#include <iostream>

using namespace std;

void foo() { cout << "foo\n"; };
void bar() { cout << "bar\n"; };
void bak() { cout << "bak\n"; };

template <bool = false>
void bonus() {};

template <>
void bonus<true>()
{
    cout << "Doing bonus\n";
};

template <bool withBonus = false>
void MyFunc()
{
    foo();
    bar();
    bonus<withBonus>();
    bak();
}

int main(int argc, const char* argv[])
{
    MyFunc();
    cout << "\n";
    MyFunc<true>();
}

output:
foo
bar
bak

foo
bar
Doing bonus
bak

Зараз існує лише одна версія MyFunc()з boolпараметром як аргументом шаблону.

Ви можете використовувати диспетчеризацію тегів і просте перевантаження функції:

struct Tag_EnableBonus {};
struct Tag_DisableBonus {};

void doBonusStuff(Tag_DisableBonus) {}

void doBonusStuff(Tag_EnableBonus)
{
    //Do bonus stuff here
}

template<class Tag> MyFunction(Tag bonus_tag)
{
   foo();
   bar();
   doBonusStuff(bonus_tag);
   foobar();
}

Це легко читати / розуміти, його можна розширити, не виділяючи поту (і не застосовуючи шаблонних ifположень - додаванням більшої кількості тегів), і, звичайно, не залишить сліду під час роботи.

Синтаксис виклику він досить зручний, але, звичайно, його можна обернути у ванільні дзвінки:

void MyFunctionAlone() { MyFunction(Tag_DisableBonus{}); }
void MyFunctionBonus() { MyFunction(Tag_EnableBonus{}); }

Диспетчеризація тегів - це широко використовувана загальна техніка програмування, ось приємний допис про основи.