如何使用指针访问矩阵列的元素

Question

我有一个矩阵A ，我需要传递一个指向function的指针来访问给定列的元素，这是代码的一部分，其中PtrColumn应该是指向表示A的列j的向量的指针。 有没有办法在不计算矩阵A的转置的情况下获取此指针。

    vector<vector<double>> A;
    int l=4,c=5;
    A.reserve(l)
    for(size_t i=0;i<l;++i)
    {
    vector<double> row;
    row.reserve(c)
     for(size_t j=0;j<c;++j)
        row.puch_back(j);
    A.puch_back(row);
    }
////// some part of the code/////
    for(size_t j=0;j<c;++j)
      function(PtrColumn) //PtrColumn is a pointer to a vector, and my vector is the column j of A

Answer 1

我会为列使用矩阵 class 和包装器 class：

#include <iostream>
#include <vector>

class Matrix;

class Column {
    Matrix *A;
    std::size_t column;
    
public:
    Column(Matrix &A, std::size_t column);
    double &operator[](std::size_t row);
    std::size_t size() const;
};

class Matrix {
    std::size_t columns;
    std::size_t rows;
    std::vector<double> A;
    
public:
    Matrix(std::size_t l, std::size_t r) : columns(r), rows(l), A(l * r) {}
    double &operator()(std::size_t i, std::size_t j) { return A[i * columns + j]; }
    std::size_t getColumns() const { return columns; }
    std::size_t getRows() const { return rows; }
    Column getColumn(std::size_t column) { return Column(*this, column); }
};

Column::Column(Matrix &A, std::size_t column) : A(&A), column(column) {}
double &Column::operator[](std::size_t row) { return (*A)(row, column); }
std::size_t Column::size() const { return A->getRows(); }

void function(Column col) {
    std::cout << col[2] << '\n';
    std::cout << col.size() << '\n';
}

int main() {
    int l = 4, c = 5;
    Matrix A(l, c);
    for(size_t i=0;i<l;++i)
        for(size_t j=0;j<c;++j)
            A(i, j) = j;

////// some part of the code/////
    for(size_t j = 0; j < c; ++j)
      function(A.getColumn(j)); //PtrColumn is a pointer to a vector, and my vector is the column j of A
}

这是一个没有矩阵的代码 class

#include <iostream>
#include <vector>

class Column {
    std::vector<std::vector<double>> *A;
    std::size_t column;
    
public:
    Column(std::vector<std::vector<double>> &A, std::size_t column) : A(&A), column(column) {}
    double &operator[](std::size_t row) { return (*A)[row][column]; }
    std::size_t size() const { return A->size(); }
};

void function(Column col) {
    std::cout << col[2] << '\n';
    std::cout << col.size() << '\n';
}

int main() {
    std::vector<std::vector<double>> A;
    int l=4,c=5;
    A.reserve(l);
    for(size_t i=0;i<l;++i) {
        std::vector<double> row;
        row.reserve(c);
        for(size_t j=0;j<c;++j)
            row.push_back(j);
        A.push_back(row);
    }
////// some part of the code/////
    for(size_t j=0;j<c;++j)
      function(Column(A, j)); //PtrColumn is a pointer to a vector, and my vector is the column j of A
}