Question

C ++中是否有一种很好的方法来实现（或伪造）矢量通用向量的类型？

忽略向量向量是一个好主意的问题（除非有等价的东西总是更好）。假设它确实对问题进行了精确建模，并且矩阵不能准确地模拟问题。假设将这些事物作为参数的模板化函数确实需要操纵结构（例如调用push_back），因此它们不能只采用支持[][]的泛型类型。

我想做的是：

template<typename T>
typedef vector< vector<T> > vecvec;

vecvec<int> intSequences;
vecvec<string> stringSequences;

但当然这是不可能的，因为无法模板化typedef。

#define vecvec(T) vector< vector<T> >

是接近的，并且可以保存在vecvecs上运行的每个模板化函数中复制类型，但不会受到大多数C ++程序员的欢迎。

Answer 1

您想拥有template-typedef。那是当前C ++中尚未支持的。解决方法是

template<typename T>
struct vecvec {
     typedef std::vector< std::vector<T> > type;
};

int main() {
    vecvec<int>::type intSequences;
    vecvec<std::string>::type stringSequences;
}

在下一个C ++中（由于2010年称为c ++ 0x，c ++ 1x），这是可能的：

template<typename T>
using vecvec = std::vector< std::vector<T> >;

Answer 2

我使用在boost库中实现的Boost.MultiArray。

HTH

Answer 3

您只需创建一个新模板：

#include <string>
#include <vector>

template<typename T>
struct vecvec : public std::vector< std::vector<T> > {};

int main() 
{
    vecvec<int> intSequences;
    vecvec<std::string> stringSequences;
}

如果你这样做，你必须记住vector的析构函数不是虚拟的，不能做这样的事情：

void test()
{
    std::vector< std::vector<int> >* pvv = new vecvec<int>;
    delete pvv;
}

Answer 4

您可以使用std::vector作为基础来实现基本矢量矢量类型：

#include <iostream>
#include <ostream>
#include <vector>
using namespace std;

template <typename T>
struct vecvec
{
    typedef vector<T> value_type;
    typedef vector<value_type> type;
    typedef typename type::size_type size_type;
    typedef typename type::reference reference;
    typedef typename type::const_reference const_reference;

    vecvec(size_type first, size_type second)
        : v_(first, value_type(second, T()))
    {}

    reference operator[](size_type n)
    { return v_[n]; }

    const_reference operator[](size_type n) const
    { return v_[n]; }

    size_type first_size() const
    { return v_.size(); }

    size_type second_size() const
    { return v_.empty() ? 0 : v_[0].size(); }

    // TODO: replicate std::vector interface if needed, like
    //iterator begin();
    //iterator end();

private:
    type v_;

};

// for convenient printing only
template <typename T> 
ostream& operator<<(ostream& os, vecvec<T> const& v)
{
    typedef vecvec<T> v_t;
    typedef typename v_t::value_type vv_t;
    for (typename v_t::size_type i = 0; i < v.first_size(); ++i)
    {
        for (typename vv_t::size_type j = 0; j < v.second_size(); ++j)
        {
            os << v[i][j] << '\t';
        }
        os << endl;
    }
    return os;
}

int main()
{
    vecvec<int> v(2, 3);
    cout << v.first_size() << " x " << v.second_size() << endl;
    cout << v << endl;

    v[0][0] = 1; v[0][1] = 3; v[0][2] = 5;
    v[1][0] = 2; v[1][1] = 4; v[1][2] = 6;
    cout << v << endl;
}

它只是一个非常简单的容器，模仿矩阵（只要用户承诺，通过改进vecvec定义或正确使用矩形）。

向量的通用向量在C ++中

4 个答案: