Código duplicado usando c ++ 11

Question 1

Actualmente estoy trabajando en un proyecto y tengo el siguiente problema.

Tengo un método C++ que quiero trabajar de dos maneras diferentes:

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

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

Y me gustaría no duplicar mi código porque la función real es mucho más larga. El problema es que bajo ninguna circunstancia debo agregar tiempo de ejecución al programa cuando se llama MyFunction en lugar de MyFunctionWithABonus. Es por eso que no puedo simplemente tener un parámetro booleano que verifique con una comparación de C++.

Mi idea habría sido usar plantillas de C++ para duplicar virtualmente mi código, pero no puedo pensar en una forma de hacerlo en la que no tenga tiempo de ejecución adicional y no tenga que duplicar el código.

No soy un experto en plantillas, así que puede que me esté perdiendo algo.

¿Alguno de ustedes tiene una idea? ¿O es eso simplemente imposible en C++ 11?

Question 2

Algo así funcionará bien:

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

Llámalo a través de:

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

La plantilla “fea” se puede evitar agregando algunos envoltorios agradables a las funciones:

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

Puedes encontrar buena información sobre esa técnica. allá. Ese es un papel “viejo”, pero la técnica en sí misma se mantiene totalmente correcta.

Siempre que tenga acceso a un buen compilador de C++ 17, incluso puede impulsar la técnica, utilizando el constexpr sicomo eso:

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

Question 3

Con template y lambda, puede hacer:

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

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

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

o simplemente puedes crear prefix y suffix función.

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

void suffix()
{
    foobar();
}

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

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

Question 4

Teniendo en cuenta algunos de los comentarios que ha hecho el OP con respecto a la depuración, aquí hay una versión que llama doBonusStuff() para compilaciones de depuración, pero no compilaciones de lanzamiento (que definen NDEBUG):

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

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

También puede utilizar el assert macro si desea verificar una condición y fallar si es falsa (pero solo para compilaciones de depuración; las compilaciones de lanzamiento no realizarán la verificación).

ten cuidado si doBonusStuff() tiene efectos secundarios, ya que estos efectos secundarios no estarán presentes en las compilaciones de lanzamiento y pueden invalidar las suposiciones hechas en el código.

Question 5

Aquí hay una ligera variación en la respuesta de Jarod42 usando plantillas variadas para que la persona que llama pueda proporcionar cero o una función de bonificación:

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

Código de llamada:

MyFunction();
MyFunction(&doBonusStuff);

Question 6

Otra versión, usando solo plantillas y sin funciones de redirección, ya que dijiste que no querías ninguna sobrecarga de tiempo de ejecución. En lo que a mí respecta, esto solo aumenta el tiempo de compilación:

#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

Ahora solo hay una versión de MyFunc() con el bool parámetro como un argumento de plantilla.

Question 7

Puedes usar envío de etiquetas y sobrecarga de función simple:

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

Esto es fácil de leer/comprender, se puede expandir sin sudar (y sin repetitivo if cláusulas agregando más etiquetas) y, por supuesto, no dejará huella en el tiempo de ejecución.

La sintaxis de llamada es bastante amigable, pero por supuesto se puede envolver en llamadas estándar:

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

El envío de etiquetas es una técnica de programación genérica ampliamente utilizada, aquí es un buen post sobre los conceptos básicos.

¿Ha sido útil esta solución?