tipos - vector de vectores c++

Vector genérico de vectores en C++

Question

¿Existe una buena forma en C ++ para implementar (o falsificar) un tipo para un vector genérico de vectores?

Ignore la cuestión de cuándo un vector de vectores es una buena idea (a menos que haya algo equivalente que siempre sea mejor). Supongamos que modela con precisión el problema y que una matriz no modela el problema con precisión. Supongamos también que las funciones de plantilla que toman estas cosas como parámetros necesitan manipular la estructura (por ejemplo, llamar push_back), por lo que no pueden simplemente tomar un tipo genérico que soporte [][] .

Lo que quiero hacer es:

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

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

pero, por supuesto, eso no es posible, ya que typedef no puede ser modelado.

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

está cerca, y salvaría la duplicación del tipo en cada función de plantilla que opera en vecvecs, pero no sería popular con la mayoría de los programadores de C ++.

Answer 1

Desea tener los tipos de plantilladefs. Eso aún no es compatible con el C ++ actual. Una solución es hacer

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

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

En el siguiente C ++ (llamado c ++ 0x, c ++ 1x debido a 2010), esto sería posible:

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

Answer 2

Simplemente puede crear una nueva plantilla:

#include <string>
#include <vector>

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

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

Si haces eso, debes recordar que el destructor de vector no es virtual y no hacer algo como esto:

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

Answer 3

Yo uso Boost.MultiArray que se implementa en la biblioteca de impulso.

HTH

Answer 4

Puede implementar el tipo vector-vectorial básico usando std::vector como base:

#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;
}

Es simplemente un contenedor muy simple que imita una matriz (siempre que el usuario lo prometa, al mejorar la definición de vecvec o mediante el uso adecuado, la forma rectangular).