如何实现编译期/运行期双触发断言？常量参数场景提前检测

给定代码如下：

#include <iostream>
#include <fcntl.h>
#include <assert.h>
#include <stdexcept>

struct MyFile
{
    MyFile(const char* filename, int flags, mode_t mode)
    {
        open(filename, flags, mode);
        std::cout << "Flags = " << flags << std::endl;
        if (flags & O_WRONLY) 
        {
            // do this...
        }
        else if (flags == O_RDONLY) // O_RDONLY == 0
        {
            // do that...
            std::cout << "Hello" << std::endl;
        }
        else
        {
            // 此处逻辑本可在编译期判断，但当前仅能运行时检测
            throw std::runtime_error{ "目前不同时支持读写模式！" };
        }
    }
};

int main()
{
    MyFile file("file.txt", O_RDWR, 0777);
    return 0;
}

这段代码中，main传入的O_RDWR是编译期常量，编译器本可提前识别非法分支，但当前只能在运行时抛出异常。我们需要实现一种混合断言机制：参数为编译期常量时触发编译期断言，参数为运行时变量时触发运行时检查。

解决方案 #

方式1：C++20+ 标准实现（推荐） #

利用std::is_constant_evaluated()判断当前是否处于常量求值上下文，结合constexpr和static_assert实现双模式检查：

#include <iostream>
#include <fcntl.h>
#include <stdexcept>
#include <type_traits>

// 编译期合法flag判断逻辑
constexpr bool is_valid_flags(int flags) {
    return (flags & O_WRONLY) || (flags == O_RDONLY);
}

struct MyFile
{
    template<typename FlagsType>
    MyFile(const char* filename, FlagsType flags, mode_t mode)
    {
        open(filename, static_cast<int>(flags), mode);
        std::cout << "Flags = " << flags << std::endl;

        // 编译期检查优先，运行时兜底
        if constexpr (std::is_constant_evaluated()) {
            static_assert(is_valid_flags(flags), "不支持的文件访问模式！");
        } else {
            if (!is_valid_flags(flags)) {
                throw std::runtime_error{ "目前不同时支持读写模式！" };
            }
        }

        if (flags & O_WRONLY) 
        {
            // do this...
        }
        else if (flags == O_RDONLY)
        {
            std::cout << "Hello" << std::endl;
        }
    }
};

int main()
{
    // 编译期直接报错：O_RDWR属于非法模式
    MyFile file("file.txt", O_RDWR, 0777);

    // 运行时传入变量，触发运行时检查
    int runtime_flags = O_RDWR;
    MyFile file2("file2.txt", runtime_flags, 0777);
    return 0;
}

方式2：兼容C++17及更早版本（编译器扩展） #

使用GCC/Clang内置函数__builtin_constant_p判断参数是否为编译期常量，用宏封装检查逻辑：

#include <iostream>
#include <fcntl.h>
#include <stdexcept>
#include <cassert>

#define CHECK_VALID_FLAGS(flags) \
    do { \
        if (__builtin_constant_p(flags)) { \
            static_assert(((flags) & O_WRONLY) || ((flags) == O_RDONLY), "不支持的文件访问模式！"); \
        } else { \
            assert(((flags) & O_WRONLY) || ((flags) == O_RDONLY) && "不支持的文件访问模式！"); \
            if (!(((flags) & O_WRONLY) || ((flags) == O_RDONLY))) { \
                throw std::runtime_error("目前不同时支持读写模式！"); \
            } \
        } \
    } while(0)

struct MyFile
{
    MyFile(const char* filename, int flags, mode_t mode)
    {
        open(filename, flags, mode);
        std::cout << "Flags = " << flags << std::endl;

        CHECK_VALID_FLAGS(flags);

        if (flags & O_WRONLY) 
        {
            // do this...
        }
        else if (flags == O_RDONLY)
        {
            std::cout << "Hello" << std::endl;
        }
    }
};

int main()
{
    // 编译期触发断言
    MyFile file("file.txt", O_RDWR, 0777);

    // 运行时触发检查
    int runtime_flags = O_RDWR;
    MyFile file2("file2.txt", runtime_flags, 0777);
    return 0;
}

核心逻辑说明 #

1. 编译期检查：当参数是常量表达式时，直接通过static_assert在编译阶段报错，避免运行时开销。
2. 运行时检查：当参数是运行时变量时，用assert或异常抛出实现错误检测，保证程序健壮性。
3. 兼容性：C++20的std::is_constant_evaluated是标准实现，__builtin_constant_p是编译器扩展，适合旧版本项目。

内容的提问来源于stack exchange，提问作者glades