C++ 结构模板特化

我正在尝试开发自己的 3D 渲染器，为此我需要一个 3D 矢量结构。我试图使其尽可能通用，因此我使用模板化结构。

我创建了一个Vec<size_t, typename>为了简单起见，我将 Vec 专门化为具有 x 和 y 属性。像这样：

template <size_t DIM, typename T>
struct Vec
{
    T data[DIM];

    Vec() : data() {}

    Vec(std::vector<T> _data)
    {
        assert(_data.size() == DIM);
        for (int i = DIM; i--; data[i] = _data[i])
            ;
    }

    template <typename U>
    Vec(Vec<DIM, U> v)
    {
        for (int i = 0; i < DIM; i++)
            data[i] = (T)v[i];
    }

    T &operator[](size_t idx)
    {
        return data[idx];
    }
};

template <size_t LEN, size_t DIM, typename T>
Vec<LEN, T> embed(Vec<DIM, T> &v, T fill = 1)
{
    Vec<LEN, T> ret;
    for (size_t i = LEN; i--; ret[i] = (i < DIM ? v[i] : fill))
        ;
    return ret;
}

template <size_t LEN, size_t DIM, typename T>
Vec<LEN, T> proj(Vec<DIM, T> &v)
{
    Vec<LEN, T> ret;
    for (size_t i = LEN; i--; ret[i] = v[i])
        ;
    return ret;
}


template <typename T>
struct Vec<2, T>
{
    union
    {
        T data[2];
        struct
        {
            T x, y;
        };
    };
};

typedef Vec<2, int> Vec2i;
typedef Vec<2, float> Vec2f;
typedef Vec<2, double> Vec2d;

但是当我这样做时，我收到此错误：

...
/src/main.cpp:61:62: error: no matching function for call to ‘Vec<2, int>::Vec(Vec<2, double>)’
   61 |                 verts[i] = (Vec<2, int>)proj<2>(face.verts[i]);
      |                                                              ^
...
/include/geometry.h:52:8: note: candidate: ‘Vec<2, int>::Vec()’
   52 | struct Vec<2, T>
      |        ^~~~~~~~~
/include/geometry.h:52:8: note:   candidate expects 0 arguments, 1 provided
/include/geometry.h:52:8: note: candidate: ‘constexpr Vec<2, int>::Vec(const Vec<2, int>&)’
/include/geometry.h:52:8: note:   no known conversion for argument 1 from ‘Vec<2, double>’ to ‘const Vec<2, int>&’
/include/geometry.h:52:8: note: candidate: ‘constexpr Vec<2, int>::Vec(Vec<2, int>&&)’
/include/geometry.h:52:8: note:   no known conversion for argument 1 from ‘Vec<2, double>’ to ‘Vec<2, int>&&’
/include/geometry.h: In instantiation of ‘Vec<LEN, T> proj(Vec<DIM, T>&) [with long unsigned int LEN = 2; long unsigned int DIM = 3; T = double]’:
/src/main.cpp:61:62:   required from here
/include/geometry.h:46:34: error: no match for ‘operator[]’ (operand types are ‘Vec<2, double>’ and ‘size_t’ {aka ‘long unsigned int’})
   46 |     for (size_t i = LEN; i--; ret[i] = v[i])
      |                               ~~~^
...

Vec 没有继承函数？为什么我会收到这些错误？

班级专业化是一张白纸；您必须提供整个实现，这可能会造成大量重复。这似乎不太适合您提出的用例：根据维度添加便利访问器。

我建议使用一个模板类，其中包含根据维度有条件启用的访问器。这会给阅读类带来一些混乱，但不会出现代码重复。

另外，由于尺寸是模板参数，因此您可以使用std::array对于数据成员。

下面的代码演示了这些想法。它使用一些高级语言功能，因此您可能必须根据您使用的语言版本来调整实现细节。

示例代码

#include <array>
#include <iostream>
#include <vector>

using std::cin, std::cout, std::endl;


template<size_t D, class T>
struct Vec {
    Vec() : data_() { }

    template<class... Us> requires (sizeof...(Us) == D and (std::is_convertible_v<Us, T> and ...))
    Vec(Us... args)
        : data_({args...}) {
    }

    Vec(const std::vector<T>& other) {
        assert(other.size() == D);
        std::copy(other.begin(), other.end(), data_.begin());
    }

    template<class U>
    Vec(const Vec<D, U>& other) {
        std::copy(other.begin(), other.end(), data_.begin());
    }

    auto& operator[](size_t idx) { return data_[idx];  }
    const auto& operator[](size_t idx) const { return data_[idx]; }

    T& x() { return data_[0]; }
    const T& x() const { return data_[0]; }

    T& y() requires (D > 1) { return data_[1]; }
    const T& y() const requires (D > 1) { return data_[1];  }

    T& z() requires (D > 2) { return data_[2]; }
    const T& z() const requires (D > 2) { return data_[2]; }

    T& w() requires (D > 3) { return data_[3]; }
    const T& w() const requires (D > 3) { return data_[3]; }

private:
    std::array<T, D> data_;
};


int main(int argc, const char *argv[]) {
    Vec<1, int> a(1);
    cout << a.x() << endl;

    Vec<2, int> b(1, 2);
    cout << b.x() << " " << b.y() << endl;

    Vec<3, int> c(1, 2, 3);
    cout << c.x() << " " << c.y() << " " << c.z() << endl;

    Vec<4, int> d(1, 2, 3, 4);
    cout << d.x() << " " << d.y() << " " << d.z() << " " << d.w() << endl;
}

Output

1
1 2
1 2 3
1 2 3 4