一个类型是否可以根据它是否在 constexpr 上下文中定义而具有不同的定义？

Question

我希望有一个在 constexpr 上下文中使用时行为不同的类型。

看这个例子：

#include <cstdio>
#include <type_traits>

template <bool IS_CONSTANT_EVAL>
struct Bar;

template <>
struct Bar<false> {
    constexpr int doIt() const {
        return 0;
    }
};

template <>
struct Bar<true> {
    constexpr int doIt() const {
        return 1;
    }
};

constexpr int foo() {
    if (std::is_constant_evaluated()) {
        Bar<true> v;
        return v.doIt();
    } else {
        Bar<false> v;
        return v.doIt();
    }
}

int main() {
    int rt = foo();
    constexpr int ce = foo();

    printf("Runtime: %d ConstEval: %d \n", rt, ce);
}

在此示例中，foo 无论是从 constexpr 上下文中调用，其行为都会有所不同，因为特化依赖于 constexpr-ness，因此它会打印：

Runtime: 0 ConstEval: 1

但如果我尝试将其简化为：

constexpr int foo() {
    Bar<std::is_constant_evaluated()> v;
    return v.doIt();
}

它不再起作用了，因为std::is_constant_evaluated() 总是返回true 作为模板参数。

甚至，我想要一个更简单的foo，像这样：

constexpr int foo() {
    Bar v;
    return v.doIt();
}

所以Bar 本身应该以某种方式处理 constexpr-ness，我不想在每次使用 Bar 时重复 std::is_constant_evaluated()。

可以这样做吗？

注意：我实际上不想有不同的行为，只是不同的实现。由于 constexpr 的限制，我需要根据 constexpr-ness 对 Bar 进行不同的实现。例如，memcpy 和 reinterpret_cast 使表达式不是常量。因此，如果Bar 用于常量表达式，我需要使用一些与 constexpr 兼容的技术来替换memcpy 或reinterpret_cast。

注意 2：我确实需要不同的 Bar 定义，不仅仅是 doIt 需要不同。如果在常量表达式中使用memcpy 和reinterpret_cast，则替换Bar 需要额外的成员。

Answer 1

这是在黑暗中拍摄的，因为所讨论的实际课程可能不允许这样做。但是 C++20 将常量表达式放宽了一个很大的因素。具体来说，现在允许虚函数调用，您可以执行以下操作：

class Bar {
    struct impl {
        constexpr virtual int  doIt () const = 0;
    };
    
    struct : impl {
        constexpr int  doIt() const override { return 1; }
    } _c;
    
    struct : impl {
        constexpr int  doIt() const override { return 0; }
    } _r;

    impl* pimpl;

public:
    constexpr Bar() {
        if(std::is_constant_evaluated()) {
            pimpl = &_c;
        }
        else {
            pimpl = &_r;
        }
    }
    
    constexpr int doIt() const {
        return pimpl->doIt();
    }
};

constexpr int foo() {
    Bar bar;
    return bar.doIt();
}

Live

不知道如何称呼这个成语。这有点像类型擦除，但类型并没有真正擦除......构造函数根据执行它的上下文选择要使用（一次）的实现，其他一切都通过接口委托给该实现。

当然，需要注意的是_r 的成员不能在常量表达式中使用是可以的，但构造函数必须是（出于显而易见的原因），所以这就是我说它可能不适用的原因。