void func(int *p, int len){
    for(int i = 0; i < len; ++i){
        cout<<*(p + i)<<endl;
    }

}

void func(int *p, int len){
    for(int i = 0; i < len; ++i){
        cout<<p[i]<<endl;
    }

}

int main(){
    
    int a[5] = {1, 2, 3, 4, 5};
    func(a, 5);
}

首先一个例子是用sizeof函数的时候，sizeof(数组名a)得到的是数组中所有元素占用的空间大小（以字节算），而sizeof(p)得到的是指针本身的大小，比如32位系统中就是4个字节。还有一个例子如下：即指针是可以改变的，而数组名是不可以改变的。

void func(int *p, int len){
     for(int i = 0; i < len; ++i){
        if(i){
             p += 1;
         }
        
        cout<<*p<<endl;
    }

 }

上边函数是正确的，下边代码段是错误的

for(int i = 0; i < 5; ++i){
        if(i){
            a += 1;
        }
        cout<<*a<<endl;
    }

所以，数组名跟指针之间真正的关系是：数组名可以退化成指针（数组类型自动类型转换成指向首元素的指针类型）。这就是数组和指针唯一的关系。

当我们将数组名作为实参传递的时候，会自动类型转换成指向首元素的指针类型，这也解释了为什么sizeof作用于数组名和指针的时候不同，以及数组名不能改变，指针可以改变，因为它们本来就是完全不同的两种类型。

方法2：数组类型做函数形参

当用int p[ ]做形参时候，跟用int * 完全一样，即一维数组类型做形参的时候会完全退化成指针类型，所以用sizeof在我的64位机器上的结果是8个字节。故用int p[]来接收指针类型自然是可以的。

即便是在做形参的时候指定数组大小，int p[5], 结果依然是和int *等价的

总结：int p[option]做函数形参与int *p完全等价

void func(int p[], int len){
    cout<<sizeof(p)<<endl;
    for(int i = 0; i < len; ++i){
        if(i){
            *p += 1;
        }
        
        cout<<*p<<endl;

}

int main(){

    int a[5] = {1, 2, 3, 4, 5};
    func(a, 5);
    
    return 0;
}

小例子2：写一个函数接收数组的地址（数组指针）并遍历输出

方法1：数组指针类型做函数形参

需要注意的是这次传递的实参是&a，其类型是int (*)[5]指向数组的指针，这个时候的参数传递不能发生退化或自动类型转换，即函数形参p必须也是int(*)[5]类型的。即p是一个数组指针。

void func(int (*p)[5], int len){
    for(int i = 0; i < len; ++i){
        
        cout<<(*p)[i]<<endl;
        cout<<*((*p) + i)<<endl;
    }

}

int main(){
    
    int a[5] = {1, 2, 3, 4, 5};
    func(&a, 5);
}

对数组指针解引用得到数组类型，因此这个时候对p解引用得到的是数组类型，即*p并没有退化成指向首元素的指针，*p的类型是 int[5] ，而不是int *，因此*p是不能改变的，像下面这样的代码编译不通过。

void func(int (*p)[5], int len){
    for(int i = 0; i < len; ++i){
        if(i){
            *p += 1;
        }
        // cout<<(*p)[i]<<endl;
        // cout<<*((*p) + i)<<endl;
    }

}

方法2：指针类型做函数形参

虽然数组指针类型&a没办法自动类型转换成指针类型int *，

void func(int *p, int len){
    for(int i = 0; i < len; ++i){
        cout<<*(p + i)<<endl;
}

}

int main(){
    
    int a[5] = {1, 2, 3, 4, 5};
    func((int *)&a, 5);
    
    return 0;
}

结论：写一个函数遍历一维数组问题

函数形参直接写成指针类型，即int *，这样可以传递数组名也可以传递数组指针，传递数组指针的时候只需要对实参进行强转就行了。

五、二维数组与指针

首要问题：二维数组的本质也是内存中一段连续的区域，二维数组名的值是二维数组0行0列即首元素的地址，但二维数组名的类型还是 int [][]。

小例子1：写一个函数接收二维数组名并遍历输出数组元素

方法一：二维数组/数组指针类型做形参

首先，如果要用二维数组做形参，则至少要指定列数，行数可以指定也可以不指定。

如同一维数组做形参会自动类型转换成一维指针，二维数组做形参时会自动转换成为数组指针。

二维数组做右值的时候，会自动转换成数组指针类型，即int a[2][3]会自动转换成

int (*a)[3]。因此用二维数组和用数组指针做形参是等价的。可以看到我们在输出值的时候用了两层解引用。其实对于数组指针来说，直接用a[i][j]也是可以的。用两层解引用的含义是：a是 int (*)[3]类型的数组指针，*a的结果是一个一维数组 int [3]类型（注意是数组而不是一级指针 int *），a + i的意思就是第i行数组，第一层解引用得到了第i行数组，其值就是该行第一个元素的首地址，首地址 + j再进行第二次解应用就得到的具体的值。当然，也可以在第一次解引用后直接用下标，即 cout<<(*(a + i))[j]<<endl;

void func(int a[][3], int row, int col){
    for(int i = 0; i < row; ++i){
        for(int j = 0; j < col; ++j){
            cout<<*(*(a + i) + j)<<endl;
        }
    }
}

void func(int (*a)[3], int row, int col){
    for(int i = 0; i < row; ++i){
        for(int j = 0; j < col; ++j){
            cout<<*(*(a + i) + j)<<endl;
        }
    }
}

int main(){
    
    int a[2][3] = {1,2,3,4,5,6};
    func(a, 2, 3);
    // func((int **)a, 5);

    return 0;
}

方法二：一级指针做函数形参

因为C语言中数组都是连续存储的，因此我们可以用首地址加偏移量的方式来遍历每一个元素。即

cout<<*(a + i * col + j)<<endl;

但是需要注意的是二维数组是没办法自动类型转换成一级指针的，因此在调用的时候需要强转一下。

void func(int *a, int row, int col){
    for(int i = 0; i < row; ++i){
        for(int j = 0; j < col; ++j){
             
            cout<<*(a + i * col + j)<<endl;
        }
    }
}

int main(){
    
    int a[2][3] = {1,2,3,4,5,6};
    func((int *)a, 2, 3);
    // func((int **)a, 5);

    return 0;
}

方法三：二级指针类型做函数形参

首先明确一点，二级指针int **与二维数组int [ ][ ]没有半毛钱关系！因此虽然可以用二级指针来接收二维数组，但最后遍历元素的时候还是相当于用了一级指针中首地址加偏移量的方式。即在func函数中虽然形参是二级指针，但是具体使用的时候还是转成了一级指针来用。

同理，二维数组也是没办法自动转成二级指针的，因此调用函数的时候需要强转。

void func(int **a, int row, int col){
    for(int i = 0; i < row; ++i){
        for(int j = 0; j < col; ++j){
            cout<<*((int *)a + i * col + j)<<endl;
        }
    }
}

int main(){
    
    int a[2][3] = {1,2,3,4,5,6};
    //func(a, 2, 3);
    func((int **)a, 5);

    return 0;
}