使用C ++ 11复制代码

我目前正在从事一个项目，但遇到以下问题。

我有一个C ++方法，希望以两种不同的方式工作：

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

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

而且我不想重复我的代码，因为实际功能要长得多。问题是在任何情况下都不能在调用MyFunction而不是MyFunctionWithABonus时增加程序的执行时间。这就是为什么我不能只具有通过C ++比较检查的布尔参数。

我的想法是使用C ++模板虚拟地复制我的代码，但是我无法想到一种无需额外执行时间且无需复制代码的方法。

我不是模板专家，所以我可能会缺少一些东西。

你们有什么主意吗？还是在C ++ 11中这是不可能的？

使用模板和lambda，您可以执行以下操作：

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 if来进一步推动该技术，例如：

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{}); }

标签分派是一种广泛使用的通用编程技术，这是一篇有关基础知识的不错的文章。