Question

我正在尝试用这种方式制作一个简单的Vector类（数学）：

template <int D, typename T = float>
class Vector
{
  T m[D];
  // ...
};

其中D是维度数。如果为2，则向量将存储两个类型为T的值。

如何声明构造函数以获取D类型的T参数？

Vector<2> v(1.0f, -6.3f);

如果D特定号码，如何添加功能？我想添加GetX()如果D是＆gt; = 1，GetY()如果D>＆gt; = 2则GetZ()如果D是Vector<2> v(1.0f, -6.3f); cout << v.GetZ() << endl; ＆gt; = 3，但以下代码应生成编译时错误：

{{1}}

如果D是＆lt;如何生成编译时错误1？

我没有遵循任何具体的标准，任何事都对我有用。

Answer 1

所以我提供了一些人们喜欢的愚蠢答案。但这比那容易得多：）

template <int D, typename T = float>
class v {
public:
    template <typename... Args>
    v(Args... args) : a{ T(args)... } {
        static_assert(sizeof...(Args) == D, "wrong number of arguments");
    }

private:
    T a[D];
};

您可以使用可变参数模板和SFINAE来获取具有正确数量参数的构造函数。

构造函数没有返回值，因此我们需要在其中一个参数上使用SFINAE。要使用可变参数模板，我们需要在最后设置参数包。

这意味着我们需要在第一个参数上使用SFINAE。

然后，这意味着在第一个参数需要比维度少一个参数之后的参数包。

有了这个，我们可以写：

template <int D, typename T>
class v {
public:
    template <typename... Tail>
    v(typename std::enable_if<sizeof...(Tail)+1 == D, T>::type head, Tail... tail)
    : a{ head, T(tail)... } {}

private:
    T a[D];
};

现在：

v<4, int> a(1,2,3,4); // ok!
v<4, int> b(1,2,3);   // error! no such constructor

Answer 2

我无法访问C ++ 11编译器，但是这样的东西可能有用吗？

#include <array>
#include <type_traits>

template <int D, typename T>
class Vector
{
    static_assert(D > 0, "Dimension must be greater than 0");
    std::array<T,D> m;
public:
    template<typename... Args>
    Vector(Args&&... args) : m{T(args)...}
    {
         static_assert(sizeof...(Args) == D, "Invalid number of constructor arguments.");
    }

    T GetX() const { return m[0]; }
    T GetY() const { return m[1]; }
    T GetZ() const { return m[2]; }
};

template <typename T>
class Vector<1, T>
{
    std::array<T,1> m;
public:
    Vector(const T& t0) : m{t0}
    {
    }

    T GetX() const { return m[0]; }
};

template <typename T>
class Vector<2, T>
{
    std::array<T,2> m;
public:
    Vector(const T& t0, const T& t1) : m{t0, t1}
    {
    }

    T GetX() const { return m[0]; }
    T GetY() const { return m[1]; }
};

Answer 3

这有点偏离主题，但也许它是最少量的工作：使用tuple。然后你可以免费获得所有的访问者功能。

唯一要做的就是建立一个元组工厂：

template <typename T, unsigned int D> struct tuple_maker
{
  typedef typename tcat<T, tuple_maker<T, D - 1>::type>::type type;
}
template <typename T> struct tuple_maker<T, 1>
{
  typedef std::tuple<T> type;
}

我们需要辅助tcat：

template <typename T, typename Tuple> struct tcat;
template <typename T, typename ...Args> struct tcat<T, std::tuple<Args...>>
{
  typedef typename std::tuple<T, Args...> type;
}

用法：

tuple_maker<float, 3>::type myVec3D;

使用模板别名，我们可以做得更好：

template <typename T, unsigned int D>
using MyVector = typename tuple_maker<T, D>::type;

MyVector<double, 4> myVec4D;

Answer 4

这应该做的工作：

template<int N, typename T>
class Array
{
private:
    T Data[N];

public:
    template<int i>
    void Init() { }
    template<int i, typename... Args>
    void Init(T Arg0, Args... Rest)
    {
        Data[i] = Arg0;
        Init<i + 1>(Rest...);
    }
    template<typename... Args>
    Array(T Arg0, Args... Rest)
    {
        static_assert(sizeof...(Args) + 1 == 5, "Wrong number of arguments");
        Data[0] = Arg0;
        Init<1>(Rest...);
    }
};

int main (int argc, const char * argv[])
{
    Array<5, int> arr(1, 2, 3, 4, 5);
    return 0;
}

Answer 5

如何声明构造函数以获取类型为T的D参数？

你做不到。您可以专门针对每个受支持的维度，并为每个维度提供适当的构造函数。或者，您可以定义一个构造函数，该构造函数接受多个默认值参数并忽略那些未使用的参数。或者，如果参数的数量大于static_assert，您可以定义多个构造函数，从1到某个上限，D。

如果D是特定数字，如何添加功能？

这是通过专业化完成的。您必须将所有常用功能移动到某个VectorBase模板并从中继承，并对维度进行部分专业化以添加这些功能。

如果D是＆lt;如何生成编译时错误1？

或者您可以为基本模板定义所有这些函数，如果static_assert不足以使用该函数，则D。现在你刚刚失去了显式的实例化。您还可以为这些函数添加虚拟模板参数，这样您就可以使用enable_if和 SFINAE 来放弃函数。

templates：如何使用模板变量控制构造函数args的数量。

5 个答案: