6

我基本上尝试编写自己的游戏引擎供练习和个人使用（我知道，这几乎是一项不可能完成的任务，但正如我所说，它主要用于学习新事物）。

目前，我正在研究我的数学库（主要是向量和矩阵），我遇到了一个有趣但主要是美学问题。

给出以下伪代码：

template <uint8 size>
struct TVector {
    float elements[size];
};

现在我希望能够以所需的浮点数作为参数来构造结构：

TVector<3> vec0(1.0f, 2.5f, -4.0f); 
TVector<2> vec1(3.0f, -2.0f);

TVector<3> vec2(2.0f, 2.2f); // Error: arg missing 
TVector<2> vec3(1.0f, 2.0f, 3.0f) // Error: too many args

由于数组的大小是由模板参数给出的，所以我很难为结构声明一个合适的构造函数。我的最终目标是这样的：

// This is pseudo-ideal-code
TVector(size * (float value)); // Create a constructor with number of size 
                               // parameters, which are all floats

当然，这是非逻辑语法，但我以这种方式实现的最接近的事情是使用C++17 折叠表达式：

template<typename... Args>
    TVector(Args... values) {
        static_assert(sizeof...(values) <= size, "Too many args");
        uint8 i = 0;
        (... , void(elements[i++] = values));
    }

它在填充数组的意义上工作得非常好，而且（我猜）开销不大，但对于使用这个结构的程序员来说，它也容易出错，因为它没有直接指示构造函数接受了多少参数。

此外，它没有指定应该是哪种类型的参数，这是我最大的问题。

如果它有效，为什么会有问题？

想象一下使用 TVector 结构的以下结构：

template <const uint8 rows, const uint8 columns>
struct TMatrix {
    // elements[-columns-][-rows-]; 
    TVector<rows> elements[columns];
}

鉴于构造函数类似于向量结构的折叠表达式，我希望能够使用相应大小的向量或大括号初始化来构造矩阵。

  1. 聚合初始化不起作用。

    TVector<2> vec(1.0f, 3.0f);
TMatrix<2, 2> mat0(vec, vec); // Works
TMatrix<2, 2> mat1(vec, {0.2f, -4.2f}); // Error
// Does not compile, because the Type is not clear

  2. 当给定错误的参数（例如大小错误的向量，不适合作为矩阵的列）时，它在编译之前不会显示错误。

  3. 错误的来源并不总是很清楚。

TL; DR：现在终于到了我真正的问题：

有没有办法限制折叠表达式的类型，最终根本不使用模板并解决我上面给出的 3 个问题？

我想像：

TVector(float... values) { 
// Maybe even specify the size of the pack with the size given in the struct template
    uint8 i = 0;
    (... , void(elements[i++] = values));
}

和：

TMatrix(const TVector<rows>&... values) {
    uint8 i = 0;
    (..., void(elements[i++] = values));
}

当然，我在这里很挑剔，这主要是一个审美问题，但我认为这是一个重要的设计决策，它可以真正提高代码的可用性。

感谢您阅读本文并帮助我解决我的第一个问题 :)

4

2 回答 2

4

因此，在深入研究模板元编程并尝试之后，我遇到了一些解决方案（都有自己的小问题）。

std::initializer_list:

优点：

  • 易于实施：

    // Constructors:
TVector(std::initalizer_list<float> values);
TMatrix(std::initalizer_list<TVector<rows>> values);

  • 大括号初始化：

    TVector<3>    vec { 1.0f, 0.0f, 2.0f };
TMatrix<3, 3> mat { vec, { 3.0f, 4.0f, 1.0f }, vec };

缺点：

标准::数组

优点：

  • 易于实施：

    // Constructors:
TVector(std::array<float, size>&& values);
TMatrix(std::aray<TVector<rows>, columns>&& values);

  • 如果数组中的对象是可移动的，则可移动

缺点：

  • 大括号初始化非常难看

    TVector<3>    vec { { 1.0f, 0.0f, 2.0f } };
TMatrix<3, 3> mat { vec, TVector<3>{ { 3.0f, 4.0f, 1.0f } }, vec };

折叠表达式 - 我的首选解决方案

优点：

  • 无开销
  • 活动

  • 使用统一初始化

    TVector<3>    vec { 1.0f, 0.0f, 2.0f };
TMatrix<3, 3> mat { vec, TVector<3>{ 3.0f, 4.0f, 1.0f }, vec };
  • 可以根据构造函数的需要指定

缺点：

  • 难以实施和指定

  • 在不指定类型的情况下不允许嵌套大括号（据我所知）

    // Constructors:
template<typename... Args, std::enable_if_t<
    is_pack_convertible<float, Args...>::value && 
    is_pack_size_of<columns, Args...>::value, bool> = false >
TVector(std::array<float, size>&& values);

template<typename... Args, std::enable_if_t<
    is_pack_convertible<Vector<rows>, Args...>::value && 
    is_pack_size_of<columns, Args...>::value, bool> = false >
TMatrix(std::aray<TVector<rows>, columns>&& values);

is_pack_convertible / is_pack_size_of

// Declaration - checks if all types of a pack are convertible to one type
template <typename To, typename... Pack> struct is_pack_convertible;
// End of pack case
template <typename To> struct is_pack_convertible<To> : std::true_type {};
// Recursive bool &&
template <typename To, typename From, typename... Pack>
struct is_pack_convertible<To, From, Pack...> {
    static constexpr bool value = std::is_convertible<From, To>::value
        && is_pack_convertible<To, Pack...>::value;
};

// Declaration - checks if the pack is equal to a certain size
template <size_t size, typename... Pack> struct is_pack_size_of;
// End of pack: size is equal
template <> struct is_pack_size_of<0> : std::true_type {};
// End of pack: size is not equal
template <size_t remainder> struct is_pack_size_of<remainder> : std::false_type {};
// Count down size for every element in pack
template <size_t size, typename Arg, typename... Pack> 
struct is_pack_size_of<size, Arg, Pack...> {
    static constexpr bool value = is_pack_size_of<size - 1, Pack...>::value;
};

我希望这对其他人有所帮助，并简要概述了初始化泛型类时的选项。

于 2018-01-23T16:13:30.183 回答
3

使用间接，您可以执行以下操作：

template <typename Seq> struct TVectorImpl;

template <std::size_t, typename T> using force_type = T;

template <std::size_t ... Is>
struct TVectorImpl<std::index_sequence<Is...>>
{
    TVectorImpl(force_type<Is, float>... args) : elements{args...} {}

    float elements[sizeof...(Is)];
};

template <std::size_t size>
using TVector = TVectorImpl<decltype(std::make_index_sequence<size>())>;

这避免了也有模板方法（所以构造为{2.4, 5}工作）。

演示

请注意，它在 C++14 中（并且index_sequence可以在 C++11 中完成）。

于 2018-01-16T18:18:37.863 回答