如何通过二维数组作为参数？

问题描述

我的 MATRX 类定义为

class Matrx
{
 double A[50][50];
 int m,n;
public:
 Matrx(void);
 Matrx(int a, int b)
 {
  m=a;
  n=b;
 }
 Matrx operator +(Matrx b);
 Matrx Transpose(Matrx b);
 Matrx operator *(Matrx b);
 CString printMatrx();
 void readMatrx(double a[][]);
 Matrx TransposeMat(Matrx b);
};

void Matrx::readMatrx(double a[][])
{
 for(int i=0;i< m;i++)
  {
   for(int j=0;j< n;j++)
    A[i][j]=a[i][j];
  }
}

智能感知提供了错误，如下面的

The intellisense gives error like the below

1智能感知：数组可能没有这种类型的D元素：\\ bmadaptive_dd_v1.02 \\ matrx.h 17 27 TESTSERVER

为什么？

如何通过二维数组作为函数的参数？

How to pass a two dimensional array as argument of the function?

推荐答案

您需要正确地了解数组和指针。这包括课呵呵！他们并不像我以为他们是有用。你已经得到熟悉数组和指针如何工作后正是你应该反思一下你的设计。

You need to properly learn about arrays and pointers. This includes the lesson "huh! They are not as useful as I thought they were". After you've gotten familiar with how arrays and pointers work exactly you should rethink your design.

例如，在我看来，下面的设计有很多优点：

For example, in my opinion, the following design has lots of advantages:

#ifndef MATRIX_HPP_INCLUDED
#define MATRIX_HPP_INCLUDED

#include <vector>
#include <algorithm>

class matrix
{
public:
    typedef std::vector<double>::size_type st;
    matrix() : rows_(0), cols_(0) {}
    matrix(int r, int c) : rows_(r), cols_(c), coeffs_(st(r)*c,0.0) {}
    void reset(int r, int c)
    { rows_=r; cols_=c; coeffs_.clear(); coeffs_.resize(st(r)*c,0.0); }
    int rows() const {return rows_;}
    int cols() const {return cols_;}
    double const& operator()(int i, int j) const {return coeffs_[indexof(i,j)];}
    double      & operator()(int i, int j)       {return coeffs_[indexof(i,j)];}
    double const* operator[](int i) const {return &coeffs_[indexof(i,0)];}
    double      * operator[](int i)       {return &coeffs_[indexof(i,0)];}
    void swap(matrix& that)
    {
      std::swap(this->rows_,that.rows_);
      std::swap(this->cols_,that.cols_);
      this->coeffs_.swap(that.coeffs_));
    }
private:
    int rows_, cols_;
    std::vector<double> coeffs_;
    st indexof(int i, int j) const {return st(i)*cols+j;} // row major storage
};

inline void swap(matrix& a, matrix& b) {a.swap(b);}

matrix& operator+=(matrix& lhs, matrix const& rhs);
matrix operator+(matrix const& lhs, matrix const& rhs);
matrix operator*(matrix const& lhs, matrix const& rhs);
inline matrix& operator*=(matrix& lhs, matrix const& rhs)
{ matrix tmp = lhs * rhs; swap(tmp,lhs); return lhs; }
...

#endif

这样你就不会浪费任何空间小矩阵，可以支持大型矩阵。此外，这点在使用std向量，而不是一个指针成员的::动态分配的内存不再需要定义自己的拷贝构造函数，赋值操作符和析构函数。

This way you won't waste any space for small matrices, and you can support large matrices. Also, the use of std::vector instead of a pointer member which points to dynamically allocated memory removes the need to define your own copy constructor, assignment operator and destructor.

当然，你可以使用boost :: multi_array的作为基质替代，但使用自定义矩阵类，您可以在自己的名称空间声明运算符重载这是可取的，由于ADL（参数依赖查找）。

Of course, you could use boost::multi_array as a matrix replacement but using a custom matrix class allows you to declare overloaded operators in your own namespace which is desirable due to ADL (argument dependent lookup).

您可能会认为这并没有真正回答你的问题。在这种情况下，我要强调，我认为你没有完全了解数组和指针的工作/行为。这是你应该查找在一个体面的C ++的书。人们可以写这个主题相关的网页。你不能指望看到一个简短的回答解释所有的怪癖。

You might think that this doesn't really answer your question. In that case, let me stress that I think you don't fully understand how arrays and pointers work / behave. This is something you should look up in a decent C++ book. One could write many pages about this topic. You can't expect to see a short answer explaining all the quirks.

查看线程。

这篇关于如何通过二维数组作为参数？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！