Duplizieren Sie Code mit c ++ 11

Ich arbeite derzeit an einem Projekt und habe das folgende Problem.

Ich habe eine C ++ - Methode, mit der ich auf zwei verschiedene Arten arbeiten möchte:

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

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

Und ich möchte meinen Code nicht duplizieren, da die eigentliche Funktion viel länger ist. Das Problem ist, dass ich unter keinen Umständen dem Programm Ausführungszeit hinzufügen darf, wenn MyFunction anstelle von MyFunctionWithABonus aufgerufen wird. Deshalb kann ich nicht einfach einen booleschen Parameter haben, den ich mit einem C ++ - Vergleich überprüfe.

Meine Idee wäre gewesen, C ++ - Vorlagen zu verwenden, um meinen Code virtuell zu duplizieren, aber ich kann mir keine Möglichkeit vorstellen, bei der ich keine zusätzliche Ausführungszeit habe und den Code nicht duplizieren muss.

Ich bin kein Experte für Vorlagen, daher fehlt mir möglicherweise etwas.

Hat jemand von euch eine Idee? Oder ist das in C ++ 11 einfach unmöglich?

Mit Vorlage und Lambda können Sie Folgendes tun:

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

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

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

oder Sie können einfach erstellen prefixund suffixfunktionieren.

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

void suffix()
{
    foobar();
}

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

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

So etwas wird gut funktionieren:

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

Nennen Sie es über:

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

Die "hässliche" Vorlage kann vermieden werden, indem den Funktionen einige nette Wrapper hinzugefügt werden:

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

Sie können einige nette Informationen auf dieser Technik finden dort . Das ist ein "altes" Papier, aber die Technik an sich bleibt völlig richtig.

Vorausgesetzt, Sie haben Zugriff auf einen netten C ++ 17-Compiler, können Sie die Technik sogar weiter vorantreiben, indem Sie den constexpr verwenden, wenn :

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

In Anbetracht einiger Kommentare, die das OP zum Debuggen abgegeben hat, ist hier eine Version, die doBonusStuff()Debug-Builds fordert , aber keine Builds veröffentlicht (die definieren NDEBUG):

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

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

Sie können das assertMakro auch verwenden, wenn Sie eine Bedingung überprüfen möchten, und fehlschlagen, wenn sie falsch ist (jedoch nur für Debug-Builds; Release-Builds führen die Prüfung nicht durch).

Seien Sie vorsichtig, wenn doBonusStuff()Nebenwirkungen auftreten, da diese Nebenwirkungen in Release-Builds nicht vorhanden sind und möglicherweise die im Code getroffenen Annahmen ungültig machen.

Hier ist eine geringfügige Abweichung von Jarod42s Antwort unter Verwendung verschiedener Vorlagen, sodass der Anrufer null oder eine Bonusfunktion bereitstellen kann:

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

Aufrufcode:

MyFunction();
MyFunction(&doBonusStuff);

Eine andere Version, die nur Vorlagen und keine Umleitungsfunktionen verwendet, da Sie sagten, Sie wollten keinen Laufzeit-Overhead. Für mich erhöht dies nur die Kompilierungszeit:

#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

Es gibt jetzt nur eine Version von MyFunc()mit dem boolParameter als Vorlagenargument.

Sie können Tag-Dispatching und einfache Funktionsüberladung verwenden:

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

Dies ist leicht zu lesen / zu verstehen, kann ohne Schweiß (und ohne Heizplatte) erweitert werden if Klauseln - durch Hinzufügen weiterer Tags) erweitert werden und hinterlässt natürlich keinen Laufzeit-Footprint.

Die aufrufende Syntax ist zwar recht freundlich, kann aber natürlich in Vanille-Aufrufe eingepackt werden:

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

Das Versenden von Tags ist eine weit verbreitete generische Programmiertechnik. Hier ist ein schöner Beitrag über die Grundlagen.