c++ - 一个类型是否可能根据它是否在 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);
}

在这个例子中，无论是从 constexpr 上下文调用，foo 的行为都不同，因为特化依赖于 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

这是在黑暗中开枪，因为所讨论的实际类(class)可能不允许这样做。但是 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

不知道如何称呼这个成语。这有点像类型删除，但类型并没有真正被删除......构造函数根据执行它的上下文选择(一次)使用哪个实现，其他所有内容都通过接口(interface)委托(delegate)给该实现。

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