使用 C++ 宏创建新范围？

Question

这甚至可能吗？我想编写一个宏，以便更轻松地使用我的某些类功能。

假设我的类中有 2 个成员函数 setup() 和 cleanup()，其中 setup() 为需要在自己的范围内执行的某些操作设置参数，而 cleanup() 执行清理（类似构造函数和析构函数的概念）。

目前，我这样做：

myClassInstance.setup(); //call the setup function
{ //start scope
    //CREATE LOCAL VARS
    //DO STUFF IN THIS SCOPE
    myClassInstance.cleanup(); //cleanup
} //end scope, destroy locals

但想做这样的事情：

NEWSCOPE(myClassInstance) //calls setup()
{
    //CREATE LOCAL VARS
    //DO STUFF IN THIS SCOPE
} // calls cleanup() and destroys locals

我的想法是写一个宏类，可以在使用宏时实例化，并且 setup() 和 cleanup() 可以在构造函数/析构函数中实现......或类似的东西......

这是考虑这个问题的正确方法，还是有另一种方法可以编写一个基本上可以环绕用户编写的代码的宏？

* 编辑 * 我修复了命名约定，因为函数名称会引起混淆。

Answer 1

要创建一个新范围，只需使用匿名块。

{ 
    Obj obj;
    /* 
    teh codez
    */
}//obj is deallocated

所以你不需要宏

听起来你 startScope 和 endScope 实际上应该是构造函数和析构函数，但是如果不知道它们实际上做什么，就很难知道

更新：我试图给你一个答案，但我只会咆哮。

类似于构造函数和析构函数的概念

在我看来，它们是构造函数和析构函数，当您让构造函数和析构函数进行设置和清理时，RAII 将自然而易读地执行操作。

另一件事，你说你的第一个解决方案（我有点不小心把它给了你）正在工作，为什么需要使用宏的解决方法，在 C 宏中需要模拟 C++ 提供的功能（如模板和对象）。对于几乎所有情况，尤其是在 C++11 中，宏只会让事情变得更糟，更难调试，在你的情况下，看起来你在执行宏时实际上必须输入更多内容？

我的建议是重新考虑为什么需要宏以及为什么setup 和cleanup 不能成为构造函数和析构函数。

Answer 2

您可以像使用 RAII 获得互斥锁一样对待它。像这样的：

class MyClassScopeBlock
{
  public:
    MyClassScopeBlock( MyClass & c )
        : obj(c)
    {
        obj.startScope();
    }

    ~MyClassScopeBlock()
    {
        obj.endScope();
    }

  private:
    MyClass & obj;
};

然后将其实例化为作用域块内的局部变量：

{
    MyClassScopeBlock block( myClassInstance );
    //CREATE LOCAL VARS
    //DO STUFF IN THIS SCOPE
}

如果你真的想要，你可以为它定义一个宏，在作用域块内使用：

#define NEWSCOPE(inst) MyClassScopeBlock block(inst)

就个人而言，我更喜欢尽可能远离宏。

Answer 3

在看到 BOOST_FOREACH 宏后，我花了几个小时试图弄清楚如何使宏控制范围。在弄清楚它的过程中，我遇到了这个问题，希望它能够回答！但是，不完全是。所以，我通读了所有的code for the BOOST_FOREACH 和原始的design for BOOST_FOREACH。然后我觉得有点愚蠢......宏基本上将代码直接插入到它所在的位置。这意味着我们可以有一个宏：

#define LOOP_3() \
    for(int i = 0; i < 3; ++i)

现在，让我们测试一下吧！

LOOP_3() std::cout << "Hello World!" << std::endl;
/* === Output ===
Hello World!
Hello World!
Hello World!
*/

耶！但是，这有什么用呢？那么，在循环结束时i 会发生什么？ 调用了析构函数，对于i 来说不是太花哨，但想法就在那里。

我们现在只需要一个类来处理这个问题：

class SCOPE_CONTROL {
public:
    SCOPE_CONTROL(): run(1) { std::cout << "Starting Scope!" << std::endl; }
    ~SCOPE_CONTROL() { std::cout << "Ending Scope!" << std::endl; }
    bool run;
}

让我们使用那个吸盘！

#define NEWSCOPE() \
    for(SCOPE_CONTROL sc = SCOPE_CONTROL(); sc.run; sc.run = 0)

...
NEWSCOPE()
    std::cout << "    In the Body!" << std::endl;
std::cout << "Not in body..." << std::endl;
...

/* === Output ===
Starting Scope!
    In the Body!
Ending Scope!
Not in body...
*/

---

要使用setup 和cleanup 函数，只需稍作改动！

class SCOPE_CONTROL {
public:
    SCOPE_CONTROL(MyClass myClassInstance): control(myClassInstance), run(1) { 
        control.setup();
    }
    ~SCOPE_CONTROL() { control.cleanup(); }
    bool run;
    MyClass & control;
}
#define NEWSCOPE(control) \
    for(SCOPE_CONTROL sc = SCOPE_CONTROL(control); sc.run; sc.run = 0)

...
NEWSCOPE(myClassInstance)
{
    // CREATE LOCAL VARS
    // DO STUFF IN THIS SCOPE
}   // end scope, destroy locals
...

为了更好地使用ENCODED_TYPE（如何在BOOST_FOREACH的设计中非常简单！）允许SCOPE_CONTROL成为模板类型。

Answer 4

将整个作用域放入宏替换的更好替代方法是使用finally block 之类的东西。我已经成功地用这些宏封装了链接的解决方案：

#define FINALLY_NAMED( NAME, ... ) auto && NAME = \
        util::finally( [&]() noexcept { __VA_ARGS__ } );
#define FINALLY( ... ) CPLUS_FINALLY_NAMED( guard, __VA_ARGS__ )
#define DO_FINALLY static_cast< void >( guard );

用法：

{
    myClassInstance.setup(); //call the setup function
    FINALLY ( myClassInstance.cleanup(); ) //call the cleanup function before exit

    // do something

    DO_FINALLY // Explicitly note that cleanup happens here. (Only a note.)
}

这是异常安全的，当且仅当setup 成功完成时，cleanup 才会执行，就像构造函数/析构函数对一样。但是cleanup一定不能抛出异常。

---

但是如果你想用老式的方式来做……

您可以使用可变参数宏将整个范围包含在宏中：

#define NEWSCOPE( INSTANCE, ... ) { \
    (INSTANCE).setup(); /* call the setup function */ \
    { __VA_ARGS__ } /* paste teh codez here */ \
    (INSTANCE).cleanup(); /* call the cleanup function */

我建议不要将cleanup 放在内部作用域内，因为作用域的意义在于包含声明和名称，但您想在外部作用域中使用INSTANCE 的名称。

用法：

NEWSCOPE ( myClassInstance,
    // Do stuff.
    // Multiple declarations, anything can go here as if inside braces.
    // (But no #define directives. Down, boy.)
)