0

我想写一个 n 维直方图类。它应该采用包含其他 bin 等的 bin 形式，其中每个 bin 包含最小和最大范围，以及指向下一维 bin 的指针

一个 bin 定义为

template<typename T>
class Bin {
 float minRange, maxRange;
 vector<Bin<either Bin or ObjectType>> bins;
}

这个定义是递归的。所以在运行时，用户定义直方图的维度

so if its just 1-dimension, then
Bin<Obj>
while 3-dimensions
Bin<Bin<Bin<Obj>>>

这可能吗？

问候

4

2 回答 2

5

当然，C++11 有模板的可变长度参数列表。即使没有 C++11，如果所有维度都具有相同的类型，您也可以使用专业化：

template <typename T, unsigned nest>
struct Bin {
  std::vector<Bin<T, (nest-1)> > bins;
};

template <typename T>
struct Bin<T,0> {
  T content;
};

您只能在一定程度上在运行时指定维度。如果它受固定值约束，您甚至可以动态选择适当的类型。但是，请考虑使用一维向量而不是多维锯齿状向量！

于 2012-06-09T18:39:22.997 回答
1

要获得您建议的确切语法，请执行以下操作：

template <typename T>
class Bin
{
    float minRange, maxRange;
    std::vector<T> bins;
};

它应该完全符合您在问题中提出的要求：

Bin< Bin< Bin<Obj> > > bins;

为了动态地（在运行时）执行此操作，我采用了一些多态性。这个例子有点复杂。首先，有一个基本类型。

template <typename T>
class BinNode {
public:
    virtual ~BinNode () {}
    typedef std::shared_ptr< BinNode<T> > Ptr;
    virtual T * is_object () { return 0; }
    virtual const T * is_object () const { return 0; }
    virtual Bin<T> * is_vector() { return 0; }
    const T & operator = (const T &t);
    BinNode<T> & operator[] (unsigned i);
};

BinNode确定节点是否实际上是另一个向量或对象。

template <typename T>
class BinObj : public BinNode<T> {
    T obj;
public:
    T * is_object () { return &obj; }
    const T * is_object () const { return &obj; }
};

BinObj继承自BinNode，并表示对象本身。

template <typename T>
class Bin : public BinNode<T> {
    typedef typename BinNode<T>::Ptr Ptr;
    typedef std::map<unsigned, std::shared_ptr<BinNode<T> > > Vec;
    const unsigned dimension;
    Vec vec;
public:
    Bin (unsigned d) : dimension(d) {}
    Bin<T> * is_vector() { return this; }
    BinNode<T> & operator[] (unsigned i);
};

Bin是BinNode's 的向量。

template <typename T>
inline const T & BinNode<T>::operator = (const T &t) {
    if (!is_object()) throw 0;
    return *is_object() = t;
}

BinNode如果它实际上是对象，则允许分配给它；

template <typename T>
BinNode<T> & BinNode<T>::operator[] (unsigned i) {
    if (!is_vector()) throw 0;
    return (*is_vector())[i];
}

BinNode如果它是向量，则允许对其进行索引。

template <typename T>
inline BinNode<T> & Bin<T>::operator[] (unsigned i)
{
    if (vec.find(i) != vec.end()) return *vec[i];
    if (dimension > 1) vec[i] = Ptr(new Bin<T>(dimension-1));
    else vec[i] = Ptr(new BinObj<T>);
    return *vec[i];
}

如果存在，则返回索引项，否则根据当前维度深度创建适当的条目。添加重定向运算符以进行漂亮的打印：

template <typename T>
std::ostream &
operator << (std::ostream &os, const BinNode<T> &n) {
    if (n.is_object()) return os << *(n.is_object());
    return os << "node:" << &n;
}

然后你可以Bin像这样使用：

int dim = 3;
Bin<float> v(dim);
v[0][1][2] = 3.14;
std::cout << v[0][1][2] << std::endl;

它目前不支持0维，但我邀请你尝试自己做。

于 2012-06-09T19:30:04.407 回答