MSVC constexpr报错：非常量子表达式问题（Clang可正常运行）

问题描述 #

开发自定义数组类型时遇到跨编译器差异：单元测试在Clang下正常通过，但MSVC触发以下错误：

error C7595: 'UnitTest': call to immediate function is not a constant expression  
note: a non-constant (sub-)expression was encountered  
note: the call stack of the evaluation (the oldest call first) is  
note: while evaluating function 'void UnitTest(void)'  

相关代码：

#include <exception>
#include <memory>

template <typename ElementType, size_t ElementCount>
class StaticArray
{
public:
    template <typename OA>
    constexpr StaticArray(OA&& otherArray)
        : m_cxBuffer(std::allocator<ElementType>().allocate(static_cast<size_t>(ElementCount)))
    {
        using OtherArrayType = decltype(otherArray);
        using OtherArrayTypeNoRef = std::remove_reference_t<OtherArrayType>;

        m_count = std::extent_v<OtherArrayTypeNoRef>;

        ElementType* src = otherArray;
        ElementType* srcEnd = src + m_count;
        ElementType* dst = m_cxBuffer;

        ElementType* srcCurrent = src;
        ElementType* dstCurrent = dst;
        while (srcCurrent != srcEnd)
        {
            std::construct_at(dstCurrent, std::move(*srcCurrent));
            ++srcCurrent;
            ++dstCurrent;
        }
    }

    constexpr ~StaticArray() noexcept
    {
        while (m_count > 0)
            std::destroy_at(m_cxBuffer + (--m_count));

        std::allocator<ElementType>().deallocate(m_cxBuffer, static_cast<size_t>(ElementCount));
    }

    size_t m_count = 0;
    ElementType* m_cxBuffer = nullptr;
};

consteval void UnitTest()
{
    size_t cppArray[] = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
    StaticArray<size_t, 15> sArr = std::move(cppArray);  // 触发问题的行
}
static_assert((UnitTest(), true), "failed!");

移除std::move可在简化示例中解决问题，但完整代码需要区分移动/拷贝逻辑，因此该方案不可行。需明确这是MSVC的Bug还是Clang的错误兼容。

问题分析与结论 #

核心原因 #

问题出在数组右值引用转指针的常量表达式合法性判定：

1. std::move(cppArray)返回size_t (&&)[10]类型的右值引用，构造函数中OA推导为该类型，std::remove_reference_t<OA>为size_t[10]，这部分逻辑合法。
2. MSVC认为ElementType* src = otherArray;这一步中，从数组右值引用转换得到的指针不是合法的常量表达式值——它判定局部数组的地址在编译期无法确定为固定常量。
3. Clang的处理更符合C++标准：consteval函数的求值发生在编译期，局部变量cppArray的生命周期覆盖整个求值过程，其地址在该上下文内是有效的常量表达式值。

谁的行为正确？ #

Clang的行为符合C++标准，MSVC的报错属于实现层面的严格限制，是兼容性Bug。

兼容解决方案 #

要保留移动/拷贝区分逻辑同时兼容MSVC，可通过以下方式修改：

方案1：为数组左/右值单独重载构造函数 #

template <typename ElementType, size_t ElementCount>
class StaticArray
{
public:
    // 数组右值重载（移动逻辑）
    template <size_t OtherCount>
    constexpr StaticArray(ElementType (&&otherArray)[OtherCount])
        : m_cxBuffer(std::allocator<ElementType>().allocate(ElementCount))
        , m_count(OtherCount)
    {
        ElementType* dst = m_cxBuffer;
        for (size_t i = 0; i < m_count; ++i)
        {
            std::construct_at(dst + i, std::move(otherArray[i]));
        }
    }

    // 数组左值重载（拷贝逻辑）
    template <size_t OtherCount>
    constexpr StaticArray(const ElementType (&otherArray)[OtherCount])
        : m_cxBuffer(std::allocator<ElementType>().allocate(ElementCount))
        , m_count(OtherCount)
    {
        ElementType* dst = m_cxBuffer;
        for (size_t i = 0; i < m_count; ++i)
        {
            std::construct_at(dst + i, otherArray[i]);
        }
    }

    // 其他成员保持不变
    constexpr ~StaticArray() noexcept
    {
        while (m_count > 0)
            std::destroy_at(m_cxBuffer + (--m_count));

        std::allocator<ElementType>().deallocate(m_cxBuffer, static_cast<size_t>(ElementCount));
    }

    size_t m_count = 0;
    ElementType* m_cxBuffer = nullptr;
};

方案2：使用范围遍历替代指针转换 #

在原构造函数中，替换指针遍历为范围循环：

// 替换原while循环
for (auto& elem : otherArray)
{
    std::construct_at(dstCurrent, std::move(elem));
    ++dstCurrent;
}

这种方式无需显式转换指针，MSVC可正确识别常量表达式中的操作。

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