c++ - minecraft splash

Código duplicado usando c++ 11

Question

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 a MyFunction en lugar de MyFunctionWithABonus. Es por eso que no puedo simplemente tener un parámetro booleano que verifico con una comparación de C ++.

Mi idea hubiera 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, por lo que me puede faltar algo.

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

Answer 1

Algo así hará 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>(); }

Puede encontrar información agradable sobre esa técnica there . Ese es un documento "viejo", pero la técnica en sí misma sigue siendo totalmente correcta.

Siempre que tenga acceso a un buen compilador de C ++ 17, incluso puede impulsar aún más la técnica, utilizando constexpr si , de esta manera:

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

Answer 2

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

Answer 3

Con template y lambda, puedes hacer:

template <typename F>
void common(F f)
{
foo();
bar();
f();
foobar();
}
void MyFunction()
{
common([](){});
}
void MyFunctionWithABonus()
{
common(&doBonusStuff);
}

o bien, simplemente puede crear la función de prefix y suffix .

void prefix()
{
foo();
bar();
}
void suffix()
{
foobar();
}
void MyFunction()
{
prefix();
suffix();
}
void MyFunctionWithABonus()
{
prefix();
doBonusStuff();
suffix();
}

Answer 4

Otra versión, usando solo plantillas y sin funciones de redireccionamiento, ya que dijiste que no querías ninguna sobrecarga de tiempo de ejecución. Por 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 parámetro bool como argumento de plantilla.

Answer 5

Puede usar el despacho de etiquetas y la sobrecarga de funciones simples:

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 ampliar sin problemas (y sin repeticiones if cláusulas, al agregar más etiquetas), y por supuesto no dejará huella en tiempo de ejecución.

La sintaxis de las llamadas es bastante amigable, pero por supuesto puede incluirse en llamadas de vainilla:

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

El despacho de etiquetas es una técnica de programación genérica ampliamente utilizada, here hay una buena publicación sobre los conceptos básicos.

Answer 6

Teniendo en cuenta algunos de los comentarios que ha realizado el OP con respecto a la depuración, aquí hay una versión que llama a doBonusStuff() para compilaciones de depuración, pero no versiones 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 usar la macro de assert 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).

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