在运行时捕获的constexpr变量中捕获的内部数组会丢失

Question

我正在尝试创建一个 [int/enum] 到文本的映射类，为其用户提供尽可能少的开销。应向其构造函数传递一个值到文本映射的列表，随后可以对其进行查询。创建的对象应该是 constexpr 并具有可选的大小参数，这允许编译器在编译时有选择地检查传递的映射数量是否与预期相符。当与枚举一起使用时，这作为额外的安全措施特别有用 - 也就是说：如果您忽略为新添加的枚举值添加映射，则可以强制编译错误。它应该在 Visual Studio 2019 和 Xcode 9 和 12 下与 C++14 一起使用。

我当前的尝试是下面的代码。但是，至少在 Visual Studio 2019 下，传递的映射数组未在 m_mappings 成员变量中正确捕获。当您运行此代码时，m_mappings 指向随机内存地址，因此您获得的任何输出都是错误的（如果它没有彻底崩溃）。

#include <iostream>


template <typename Type>
struct Mapping {
    Type value;
    const char* text;
};


template <typename Type, Type maxValue = Type(-1)>
class Mapper {
public:
    template <size_t numMappings>
    explicit constexpr Mapper(const Mapping<Type>(&mappings)[numMappings]) :
        m_mappings(mappings),
        m_numMappings(numMappings) {
        static_assert(
            int(maxValue) == -1 || numMappings == int(maxValue) + 1,
            "Some mappings are missing!"
        );
    }

    const char* Map(Type value) const {
        for (size_t mappingNr = 0; mappingNr < m_numMappings; ++mappingNr)
            if (m_mappings[mappingNr].value == value)
                return m_mappings[mappingNr].text;

        return "?";
    }

private:
    const Mapping<Type>* m_mappings;
    const size_t m_numMappings;
};


enum class TestEnum {
    a,
    b,
    c,

    maxValue = c
};


int main() {
    constexpr Mapper<int> intMapper_noCheck({
        { 11, "a" },
        { 5, "b" },
        { 26, "x" }
    });
    std::cout << intMapper_noCheck.Map(10);

    constexpr Mapper<int, 3> intMapper_check({
        { 0, "z" },
        { 1, "f" },
        { 2, "t" },
        { 3, "#" }
    });
    std::cout << intMapper_check.Map(2);

    // if we'd pass e.g. TestEnum::b here, we get a nice compile time error
    constexpr Mapper<TestEnum, TestEnum::maxValue> enumMapper({
        { TestEnum::a, "-" },
        { TestEnum::b, "-" },
        { TestEnum::c, "+" }
    });
    std::cout << enumMapper.Map(TestEnum::b);

    // expected output by now: "?t-"

    std::cin.get();
    return 0;
}

一种可能的解决方案是在单独的 constexpr 变量中捕获映射数组，并将其传递给映射器对象，如下所示：

    constexpr Mapping<TestEnum> enumMapping[] = {
        { TestEnum::a, "-" },
        { TestEnum::b, "-" },
        { TestEnum::c, "+" }
    };
    constexpr Mapper<TestEnum, TestEnum::maxValue> enumMapper(enumMapping);
    std::cout << enumMapper.Map(TestEnum::b);

这样映射就会得到保留并且输出是正确的。然而，我发现这个额外的层使它变得更加“混乱”......

这里的复杂因素是传入的数组的大小必须以 constexpr 友好的方式捕获，并且我不想通过单独指定它手。

• 使用构造函数模板参数中指定大小的固定大小数组是实现此目的的一种方法，但是当内联传递数组时，它在运行时无法访问。
• 另一个版本是传递（并存储）一个 std::initializer_list，但您不能在它的 size 方法上使用 static_assert 。作为一种解决方法，我们还可以像 m_mappings(sizeMatches?mappings: throw "mismatch!") 一样初始化 m_mappings，但这样非 constexpr 对象可能会在运行时执行令人讨厌的抛出（不幸的是，代码库的其余部分并不完全是异常安全的）。
• 我考虑使用 std::array 代替（其中的 size 是 constexpr 可以访问的），但是没有办法将使用的大小传递给 m_mappings （大小只有构造函数模板知道，类模板不知道）。
• 我还考虑为构造函数使用模板参数包，以便用户可以两两传递松散的值和文本参数。但是我该如何将它们填充到 m_mappings 中呢？例如，我必须将 m_mappings 设为 std::vector 才能执行此操作，但这与 constexpr 不兼容。

像我的第一个版本一样，在保持美观和干净的同时，还有什么选择呢？

Answer 1

失败的原因是，您将一个指针存储到将数组传递给构造函数以供以后使用的指针。

但是在您的紧凑型情况下，该数组在构造函数运行后不再存在。因此，您需要进行一些分配（在所有编译器中可能不友好）并复制。您使用char*而不是std :: string进一步添加到此问题的事实 - 也不能保证当指向字符串时仍存在您使用它。

另外，除非这是针对某种课程的工作“ rel =“ nofollow noreferrer”> https://github.com/serge-sans-paille/frozen

Answer 2

经过一番篡改之后，我提出了一个解决方案，在该解决方案中，我只是将经过的映射复制到一个普通的旧数组成员中。我还尝试使用std ::数组，但是在C ++ 14中它不够友好。

我先前尝试过的是自动捕获模板构造函数中的映射列表大小（nummappings是由编译器推导的），然后将其匹配到类模板中指定的预期映射数（MaxValue ）。但是现在，类模板本身需要知道我们将要通过的映射数量，以便可以为该副本保留存储。因此，我还将maxValue参数重新定义以代表这一点。

因此，一个缺点是您现在始终需要手动计算要通过多少次映射，这在绘制大型不连续的INT范围内是您真正不关心该细节的痛苦。对于枚举而言，什么都没有改变，我主要写这堂课来处理枚举。

因此，这不是一个100％完美的问题，但是我想……好吧。

#include <iostream>


template <typename Type>
struct Mapping {
    Type value;
    const char* text;
};


template <typename Type, Type maxValue>
class Mapper {
public:
    template <size_t numMappings>
    explicit constexpr Mapper(const Mapping<Type>(&mappings)[numMappings]) :
        m_mappings{} {
        constexpr int correctNumMappings{ int(maxValue) + 1 };

        static_assert(numMappings <= correctNumMappings, "Too many mappings given!");
        static_assert(numMappings >= correctNumMappings, "Some mappings are missing!");

        for (size_t mappingNr = 0; mappingNr < numMappings; ++mappingNr)
            m_mappings[mappingNr] = mappings[mappingNr];
    }

    const char* Map(Type value) const {
        for (const Mapping<Type>& mapping : m_mappings)
            if (mapping.value == value)
                return mapping.text;

        return "?";
    }

private:
    Mapping<Type> m_mappings[int(maxValue) + 1];
};


enum class TestEnum {
    a,
    b,
    c,

    maxValue = c
};


int main() {
    constexpr Mapper<int, 3> intMapper_check({
        { 0, "z" },
        { 1, "f" },
        { 2, "t" },
        { 3, "#" }
    });
    std::cout << intMapper_check.Map(2) << "\n";

    constexpr Mapper<TestEnum, TestEnum::maxValue> enumMapper({
        { TestEnum::a, "-" },
        { TestEnum::b, "-" },
        { TestEnum::c, "+" }
    });
    std::cout << enumMapper.Map(TestEnum::b) << "\n";

    std::cin.get();
    return 0;
}