矩阵类（运用二维指针）

题目1：

 

#include<iostream>
using namespace std;

class Matrix
{
    private:
        int **p; //指向指针的指针：二级指针
        int rows;
        int cols;
    public:
        Matrix(int r, int c)
        {
            rows = r;
            cols = c;
            p = new int*[rows]; //先申请一个指针数组存放各行指针！！！
            for(int i=0; i<rows; i++)
            {
                p[i] = new int[cols]; //每个行的指针申请一个一维数组大小空间！！！
            }
        }
        Matrix(const Matrix &b)
        {
            //此处不用将类本身的空间删除
            //用一个已经存在对象去初始化另外一个对象，调用拷贝构造函数
            //而将一个已经存在的对象赋值给另一个已经存在的对象，调用赋值运算符重载函数，此时需要将原有的数据清除覆盖
            int i, j;
            rows = b.rows;
            cols = b.cols;
            if(b.p)
            {
                p = new int*[b.rows];
                for(i=0; i<b.rows; i++)
                {
                    p[i] = new int[b.cols];
                    for(j=0; j<b.cols; j++)
                    {
                        *(*(p+i)+j) = *(*(b.p+i)+j);
                    }
                }
            }
        }
        void input()
        {
            int i, j;
            for(i=0; i<rows; i++)
            {
                for(j=0; j<cols; j++)
                {
                    cin >> *(*(p+i)+j);
                }
            }
        }
        Matrix operator+(const Matrix &b)
        {
            int i, j;
            for(i=0; i<rows; i++)
            {
                for(j=0; j<cols; j++)
                {
                    *(*(p+i)+j) += *(*(b.p+i)+j);
                }
            }
            return *this;
        }
        Matrix operator=(const Matrix &b)
        {
            int i, j;
            if(this==&b) return *this; //若自身赋值
            rows = b.rows;
            cols = b.cols;
            if(p)
            {
                for(i = 0; i < rows; i++)
                {
                    delete[] p[i];
                }
                delete[]p;
            }
            if(b.p)
            {
                p = new int*[b.rows];
                for(i=0; i<b.rows; i++)
                {
                    p[i] = new int[b.cols];
                    for(j=0; j<b.cols; j++)
                    {
                        *(*(p+i)+j) = *(*(b.p+i)+j);
                    }
                }
            } 
            else p=NULL; //要不然p就成了野指针！！！！
            return *this;
        }
        void show()
        {
            int i, j;
            for(i=0; i<rows; i++)
            {
                cout << *(*(p+i));
                for(j=1; j<cols; j++)//从1开始，要不然第一个元素就会重复输出啊啊啊啊
                {
                    cout << " " << *(*(p+i)+j); 
                }
                cout << endl;
            }
        }
        ~Matrix()
        {
            for(int i = 0; i < rows; i++)
            {
                delete[] p[i];
            }
            delete[]p;
        }
};

int main()
{
    Matrix A(2, 3);
    Matrix B(2, 3);
    Matrix C(2, 3);
    cout << "请输入矩阵A：" << endl;
    A.input();
    cout << "请输入矩阵B：" << endl;
    B.input();
    C = A + B;
    cout << "矩阵C=A+B为：" << endl;
    C.show();
    return 0;
}

最近写老师布置的实验作业遇到了二维数组的问题，这里自我总结一下：

二维数组与指针

1、行指针变量

行指针变量指向一个一维数组，其定义格式为：<type> (*pname)[N]

以上从左到右分别是：类型标识符、指针变量名、一维数组中的元素个数

//已知二维数组
int a[3][4];

//定义一个 指向 含有4个元素的一维数组指针
int (*p)[4];

//此时p和a的数据类型一样，表示为int(*)[4],可以进行赋值p=a,在此前提下，可以通过四种方法访问数组a的元素
p[i][j]
*(p[i]+j)
*(*(p+i)+j)
(*(p+i))[j]

//三种方法获得a[i][j]的地址
&p[i][j]
p[i]+j
*(p+i)+j

2.二维数组名作函数参数

以二维数组名作函数参数，形参有以下三种写法：

eg.
void fun(int b[3][4]) // also int b[ ][4] or int (*b)[4]
//可以加上行数n

若已经令行指针p=a，那么实参可以是a，也可以是b，接上：

fun(a);
fun(b);

3.将二维数组看成是一维数组访问

二维数组从逻辑上看是二维的，而在内存中物理存储是一维的。（行存储）

已知一个数组a[M][N],将其按行存储为一维数组之后，欲知 a[i][j] 存储在一维数组中的第几个位置：以M=3 N=4举例

在这个数组中，在a[i][j]之前一共有 i*M+j 个元素，而p指向一维数组的第0个元素，故 a[i][j] 的地址就是 p+i*M+j 其值为 *（p+i*M+j ）

指向指针的指针

存放指针变量起始地址的变量，为指向指针的指针变量，其定义格式为：<类型说明符>**（指针变量名）

例如：

int x=3, *P1, **p2;
p1 = &x;
p2 = &p1;

再如：

#include<iostream>
using namespace std;
int main()
{
    char **p;
    char *s[] = {"apple", "boy", "cat", "dog"};
//指针数组含有四个元素，每个元素都是char*类型的指针，数组名s指向s[0],而s[0]本身是char*类型的指针，故s是指向指针的指针常量
//s的类型可以写作 char** 或 char*[]
    int i;
    p = s;
    for(i=0; i<4; i++)
    {
        cout << *p++ << endl;//*p++等价于先输出*p，然后p++
    }
    return 0;
}

最后，欢迎指正！