1

我希望这个问题不会过于复杂。我意识到元编程作用于类型而不是那些类型的对象。但是，我仍然试图通过 1）从类中检索类型信息，然后 2）对该类型信息的元函数来实现相同的结果。

对我的情况的解释如下，并附有简化的代码摘录：

我有一个矩阵模板类，我称之为 Matrix_Base。有点类似于 Eigen 采用的方法，我允许矩阵大小有两种可能性——在编译时固定或在运行时固定。Matrix_Base 的简化声明是：

template <typename Type, uint32_t rows_ = 1, uint32_t cols_ = 1,>
class Matrix_Base{
/* 
...
*/
};

运行时大小的矩阵由参数 0 表示。

检查矩阵的运行时与编译时大小是相当简单的（使用 boost::mpl）：

            typedef typename mpl::if_<
                typename mpl::or_<
                typename mpl::equal_to<
                typename mpl::int_<rows_>::type,
                mpl::int_<0>
                >::type,
                typename mpl::equal_to <
                typename mpl::int_<cols_>::type,
                mpl::int_<0>
                >
                >::type,
                mpl::true_,
                mpl::false_
                >::type runtime_size_type;

这已经过测试并且工作正常。我的麻烦从这里开始...

目前，我正在以下列方式使用上述 boost::mpl 代码：

namespace internal {
template <uint32_t rows = 1, uint32_t cols_ = 1>
struct Runtime_Size_Helper {
typedef typename mpl::if_< 
// REST OF THE BOOST::MPL code here //
>::type runtime_size_t
bool value() { return runtime_size_t::value;}
};
} // namespace
template <typename Type, uint32_t rows_ = 1, uint32_t cols_ = 1>
class Matrix_Base{
// ...
static constexpr uint32_t rows = rows_;
static constexpr uint32_t cols = cols_;
bool is_runtime_sized;
// ...
};

template <typename T, uint32_t R, uint32_t C>
bool Matrix_Base<T,R,C>::is_runtime_sized = internal::Runtime_Size_Helper<R,C>::value();

这使得 mpl 函数的结果成为 Matrix_Base 类的成员。到目前为止，一切都很好。

我想使用某种形式的间接来确定 runtime_size_type 的值，方法是将其传递给实例化对象。根据示例代码，确定这一点所需的唯一信息是 col 和 row 的 uint32_t 参数。

对于实例化的 Matrix_Base 对象，相关信息永远不会改变其编译类型值。矩阵的大小将是不可变的；大小将通过模板参数设置，或者——对于运行时大小的矩阵——通过构造函数设置。在这两种情况下，模板参数都是固定的，并且是类型信息的一部分。我将此信息保存为类中的静态变量，我什至尝试添加一个 typedef，其中所有模板参数为 my_typetypename typename Matrix_Base<T,rows_, cols_, ...> my_type但我似乎无法弄清楚如何编写一个可以传递 Matrix_Base 对象的元函数（显然作为参考或指针）并重新提取相关信息。

如果它们能提供必要的功能，我完全愿意合并（其他）boost 库。

希望这很清楚。请让我知道这里是否有不清楚的地方或者这只是愚蠢的。

最好的问候， 什穆尔

编辑文本以更清楚地说明问题

4

1 回答 1

1

做你想要的最快的方法（你没有真正详细指定它）是让你的矩阵类模板继承自存储类模板，并根据你的 MPL 谓词返回 true 或错误的

#include <array>
#include <iostream>
#include <vector>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/comparison.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/logical.hpp>

using namespace boost;

// in C++98, use 
// template<int R, int C>
// struct is_runtime_sized: mpl::if<
// ...
// >::type {};
template<int R, int C>
using is_runtime_sized = typename mpl::if_<
    mpl::or_<
        mpl::equal_to<mpl::int_<R>, mpl::int_<0>>,
        mpl::equal_to<mpl::int_<C>, mpl::int_<0>>
    >,
    mpl::true_, mpl::false_
>::type;

请注意，我已经消除了一些不必要typename的情况，以使 MPL 谓词更具可读性。

template<class T, int R, int C, bool = is_runtime_sized<R, C>::value>
struct MatrixStorage
{
    MatrixStorage() = default;
    MatrixStorage(int r, int c): data_(r * c) {} // zero-initializes
protected:    
    std::vector<T> data_;
};

template<class T, int R, int C>
struct MatrixStorage<T, R, C, false>
{
    MatrixStorage() = default;
    MatrixStorage(int, int): data_{} {} // zero-initializes
protected:    
    std::array<T, R * C> data_;    
};

在这里，我拆分了动态和静态存储矩阵的实现。前者使用 a std::vector，后者使用 a std:array。与 Eigen 类似，两者都有一个默认构造函数，并且都有一个构造函数，该构造函数采用零初始化的矩阵维度。

template<class T, int R = 0, int C = 0>
struct Matrix: public MatrixStorage<T, R, C>
{
    Matrix() = default;
    // In C++98, write:
    // Matrix(int r, int c): MatrixStorage<T, R, C>(r, c) {}
    using MatrixStorage<T, R, C>::MatrixStorage;
    int size() const { return this->data_.size(); }
};

实际的Matrix类继承自, 并根据当前存储的数据MatrixStorage返回 a 。size()

int main()
{
    Matrix<int> m_dyn(3, 3);
    std::cout << m_dyn.size() << "\n"; // 9

    Matrix<int, 2, 2> m_stat;
    std::cout << m_stat.size() << "\n"; // 4
}

活生生的例子。如您所见，动态分配的矩阵大小为 9，静态大小的矩阵大小为 4。请注意，上述代码中有两个小的 C++11 功能，如果需要，您可以轻松解决使用 C++11。

于 2013-10-14T12:17:13.837 回答