Question

我需要从用户那里获得输入N并生成N * N矩阵。我该如何申报矩阵？一般来说，数组和矩阵的大小应该在声明中固定，对吧？那么vector<vector<int>>呢？我从来没有使用过这个，所以我需要老兵的建议。

Answer 1

vector<vector<int> >（注意> >中的空格）可以很好地运作，但它不一定是最有效的方法。另一个可以很好地工作的是一个包含单个向量的包装器，它跟踪所表示的矩阵的“形状”，并提供一个函数或重载操作符来访问数据：

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 ++。如果您真的开始使用[]表示法，那么无论如何都可以这样做，虽然它有点棘手（在矩阵类中重载它以返回代理，然后使代理类也重载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;

Answer 2

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

#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

根据输入的动态二维数组

3 个答案: