对于用指向多维数组的指针做函数参数一些认识

首先，我们知道，一维数组可以作为函数参数，同时，多维数组也可以作为函数参数，用来接收实参组名传来的地址。可以有两种方法：用指向变量的指针变量和用指向一维数组的指针变量做函数参数，下面对于这两种方法做基本的阐述。

一、定义描述

（一）、用指向变量的指针变量做函数参数 首先，我们定义一个二维数组source[3][4],定义一个返回值为指针数据类型的函数：*search(int p)。当我们用指向变量的指针变量做函数参数时，我们传递的是数组首行、首列元素的首地址。因此，在函数内进行操作时，我们可以通过(p+i)来操作第i个数组元素，来返回他的地址。

（二）、用指向一维数组的指针变量做函数参数 同样，定义一个二维数组source[3][4]，,定义一个返回值为指针数据类型的函数：*search(int (p)[4])。此时，我们在操作这个函数时，传递给函数的是首行的地址，因此，在函数体内部，(p+i)才指的是第i行首元素的地址。

二、应用举例：寻找第k名同学的成绩

（一）、用指向变量的指针变量做函数参数

int main()

{     int *search(int *p,int n);

int source[3][4]={{99,99,99,99},{99,99,99,99},{88,88,88,88}};

int k,i;

int *p;

scanf("%d",&k);

p=search(source,k);

for(i=0;i<4;i++)

{

printf("%d ",(p+i));

}

}int *search(int *p,int n)

{

int *flag;

flag=p+(n-1)*4;

return flag;

}

（二）、用指向一维数组的指针变量做函数参数

int main()

{

int *search(int (*p)[4],int x);

int source[3][4]={{99,99,99,99},{99,99,99,99},{88,88,88,88}};

int k,i;

int p;

scanf("%d",&k);

p=search(source,k);

for(i=0;i<4;i++)

{

printf("%d ",(p+i));

}

}

int *search(int (*p)[4],int x)

{

int flag;

flag=(p+x-1);

return flag;

}

C语言数组
数组的中括号只有在定义的时候表示数组的大小，其余情况都表示下标
数组与函数

实际参数表示方法

数组做参数时，传递的是数组的首地址（1.第一个数组元素的地址   2.数组名）
形式参数表示方法

数组括号中大小无效

引入
做题的时候发现了一道题，想了很久也没有想出来与给出算法相符合的思路



最后写了个可以勉强得出结果，但是好像不怎么对的方法


因为题目给出的变量都已经使用过，所以只能使用数组名作为增量向后遍历
但是这时就出现了问题，数组名竟然不指向首地址元素了，事后想想也知道如果一直指向首元素那么显然不能通过这种自增数组名的方式遍历数组
在main函数定义数组并使用数组名自增时，编译器会报错，那为什么在while循环中可以自增？是因为while有神奇的魔力吗？显然不是，是因为在参数传递的时候，数组名在传递过程中发生了“退化”，从数组名这个特殊的类型退化成了指针，而指针自然时可以通过自增后移的
数组名退化为指针
数组名代表的是一个内存块及这个内存块中的元素类型 。只是在大多数情况下数组名会“退化”

算术运算与数组取下标操作符时退化为指针
在作为右值参与运算的时候，数组名会自动”退化“为指向首元素的指针
如:
char a[] = "hello";
char *p = a + 1;

数组取下标操作符[ ]，在c标准中对它的定义是等价于*(p + offset)运算。
也是就说，你写a[3]其实等价于*(a+3)，可以看到括号内是一个算术运算，于是a“退化”为一个指针，随后参与进行计算和解引用。
根据加法的交换律，我们也可以写成*(3+a)，也是就3[a]。
函数调用传递数组时退化为指针
我们学在给函数传递数组的时候，经常会听到“按值传递机制和按引用传递机制 ”这样的说法（网上也有很多），即传递数组是“按引用传递的”，这也是为什么传递数组在函数内读写数组，退出函数后数组会发生变化的原因。
实际上C语言参数传递只有一种:值传递
几种定义数组参数方式:
void test(int a[5])
void test(int [5])
void test(int*)

许多人认为，第一种写法是最好的，清晰（这个是对的，对于代码阅读者而言）而且可以告诉编辑器这个数组的大小。

但是，这三种声明在编译器看来只有一种：void test(int*)
test函数得到的是一个值为a“退化”后指向数组首元素（内存块首地址）的指针 ，在test内部是不知到a是一个数组的，它仅仅认为它是一个整数指针。
但是我们依然可以使用数组取下标操作符进行运算，因为即使a是一个数组名，它被用作数组取下标操作符的操作数时也会“退化”为指针

java数组常见问题
数组的定义
数组的属性
数组访问的问题
1. 数组越界
2. 指向空指针
3. 数组作为参数传递
数组转字符串
1. Arrays.toString()
2. 重写toString方法
数组的拷贝
1. 通过for循环
2. 通过工具类 Arrays.copyOf()
3. 通过 System.arraycopy()
4. 数组名 .clone()

数组的定义
数组是一块连续的内存，存放相同数据类型的集合。

在java中数组也叫数组对象

数组可以作为函数参数进行传递

数组可以作为返回值进行返回（c语言可是做不到的）
//静态初始化（静态初始化只有第一次定义可以）
int[] array = {1,2,3,4,5,6};

//动态初始化
int[] array2 = new int[10];//未初始化，默认值为0
int[] array3 = new int[]{1,2,3,4,5,6};//后面的[]中不能写数字，长度会自己判断
类型   引用                 对象

//匿名数组(可以作为返回值或者参数)缺点是只能用一次
fun(new int[]{1,2,3,4});

补充：

引用就是一个变量，里面存放的值是一个地址

引用不一定在栈上，但是对象一定在堆上

引用是不能指向引用的

数组的属性
打印数组的三种方式：
//1.for 可以拿到下标
for(int i = 0;i < array.length;i++){
	System.out.println(array[i]);
}

//2.foreach 只能拿到数组的值
for(int i : array.length){
	System.out.println(i);
}

//3.Arrays.toString 将数组转化为字符串进行输出
String str = Arrays.toString(array);
System.out.println(str);


数组访问的问题
1. 数组越界
数组可以访问的下标范围为 0 --> arry.length-1，若访问越界，会抛出数组下标越界异常
2. 指向空指针
当执行 array = null; 时 array指向空指针

array 不指向任何的对象，若此时访问 array，或者打印数组的长度时，会抛出空指针异常
此时array之前所指向的内容会被jvm自动垃圾回收（即当对象没有引用在指向的时候这个对象会被自动回收）

3. 数组作为参数传递
public static void main(){
    int array = new int[]{1,2,3,4}
	print(array);
    System.out.println(array[0]);
}
public static void print(int array2){
	for(int i : array.length){
		System.out.println(i);
	}
    array2[0] = 0；//在这里修改了array2指向的内容，外面也会受到影响
}

两个引用指向同一个对象，不管你去修改哪一个引用的值，其他的地方都会受到影响
数组转字符串
1. Arrays.toString()
//1.Arrays.toString实现
int[] arr = new int[]{1,2,3,4};
System.out.println(Arrays.toString);
	//输出结果：[1,2,3,4]


2. 重写toString方法
public static String toString(int arr[i]){

}

数组的拷贝
关于深拷贝和浅拷贝：

如果把 arr1 拷贝到 arr2之后，将arr2中的元素修改，arr1中的元素不受影响，称为深拷贝
以下四种方式对于引用类型来说都是浅拷贝，对于基本数据类型是深拷贝
1. 通过for循环
arr = [1,2,3,4,5];
int[] arr2 = new int[arr.length];
for(int i = 0;i < arr.length;i++){
	arr2[i] = arr[i];
}


2. 通过工具类 Arrays.copyOf()

拷贝数组

int[] arr = new int[]{1,2,3,4,5};
int[] arr2 = new int[5];

//两个参数：  要拷贝的数组  要拷贝的长度
arr2 = Arrays.copyOf(arr,arr.length);



拷贝数组的一部分

int[] arr = new int[]{1,2,3,4,5};

//左闭右开区间（不包括 4 下标）若后者超过arr的长度，超出部分全为零 
int[] arr2 = Arrays.copyOfRange(arr,2,4);

3. 通过 System.arraycopy()
此方法是用native方法修饰的（是用c或c++代码实现的）速度快
int[] arr = new int[]{1,2,3,4,5};
int[] arr2 = new int[arr.length];

// 参数： 要拷贝的数组 拷贝的数组开始位置  目标数组  拷贝到数组的目标位置 要拷贝的长度
System.arraycopy(arr,0,arr2,0,arr.length);

4. 数组名 .clone()
原理：产生当前对象的一个副本
int[] arr = new int[]{1,2,3,4,5};
int[] arr2 = new int[5];

arr2 = arr.clone();