C ++ 11을 사용하는 중복 코드

현재 프로젝트를 진행 중이며 다음과 같은 문제가 있습니다.

두 가지 다른 방법으로 작업하려는 C ++ 메서드가 있습니다.

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

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

그리고 실제 기능이 훨씬 길기 때문에 내 코드를 복제하지 않고 싶습니다. 문제는 어떤 상황에서도 MyFunctionWithABonus 대신 MyFunction이 호출 될 때 프로그램에 실행 시간을 추가해서는 안된다는 것입니다. 그렇기 때문에 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 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매크로를 사용하고 false이면 실패 할 수도 있습니다 (그러나 디버그 빌드에만 해당되며 릴리스 빌드는 확인을 수행하지 않습니다).

doBonusStuff()이러한 부작용은 릴리스 빌드에 나타나지 않으며 코드에서 가정 한 내용을 무효화 할 수 있으므로 부작용이있는 경우주의하십시오 .

호출자가 0 개 또는 1 개의 보너스 기능을 제공 할 수 있도록 가변 템플릿을 사용하는 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{}); }

태그 디스 패칭은 널리 사용되는 일반 프로그래밍 기술이며 여기 에 기본에 대한 멋진 게시물이 있습니다.