C++模板專業化冗餘減少

Question

我想編寫我自己的Vector類模板，並且還想添加一些專業化，例如可以通過x/y/z訪問組件的3D矢量類型。

到目前爲止，模板和專業化工作狀況良好，但問題是，專用模板需要從基本模板進行大量複製/粘貼才能正常工作。我想減少這一點。

這是它看起來像現在：

template<class T, unsigned int dim> 
class Vector; 

template<class T, unsigned int dim> 
Vector<T, dim> add(Vector<T, dim> const& lhs, Vector<T, dim> const& rhs) 
{ 
    Vector<T, dim> tmp; 
    for (unsigned int i = 0; i < dim; ++i) 
    { 
     tmp[i] = lhs[i] + rhs[i]; 
    } 

    return tmp; 
} 

template<class T, unsigned int dim, class S> 
Vector<T, dim> add(Vector<T, dim> const& lhs, S const& rhs) 
{ 
    Vector<T, dim> tmp; 
    for (unsigned int i = 0; i < dim; ++i) 
    { 
     tmp[i] = lhs[i] + rhs; 
    } 

    return tmp; 
} 

template<class T, unsigned int dim> 
Vector<T, dim> operator+(Vector<T, dim> const& lhs, Vector<T, dim> const& rhs) 
{ 
    return vectors::add(lhs, rhs); 
} 

template<class T, unsigned int dim, class S> 
Vector<T, dim> operator+(Vector<T, dim> const& lhs, S const& rhs) 
{ 
    return vectors::add(lhs, rhs); 
} 

template<class T, unsigned int dim> 
class Vector 
{ 
//... 
protected: 
    T values[dim] __attribute((aligned(16))); 
public: 
    template<class R, unsigned int fdim> 
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, Vector<R, fdim> const& rhs); 
    template<class R, unsigned int fdim, class S> 
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, S const& rhs); 
    template<class R, unsigned int fdim, class S> 
    friend Vector<R, fdim> operator+(S const& lhs, Vector<R, fdim> const& rhs); 
//... 
//constructors, etc. 
}; 

template<class T> 
class Vector<T, 3> 
{ 
//... 
protected: 
    T values[3] __attribute((aligned(16))); 
public: 
    T& x = values[0]; 
    T& y = values[1]; 
    T& z = values[2]; 

    //lots of copy-pasta :(
    template<class R, unsigned int fdim> 
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, Vector<R, fdim> const& rhs); 
    template<class R, unsigned int fdim, class S> 
    friend Vector<R, fdim> operator+(Vector<R, fdim> const& lhs, S const& rhs); 
    template<class R, unsigned int fdim, class S> 
    friend Vector<R, fdim> operator+(S const& lhs, Vector<R, fdim> const& rhs); 
//... 
//constructors, etc. 
}; 

現在我認爲最簡單的辦法是簡單地定義Vector3D作爲一個子類Vector模板的，就像這樣：

template<class T> 
class Vector3D: public Vector<T, 3> 
{ 
//... 
public: 
    T& x = values[0]; 
    T& y = values[1]; 
    T& z = values[2]; 

    //no copy-pasta :) 
//... 
//constructors, etc. 
}; 

這並不在所有的工作中，由於不確定性：

ambiguous overload for ‘operator+’ (operand types are ‘const vec3f {aka const math::vectors::Vector3D<float>}’ and ‘math::vectors::vec3f {aka math::vectors::Vector3D<float>}’) 
../main.cpp:84:16: note: candidates are: 
In file included from ../main.cpp:10:0: 
../include/vector.hpp:720:16: note: math::vectors::Vector<T, dim> math::vectors::operator+(const math::vectors::Vector<T, dim>&, const math::vectors::Vector<T, dim>&) [with T = float; unsigned int dim = 3u] 
Vector<T, dim> operator+(Vector<T, dim> const& lhs, Vector<T, dim> const& rhs) 
       ^
../include/vector.hpp:726:16: note: math::vectors::Vector<T, dim> math::vectors::operator+(const math::vectors::Vector<T, dim>&, const S&) [with T = float; unsigned int dim = 3u; S = math::vectors::Vector3D<float>] 
Vector<T, dim> operator+(Vector<T, dim> const& lhs, S const& rhs) 
       ^
../include/vector.hpp:732:16: note: math::vectors::Vector<T, dim> math::vectors::operator+(const S&, const math::vectors::Vector<T, dim>&) [with T = float; unsigned int dim = 3u; S = math::vectors::Vector3D<float>] 
Vector<T, dim> operator+(S const& lhs, Vector<T, dim> const& rhs) 

因此，看起來模板替換失敗了，因爲S也可以被新的Vector3D類替代，而它應該只處理標量。

於是，我就寫了標量小包裝類，像這樣擺脫這個問題的：

template<class T> 
class ScalarType 
{ 
public: 
    T value; 
    ScalarType() : 
      value(0) 
    { 

    } 

    ScalarType(T const& _v) : 
      value(_v) 
    { 

    } 

    ScalarType(ScalarType<T> const& rhs) : 
      value(rhs.value) 
    { 

    } 

    operator T&() 
    { 
     return value; 
    } 

    operator T() const 
    { 
     return value; 
    } 
}; 

而且隨着ScalarType<S> const& (l|r)hs取代的S const& (l|r)hs所有實例。

讓操作符在兩側再次運行Vector，但是應該處理Vector-Scalar操作的操作符仍然失敗。

這次是因爲標量值必須顯式爲ScalarType，因爲對其的隱式轉換不適用於模板替換。

那麼，有什麼辦法讓這個工作或我必須堅持複製粘貼代碼？

Answer 1

在這裏完成部分模板專業化和CRTP。

maybe_has_z<Container, N>是轉化成Container::z()一個Container::operator[](2)類，但只有當Container::size() >= 3

#include <array> 
#include <iostream> 
#include <algorithm> 

// 
// some boilerplate - note the different indecies 
// 

// define some concepts 

template<class Container, std::size_t N, typename= void> 
struct maybe_has_x{}; 

template<class Container, std::size_t N, typename = void> 
struct maybe_has_y{}; 

template<class Container, std::size_t N, typename = void> 
struct maybe_has_z{}; 

// specialise the concepts into (sometimes) concrete accessors 

template<class Container, std::size_t N> 
struct maybe_has_x<Container, N, std::enable_if_t<(N > 0)>> 
{ 
    auto& x() const { return static_cast<const Container&>(*this)[0]; } 
    auto& x() { return static_cast<Container&>(*this)[0]; } 
}; 

template<class Container, std::size_t N> 
struct maybe_has_y<Container, N, std::enable_if_t<(N > 1)>> 
{ 
    auto& y() const { return static_cast<const Container&>(*this)[1]; } 
    auto& y() { return static_cast<Container&>(*this)[1]; } 
}; 

template<class Container, std::size_t N> 
struct maybe_has_z<Container, N, std::enable_if_t<(N > 2)>> 
{ 
    auto& z() const { return static_cast<const Container&>(*this)[2]; } 
    auto& z() { return static_cast<Container&>(*this)[2]; } 
}; 

// define our vector type 

template<class T, std::size_t N> 
struct Vector 
: std::array<T, N> 
, maybe_has_x<Vector<T, N>, N> // include the maybe_ concepts 
, maybe_has_y<Vector<T, N>, N> 
, maybe_has_z<Vector<T, N>, N> 
{ 
private: 
    using inherited = std::array<T, N>; 
public: 
    Vector() : inherited {} {}; 
    Vector(std::initializer_list<T> il) 
    : inherited { } 
    { 
     std::copy_n(il.begin(), std::min(il.size(), this->size()), std::begin(*this)); 
    } 
    Vector(const inherited& rhs) : inherited(rhs) {} 

public: 
    using value_type = typename inherited::value_type; 

    // offer arithmetic unary functions in class (example +=) 
    // note that this allows us to add integers to a vector of doubles 
    template<class Other, std::enable_if_t<std::is_convertible<value_type, Other>::value> * = nullptr> 
    Vector& operator+=(const Vector<Other, N>&rhs) { 
     auto lfirst = std::begin(*this); 
     auto rfirst = std::begin(rhs); 
     auto lend = std::end(*this); 
     while (lfirst != lend) { 
      *lfirst += *rfirst; 
      ++lfirst; 
      ++rfirst; 
     } 
     return *this; 
    } 

}; 

// offer binary arithmetic as free functions 

template<class T, std::size_t N, class Other> 
Vector<T, N> operator+(Vector<T, N> lhs, const Vector<Other, N>& rhs) { 
    lhs += rhs; 
    return lhs; 
} 

// offer some streaming capability 

template<class T, std::size_t N> 
std::ostream& operator<<(std::ostream& os, const Vector<T, N>& rhs) { 
    auto sep = ""; 
    os << '['; 
    for (auto& x : rhs) { 
     os << sep << x; 
     sep = ", "; 
    } 
    return os << ']'; 
} 

// test 

int main() 
{ 
    auto a = Vector<double, 3> { 2.1, 1.2, 3.3 }; 
    auto b = a + a + Vector<int, 3> { 1, 1, 1 }; 
    std::cout << a << std::endl; 
    std::cout << b << std::endl; 

    std::cout << a.x() << ", " << a.y() << ", " << a.z() << std::endl; 

    auto c = Vector<double, 2> { 4.4, 5.5 }; 
    std::cout << c << std::endl; 

    std::cout << c.x() << std::endl; 
    std::cout << c.y() << std::endl; 
    // won't compile 
    // std::cout << c.z() << std::endl; 
} 

預期輸出：

[2.1, 1.2, 3.3] 
[5.2, 3.4, 7.6] 
2.1, 1.2, 3.3 
[4.4, 5.5] 
4.4 
5.5