Question

我已经用这种方式声明了一个矩阵：

double **MB;
    MB = new double *[650000];
     for (int count = 0; count < 650000; count++)
     MB[count] = new double [2];

现在我想在一个应该修改它的函数中调用我的矩阵。

bool notindic (..., double MB [][2], ...) {}

并在主要内容：

notindic(..., MB, ...)

现在它给了我这个错误：* [错误]无法将'double **'转换为'double（）[2]'以将参数'3'转换为'bool notindic（std :: string，std：：string ，double（）[2]，int，int）'

我该如何解决？

谢谢。

Answer 1

只需将数组指针作为参数传递

#include <iostream>


const int NX = 65;
const int NY = 2;

bool notindic(double** MB) {
        for(int i = 0; i < NX; ++i) {
                for(int j = 0; j < NY; ++j) {
                        MB[i][j] = i + j;
                }
        }
}

int main() {
        double **MB = new double *[650000];
        for (int count = 0; count < 650000; count++) {
                MB[count] = new double [2];
        }

        notindic(MB);

        for(int i = 0; i < NX; ++i) {
                for(int j = 0; j < NY; ++j) {
                        std::cout << MB[i][j] << " ";
                }
                std::cout << std::endl;
        }
}

Answer 2

忘记所有指针废话。它容易出错，异常不安全，难以编写，难以阅读，难以维护且性能不佳。将您的矩阵表示为std::vector<double>并相应地计算偏移量。

bool notindic (std::vector<double> const& matrix, int m) {
    // ...
    auto const element = matrix[y * m + x];
    // ...
}

auto const m = 650000;
auto const n = 2;
std::vector<double> my_matrix(m * n);
auto const result = notindic(my_matrix, m);

当你在它时，将它包装在这样的类中：

template <class T>
class Matrix final
{
public:
    Matrix(int m, int n) :
        data(m * n),
        m(m)
   {
   }

   T& operator()(int x, int y)
   {
       return data[y * m + x];
   }

   T const& operator()(int x, int y) const
   {
       return data[y * m + x];
   }

private:
    std::vector<T> data;
    int m;
};

bool notindic (Matrix<double> const& matrix) {
    // ...
    auto const element = matrix(x, y);
    // ...
}

auto const m = 650000;
auto const n = 2;
Matrix<double> my_matrix(m, n);
auto const result = notindic(my_matrix);

如果您需要，请添加其他成员函数。

如何将动态矩阵称为函数？

2 个答案: