如何使用指针的二维向量

Question

实现高效二维向量的正确方法是什么？我需要将一组 Item 对象存储在 2d 集合中，这样可以快速迭代（最重要）并且可以快速查找元素。

我有一个 2d 指针向量，声明如下：

std::vector<std::vector<Item*>> * items;

在构造函数中，我将其实例化如下：

items = new std::vector<std::vector<Item*>>();
items->resize(10, std::vector<Item*>(10, new Item()));

我如何（正确）实现访问项目的方法？例如：

items[3][4] = new Item();

AddItem(Item *& item, int x, int y)
{
     items[x][y] = item;
}

我使用指针的原因是为了获得更好的性能，这样我就可以通过引用传递东西。

如果有更好的方法来解决这个问题，请解释一下，但是我仍然对如何正确使用向量感兴趣。

编辑：为澄清起见，这是一个简单游戏中用于库存管理的类的一部分。设置的 10x10 向量表示作为设置大小的库存网格。 Item 类包含项目类型、资源管理器中指向图像的指针、堆栈大小等。

我的指针使用是为了提高性能，因为这个类是迭代的，并使用图像指针在每一帧渲染整个库存。

Answer 1

您似乎事先知道矩阵的大小，并且该矩阵是平方的。虽然vector<> 很好，但在这种情况下您也可以使用原生向量。

Item **m = new Item*[ n * n ];

如果你想访问位置r,c，那么你只需要将r乘以n，然后加上c：

pos = ( r * n ) + c;

所以，如果要访问位置 1、2、n = 5，那么：

pos = ( 1 * 5 ) + 2;
Item * it =  m[ pos ];

另外，除了使用普通指针，您还可以使用智能指针，例如auto_ptr（已过时）和unique_ptr，它们或多或少相似：一旦它们被销毁，它们就会销毁它们指向的对象.

auto_ptr<Item> m = new auto_ptr<Item>[ n * n ];

唯一的缺点是现在你需要调用get()才能获取指针。

pos = ( 1 * 5 ) + 2;
Item * it =  m[ pos ].get();

这里有一个总结了所有这些的课程：

class ItemsSquaredMatrix {
public:
    ItemsSquaredMatrix(unsigned int i): size( i )
        { m = new std::auto_ptr<Item>[ size * size ]; }
    ~ItemsSquaredMatrix()
        { delete[] m; }

    Item * get(unsigned int row, unsigned int col)
        { return m[ translate( row, col ) ].get(); }
    const Item * get(unsigned int row, unsigned int col) const
        { return m[ translate( row, col ) ].get(); }

    void set(unsigned int row, unsigned int col, Item * it)
        { m[ translate( row, col ) ].reset( it ); }

    unsigned int translate(unsigned int row, unsigned int col) const
        { return ( ( row * size ) + col ); }

private:
    unsigned int size;
    std::auto_ptr<Item> * m;
};

现在您只需创建类Item。但是，如果您创建了一个特定的类，那么您必须为每个新数据复制 ItemsSquaredMatrix。在 C++ 中，对此有一个特定的解决方案，涉及在 模板 中转换上述类（提示：vector<> 是一个模板）。由于您是初学者，将Item 作为抽象类会更简单：

class Item {
public:
    // more things...
    virtual std::string toString() const = 0;
};

并派生您将从它们创建的所有数据类。不过记得做演员表……

如您所见，有很多未解决的问题，而且随着您不断揭示问题，还会提出更多问题。享受吧！

希望这会有所帮助。

Answer 2

对于数值工作，您希望将数据尽可能本地存储在内存中。例如，如果您要创建 n 与 m 矩阵，您可能会想将其定义为

vector<vector<double>> mat(n, vector<double>(m));

这种方法有严重的缺点。首先，它不适用于任何适当的矩阵库，例如BLAS 和LAPACK，它们希望数据在内存中是连续的。其次，即使这样做，也会导致内存中出现大量随机访问和指针间接，这会降低矩阵运算的性能。相反，您需要一个连续的内存块n*m 个大小的项目。

vector<double> mat(n*m);

但您不会真的想为此使用vector，因为您需要手动将一维索引转换为二维索引。在C++ 中有一些库可以为您执行此操作。其中之一是Blitz++，但现在似乎没有太多开发。其他替代方案是Armadillo 和Eigen。详情请见this previous answer。

例如，使用Eigen，矩阵声明将如下所示：

MatrixXd mat(n,m);

您将能够以mat[i][j] 访问元素，并将矩阵乘以mat1*mat2，等等。

Answer 3

第一个问题是为什么要指针。几乎没有任何理由 有一个指向std::vector 的指针，但这种情况并不常见 你会有一个指针向量。你的定义应该是：

std::vector<std::vector<Item> > items;

，或者至少（假设例如 Item 是 多态层次结构）：

std::vector<std::vector<Item*> > items;

至于您的问题，最好的解决方案是以某种方式包装您的数据 属于Vector2D 类，其中包含std::vector<Item> 作为成员， 并进行索引计算以访问所需的元素：

class Vector2D
{
    int my_rows;
    int my_columns;
    std::vector<Item> my_data;
public:
    Vector2D( int rows, int columns )
        : my_rows( rows )
        , my_columns( columns )
    {
    }

    Item& get( int row, int column )
    {
        assert( row >= 0 && row < my_rows
                && column >= 0 && column < my_columns );
        return my_data[row * my_columns + column];
    }

    class RowProxy
    {
        Vector2D* my_owner;
        int my_row;
    public;
        RowProxy(Vector2D& owner, int row)
            : my_owner( &owner )
            , my_row( row )
        {
        }
        Item& operator[]( int column ) const
        {
            return my_owner->get( my_row, column );
        }
    };
    RowProxy operator[]( int row )
    {
        return RowProxy( this, row );
    }

    //  OR...
    Item& operator()( int row, int column )
    {
        return get( row, column );
    }
};

如果您放弃边界检查（但我不建议这样做）， RowProxy 可以是简单的Item*。

当然，您应该为const 复制上述内容。