根据输入动态二维数组

Question

我需要从用户那里获取输入 N 并生成 N*N 矩阵。我如何声明矩阵？一般来说，数组和矩阵的大小应该在声明时固定，对吧？ vector> 怎么样？我以前从未使用过这个，所以我需要资深人士的建议。

Answer 1

vector>（或 vector >，对于较旧的编译器）可以很好地工作，但这不一定是最有效的方法做事¹。另一个可以很好地工作的是单个向量的包装器，它跟踪所表示的矩阵的“形状”，并提供函数或重载运算符来访问数据：

template <class T>
class matrix { 
    int columns_;
    std::vector<T> data;
public:
    matrix(int columns, int rows) : columns_(columns), data(columns*rows) {}

    T &operator()(int column, int row) { return data[row*columns_+column]; }
};

请注意，C++ 标准仅允许 operator[] 接受单个操作数，因此您不能将它用于此作业，至少不能直接使用它。在上面的示例中，我（显然）使用了 operator() 来代替，因此下标看起来更像 Fortran 或 BASIC，而不是您在 C++ 中习惯的下标。如果您确实决定使用 [] 表示法，则无论如何都可以这样做，尽管这有点棘手（您在矩阵类中重载它以返回代理，然后让代理类也重载 < code>operator[] 返回（引用）正确的元素——它的内部有点丑陋，但无论如何都工作得很好）。

下面是如何使用 operator[] 的多个重载来实现该版本的示例。我在大多数编译器包含 std::vector 之前写了这个（相当长一段时间），因此它静态分配一个数组而不是使用向量。它也适用于 3D 情况（因此涉及两个级别的代理），但幸运的是，无论如何，基本思想都会实现：

template<class T, int size>
class matrix3 {

    T data[size][size][size];

    friend class proxy;
    friend class proxy2;

    class proxy { 
        matrix3 &m_;
        int index1_, index2_;
    public:
        proxy(matrix3 &m, int i1, int i2) 
            : m_(m), index1_(i1), index2_(i2) 
        {}

        T &operator[](int index3) { 
            return m_.data[index1_][index2_][index3];
        }
    };

    class proxy2 { 
        matrix3 &m_;
        int index_;
    public:
        proxy2(matrix3 &m, int d) : m_(m), index_(d) { }

        proxy operator[](int index2) { 
            return proxy(m_, index_, index2);
        }
    };
public:
    proxy2 operator[](int index) {
        return proxy2(*this, index);
    }
};

使用它，您可以使用正常的 C++ 语法来寻址矩阵，例如

matrix3<double, size> m;

for (int x=0; x<size; x++)
    for (int y = 0; y<size; y++)
        for (int z = 0; z<size; z++)
            m[x][y][z] = x*100 + y * 10 + z;

---

1. ： code>std::vector 通常实现为指向某些动态分配数据的指针，因此像 vector>> 这样的东西将取消引用两个级别的获取每条数据的指针。这意味着更多的内存引用，这在大多数现代处理器上往往相当慢。由于每个向量都包含单独分配的数据，因此通常也会导致缓存局部性较差。它还可能浪费一些空间，因为每个向量都存储其分配的大小和正在使用的大小。

Answer 2

Boost 在其 中实现矩阵（支持数学运算） uBLAS库，并提供如下使用语法。

#include <boost/numeric/ublas/matrix.hpp>

int main(int argc, char* argv[])
{
    unsigned int N = atoi(argv[1]);
    boost::matrix<int> myMatrix(N, N);

    for (unsigned i = 0; i < myMatrix.size1 (); ++i)
        for (unsigned j = 0; j < myMatrix.size2 (); ++j)
            myMatrix(i, j) = 3 * i + j;

    return 0;
}

Answer 3

示例代码：

template<class T>
class Array2D
{
public:
    Array2D(int a, int b)  
    {
        num1 = (T**)new int [a*sizeof(int*)];
        for(int i = 0; i < a; i++)
            num1[i] = new int [b*sizeof(int)];

        for (int i = 0; i < a; i++) {
            for (int j = 0; j < b; j++) {
                num1[i][j] = i*j;
            }
        }
    }
    class Array1D
    {
    public:
        Array1D(int* a):temp(a) {}
        T& operator[](int a)
        {
            return temp[a];
        }
        T* temp;
    };

    T** num1;
    Array1D operator[] (int a)
    {
        return Array1D(num1[a]);
    }
};


int _tmain(int argc, _TCHAR* argv[])
{
    Array2D<int> arr(20, 30);

    std::cout << arr[2][3];
    getchar();
    return 0;
}

    enter code here