C++将执行一段代码以及该代码块之后的某个命令的宏

Question

void main()
{
    int xyz = 123; // original value
    { // code block starts
        xyz++;
        if(xyz < 1000)
            xyz = 1;
    } // code block ends
    int original_value = xyz; // should be 123
}

void main()
{
    int xyz = 123; // original value
    MACRO_NAME(xyz = 123) // the macro takes the code code that should be executed at the end of the block.
    { // code block starts
        xyz++;
        if(xyz < 1000)
            xyz = 1;
    } // code block ends << how to make the macro execute the "xyz = 123" statement?
    int original_value = xyz; // should be 123
}

只有第一个 main() 有效。
我认为评论已经解释了这个问题。

它不需要是一个宏，但对我来说，它听起来像是一个经典的“需要宏”的情况。

顺便说一句，有 BOOST_FOREACH 宏/库，我认为它完成了与我想要实现的完全相同的事情，但它对我来说太复杂了，无法找到我需要的本质。
从其介绍性手册页来看，有一个示例：

#include <string>
#include <iostream>
#include <boost/foreach.hpp>

int main()
{
    std::string hello( "Hello, world!" );

    BOOST_FOREACH( char ch, hello )
    {
        std::cout << ch;
    }

    return 0;
}

Answer 1

最干净的方法可能是使用 RAII 容器来重置值：

// Assumes T's assignment does not throw
template <typename T> struct ResetValue
{
    ResetValue(T& o, T v) : object_(o), value_(v) { }
    ~ResetValue() { object_ = value_; }

    T& object_;
    T value_;
};

用作：

{
    ResetValue<int> resetter(xyz, 123);
    // ...
}

当块结束时，将调用析构函数，将对象重置为指定值。

如果你确实想要使用宏，只要它是一个相对简单的表达式，你就可以使用 for 块来实现：

for (bool b = false; b == false; b = true, (xyz = 123))
{
    // ...
}

它可以变成宏：

#define DO_AFTER_BLOCK(expr) \
    for (bool DO_AFTER_BLOCK_FLAG = false; \
         DO_AFTER_BLOCK_FLAG == false; \
         DO_AFTER_BLOCK_FLAG = true, (expr))

用作：

DO_AFTER_BLOCK(xyz = 123)
{
    // ...
}

I don'我真的不认为宏观方法是个好主意；如果我在生产源代码中看到这一点，我可能会感到困惑。

Answer 2

您并不绝对需要宏 - 您可以使用内部作用域变量：

#include <stdio.h>
int main(void)
{
    int xyz = 123;
    printf("xyz = %d\n", xyz);
    {
        int pqr = xyz;
        int xyz = pqr;
        printf("xyz = %d\n", xyz);
        xyz++;
        if (xyz < 1000)
            xyz = 1;
        printf("xyz = %d\n", xyz);
    }
    printf("xyz = %d\n", xyz);
    return(0);
}

这会产生输出：

xyz = 123
xyz = 123
xyz = 1
xyz = 123

如果您使用 GCC 和 -Wshadow 进行编译，您会收到警告；否则，它编译干净。
您无法可靠地在内部块中写入int xyz = xyz;；一旦解析了“=”，声明就完成了，因此初始化器是内部“xyz”，而不是外部。不过，两步舞还是有效的。

这样做的主要缺点是需要修改代码块。

如果块中存在副作用（如上面的打印语句），您可以调用包含内部块的函数。如果块中没有副作用，那么为什么要执行它呢？

#include <stdio.h>
static void inner(int xyz)
{
    printf("xyz = %d\n", xyz);
    xyz++;
    if (xyz < 1000)
        xyz = 1;
    printf("xyz = %d\n", xyz);
}

int main(void)
{
    int xyz = 123;
    printf("xyz = %d\n", xyz);
    inner(xyz);
    printf("xyz = %d\n", xyz);
    return(0);
}

Answer 3

除非将循环放入宏中，否则无法使宏在循环后执行命令。认真的吗？仅仅创建一个作用域变量会是一个更好的主意。

template<typename T> class CallFunctionOnScopeExit {
    T t;
public:
    CallFunctionOnScopeExit(T tt) : t(tt) {}
    ~CallFunctionOnScopeExit() { t(); }
};

在异常等情况下得到保证，而宏版本绝对不是。我更愿意使用这种模式来保证异常，因为它比仅仅复制 int 更灵活。