c++ - 宏的if语句中的变量初始化

我是一个设计cubesat（纳米卫星）的大学团队的成员。
同一子系统上的另一个人的任务是实现一个日志库，我们可以将其与错误流一起使用。
核心更改分别在两个文件Logger.hpp和Logger.cpp中发生。

他使用不同的“日志级别”，每个级别对应于错误的严重性：

#if defined LOGLEVEL_TRACE
#define LOGLEVEL Logger::trace
#elif defined LOGLEVEL_DEBUG
#define LOGLEVEL Logger::debug
#elif defined LOGLEVEL_INFO
[...]
#else
#define LOGLEVEL Logger::disabled
#endif

级别在#define内部：

enum LogLevel {
        trace = 32, // Very detailed information, useful for tracking the individual steps of an operation
        debug = 64, // General debugging information
        info = 96, // Noteworthy or periodical events
[...]
};

此外，他介绍了“全局级别”的概念。
即，仅记录严重程度与全局级别相同的错误。
要设置“全局级别”，您需要设置上述常量之一，例如enum。
下面的更多内容。

最后但并非最不重要的一点是，他使用LOGLEVEL_TRACE运算符创建了一个自定义流并使用一些宏魔术使记录变得容易：

template <class T>
Logger::LogEntry& operator<<(Logger::LogEntry& entry, const T value) {
    etl::to_string(value, entry.message, entry.format, true);

    return entry;
}

这个问题是关于下面的代码；他介绍了一个花哨的宏：

#define LOG(level)
    if (Logger::isLogged(level)) \
        if (Logger::LogEntry entry(level); true) \
            entry

<<只是一个帮助程序isLogged，将每个级别与“全局”级别进行比较：

static constexpr bool isLogged(LogLevelType level) {
        return static_cast<LogLevelType>(LOGLEVEL) <= level;
    }

我从未见过使用这样的宏，在继续我的问题之前，这是他的解释：

Implementation details
This macro uses a trick to pass an object where the << operator can be used, and which is logged when the statement
is complete.

It uses an if statement, initializing a variable within its condition. According to the C++98 standard (1998), Clause 3.3.2.4,
"Names declared in the [..] condition of the if statement are local to the if [...]
statement (including the controlled statement) [...]".

This results in the Logger::LogEntry::~LogEntry() to be called as soon as the statement is complete.
The bottom if statement serves this purpose, and is always evaluated to true to ensure execution.

Additionally, the top `if` checks the sufficiency of the log level.
It should be optimized away at compile-time on invisible log entries, meaning that there is no performance overhead for unused calls to LOG.

这个宏看起来很酷，但是让我有些不安，我的知识不足以形成正确的见解。
因此，这里去：

为什么有人会选择实施这样的设计？
如果有这种方法，有哪些陷阱要注意？
（奖励）如果这种方法不被认为是好的做法，那么可以怎么做呢？

最让我感到惊讶（并使之震惊）的是，尽管其背后的想法似乎并不复杂，但我在互联网上的任何地方都找不到类似的例子。
我开始了解constexpr是我的朋友，并且

宏可能很危险
预处理器不应该被信任

这就是为什么围绕宏构建的设计使我感到恐惧的原因，但是我不知道这种担忧是否有效，或者它是否源于我缺乏理解。

最后，我觉得我没有尽可能地回答（和/或称呼）这个问题。
所以随时修改它:)

最佳答案

这里的一个问题是宏参数被使用了两次。如果在LOG()参数中调用了某些函数或使用了其他具有副作用的表达式，则该表达式（不必是常量表达式）可以被评估两次。也许没什么大不了的，因为在这种情况下，除了LogLevel中的直接LOG()枚举器外，没有其他理由使用其他东西。

一个更危险的陷阱：考虑如下代码

if (!test_valid(obj))
    LOG(Logger::info) << "Unexpected invalid input: " << obj;
else
    result = compute(obj);

扩展宏会将其转换为

if (!test_valid(obj))
    if (Logger::isLogged(Logger::info))
        if (Logger::LogEntry entry(Logger::info); true)
            entry << "Unexpected invalid input: " << obj;
        else
            result = compute(obj);

不管全局日志级别是什么，都不能调用compute函数！

如果您的团队喜欢这种语法，这是一种获得更安全行为的方法。 if (declaration; expression)语法至少意味着C ++ 17，所以我假设了其他C ++ 17功能。首先，我们需要LogLevel枚举器成为具有不同类型的对象，以便使用它们的LOG表达式可以具有不同的行为。

namespace Logger {

template <unsigned int Value>
class pseudo_unscoped_enum
{
public:
    constexpr operator unsigned int() const noexcept
    { return m_value; }
};

inline namespace LogLevel {
    inline constexpr pseudo_unscoped_enum<32> trace;
    inline constexpr pseudo_unscoped_enum<64> debug;
    inline constexpr pseudo_unscoped_enum<96> info;
}

}

接下来，定义一个支持operator<<但不执行任何操作的伪记录器对象。

namespace Logger {

struct dummy_logger {};

template <typename T>
dummy_logger& operator<<(dummy_logger& dummy, T&&)
{ return dummy; }

}

LOGLEVEL可以保留其相同的宏定义。最后，几个重载的函数模板替换了LOG宏（可能在全局名称空间中）：

#include <type_traits>

template <unsigned int Level,
          std::enable_if_t<(Level >= LOGLEVEL), std::nullptr_t> = nullptr>
LogEntry LOG(pseudo_unscoped_enum<Level>) { return LogEntry(Level); }

template <unsigned int Level,
          std::enable_if_t<(Level < LOGLEVEL), std::nullptr_t> = nullptr>
dummy_logger LOG(pseudo_unscoped_enum<Level>) { return {}; }

loglevel

c++ - 宏的if语句中的变量初始化