0

我的问题肯定很愚蠢，但我对 C++11 和模板编程的理解有很多漏洞，我不知道如何解决这个问题。

我正在滚动我自己的非常简单的线性代数库：

typedef short index_t;

template<int M, int N, typename T = double>
class mat {
    // may want some specialized constructors for mat<1,N,T> and mat<M,1,T>
public:
    T& operator()(index_t i, index_t j) {
        return buf[i + j*M];
    }
    T& operator[](index_t k) { // useful for special cases where matrix is vector
        return buf[k];
    }

    // etc...

private:
    std::array<T, M*N> buf;
}

typedef mat<2, 1, double> col2d;
typedef mat<3, 1, double> col3d;
typedef mat<1, 2, double> row2d;
typedef mat<1, 3, double> row3d;
typedef mat<2, 2, double> mat2d;
typedef mat<3, 3, double> mat3d;

我只是希望它支持一种直接分配（或至少初始化）向量（即具有单维数的矩阵）的方法。例如，我希望能够做到v = col2d(v1,v2)或至少能够做到col2d v = {v1,v2}。我的印象是buf公开可能允许col2d v = {{v1, v2}}，但我不喜欢公开的想法buf。我并不热衷于为每个 (1,N) 和每个 (M,1) 编写一个专门的构造函数。我试图使图书馆尽可能简单易读。

有什么建议吗？

4

2 回答 2

1

这就是我最终做的事情：

template<int M, int N, typename T = double>
class mat {
public:
    // constructor
    template <typename... Args>
    mat(Args... args) : buf({ args... }) {
        static_assert(sizeof...(Args) == M*N || sizeof...(Args)==0, "Wrong number of arguments in constructor.");
    }
    // etc...
}

// the following aliases replace all those typedefs in the question
template<index_t N, typename T=double>
using row = mat<1, N, T>;
template<index_t M, typename T=double>
using col = mat<M, 1, T>;

template <typename T=double, typename... Args>
col<sizeof...(Args), T> c(Args... args) {
    return col<sizeof...(Args), T>({ args... });
}
template <typename T=double, typename... Args>
row<sizeof...(Args), T> r(Args... args) {
    return row<sizeof...(Args), T>({ args... });
}

这允许像

c(1.0, 2.0, 3.0); // returns a col<3>, which is a mat<3,1>
r(1.0, 2.0);      // returns a row<2>, which is a mat<1,2>
r<float>(1.0f, 2.0f); // returns a row<2, float>

如果上面最后一行中的模板函数有一种简单的方法可以从函数的参数类型推断类型参数，我很想知道它。

编辑：（新版本包含@Yakk 的建议。）

typedef short index_t;

template<int M, int N, typename T = double>
class mat {
public:
    mat() {
    }
    template <typename... Args, std::enable_if_t<(sizeof...(Args)==M*N), int> = 0> // static assertion doesn't work for external detection of validity, which is needed I think to avoid signature conflict with default, copy, move constructors etc.
    mat(Args&&... args) : buf({ std::forward<Args>(args)... }) {
        //static_assert(sizeof...(Args) == M*N || sizeof...(Args) == 0, "Wrong number of arguments in constructor.");
    }
public:
    T& operator()(index_t i, index_t j) {
        return buf[i + j*M];
    }
    T& operator[](index_t k) {
        return buf[k];
    }

    // etc... various matrix operations

private:
    std::array<T, M*N> buf;
};

// etc... various matrix operators

// aliases for row and col
template<index_t N, typename T=double>
using row = mat<1, N, T>;
template<index_t M, typename T=double>
using col = mat<M, 1, T>;

// short-hand "literals"
template <typename... Args>
col<sizeof...(Args), typename std::common_type<Args...>::type> c(Args&&... args) {
    return col<sizeof...(Args), typename std::common_type<Args...>::type>({ std::forward<Args>(args)... });
}
template <typename... Args>
row<sizeof...(Args), typename std::common_type<Args...>::type> r(Args&&... args) {
    return row<sizeof...(Args), typename std::common_type<Args...>::type>({ std::forward<Args>(args)... });
}
于 2016-10-14T11:50:27.357 回答
1 
mat(std::array<T, M*N>&& buffin):buf(std::move(buffin)){}
mat(std::array<T, M*N> const& buffin):buf(buffin){}

这不会暴露buf，但会为您提供col3d x = {{{ 1,2,3 }}};语法。

它还允许使用平面缓冲区初始化 mat 3d。我自己觉得这很有用。

我可能会想补充

struct flat_t{constexpr flat_t(){};};
constexpr flat_t flat{};

然后将arrayctors 添加mat到flat_t. 这可以防止意外的隐式转换，同时仍然允许return {flat, {{1,2,3}}};样式返回。

另一种选择是

template<class...Ts,
  std::enavle_if_t< (sizeof...(Ts)==N*M), int> =0
>
mat(flat_t, Ts&&...ts):
  buf{{std::forward<Ts>(ts)....}}
{}

这给了你

col2d{flat, 1,2};

作为有效的col2d.

添加所有Ts可以转换为的 sfinae 测试T是此路径的下一步。

于 2016-10-14T03:16:29.127 回答