C++ # ¿define una macro con corchetes?

Question

En vez de hacer lo siguiente cada vez que

start(); 

// some code here 

stop(); 

Me gustaría definir algún tipo de macro que hace posible escribir como:

startstop() 
{ 

//code here 

} 

¿Es posible en C++?

Answer 1

Puede hacer algo muy cerca usando una pequeña clase de ayuda de C++.

class StartStopper { 
public: 
    StartStopper() { start(); } 
    ~StartStopper() { stop(); } 
}; 

Luego en el código:

{ 
    StartStopper ss; 
    // code here 
} 

Cuando la ejecución entra en el bloque y construye la variable ss, se llamará a la función start(). Cuando la ejecución abandona el bloque, se llamará automáticamente al destructor StartStopper y luego llamará al stop().

Answer 2

La forma idiomática de hacer esto en C++ se llama Resource Acquisition Is Initialization, o en breve RAII. Además de proporcionar lo que desea, también tiene el beneficio adicional de ser una excepción segura: se llamará a la función stop incluso si su código arroja una excepción.

definir una estructura de protección:

struct startstop_guard 
{ 
    startstop_guard() 
    { 
     start(); 
    } 
    ~startstop_guard() 
    { 
     stop(); 
    } 
}; 

y luego volver a escribir el código de la siguiente manera:

{ 
    startstop_guard g; 
    // your code 
} 

destructor del guardia (y por lo tanto la función stop) se llamará automáticamente al final de la bloque que lo rodea

Answer 3

¿Qué estás tratando de hacer? Recomiendo ver RAII como una forma mucho más orientada a C++ de hacer cosas que macro hacking, con todas sus consecuencias imprevistas.

Answer 4

#define startstop(x, y, ...) for(/* use macro args */) 

Answer 5

No utilice macros. Puede usar funciones en línea, ya que proporciona verificación de tipos y otras funciones. Puede consultar aquí: inline functions

Answer 6

Solución genérica con función RAII y boost :: (std :: function).

class starter 
{ 
    typedef boost::function< void() > action; 
    action end_; 
public: 
    starter(action start, action end): 
     end_(end) 
    { 
     log("starter start"); 
     start(); 
    } 
    ~starter() 
    { 
     log("starter end"); 
     end_() ; 
    } 
}; 
int main() 
{ 
    { 
     starter s(start, stop); 
     middle(); 
    } 

    return 0; 
} 

o para probar y comprobar la idea

void print(const std::string& message) 
    { 
     std::cout << message << std::endl; 
    } 
    int main() 
    { 
     starter s(boost::bind(print, "globalstart"), 
        boost::bind(print, "globalend")); 

     { 
      starter s(boost::bind(print, "start"), 
         boost::bind(print, "end")); 
      std::cout << "middle" << std::endl; 
     } 
     return 0; 
    } 

Answer 7

Otras respuestas han abordado el lado RAII de la cuestión y, por lo voy a abordar el lado de la sintaxis que.

#define startstop for(Starter s; s.loop; s.loop = false) 
struct Starter { 
    bool loop; 
    Starter() { start(); loop = true; } 
    ~Starter() { stop(); } 
}; 

utilizado como:

startstop { 
    // some code 
} 

Debería explicarse por sí mismo suficiente.

Answer 8

En C#, puede usar el patrón IDisposable e implementar su funcionalidad Stop() en el método Dispose(), pero eso funcionaría si estuviera usando una variante .net de C++.

Answer 9

crédito para dirkgently a la idea .. pensé que llenar el resto de

#define startstop() for(start();isStarted();stop())