C语言——指针/数组：指针与数组、指针运算、二级指针、函数指针

内容

1.指针类型
2.指针与数组
3.指针运算
4.二级指针
5.数组指针与指针数组
6.数组参数、指针参数
7.函数指针
————————————————————————————————————————————

*1.指针类型

• 在计算机中，指针（Pointer）是编程语言中一个对象，创建一个指针变量，它的值指向的是存在电脑存储器中另一个地方的值，即指针储存的就是另一个变量的地址，该地址指向该变量单元。
• 指针作用：通过指针可以间接访问内存（内存是编号是从0开始记录的，用十六进制表示），可以用指针保存地址；
• &变量——取地址：取该变量最低一个字节的地址；
• *变量名——解引用：就可以找到指针指向的内存地址所存的数据（需要获得该数据的起始地址+该数据内存的长度；需要是有效的指针，对应内存是已经申请到的可以用的内存）
• 野指针：对应无效非法的内存，解引用操作会引起未定义行为！
• 空指针：用于初始化指针；
• 野指针和空指针都不是申请分配的内存空间，因此都不可访问；有种特殊的野指针、空指针、NULL，对应地址编号为0的内存空间；
• 常量指针：const修饰指针，指针的指向可以改变，指针指向的值不能改变；
• 指针常量：const修饰的是常量，指针的指向不可以改变，指针指向的值可以改变；
• const既修饰指针又修饰变量，指向和指向地址的值都不可改变；
• 不管是什么类型指针，在32为操作系统下，都是占4个字节的内存大小；64位占8个字节；

*2.指针与数组

例：

#include<stdio.h>
int main(){
	int arr[]={1,2};
	printf("%p\n",arr);
	printf("%p\n",&arr[0]);
	system("pause");
	return 0;
}

• 可以看到数组名——可以隐式转化为数组首元素的地址；
• 故可以创建一个指针变量 int *p=arr; 指针指向数组首元素地址，可以利用指针访问数组；

int arr[]={1,2};
printf("%p\n",arr);
printf("%p\n",arr+1);
printf("%p\n",&arr);
printf("%p\n",&arr+1);

• &arr 实际上是数组的地址，不是数组首元素的地址；&arr+1 表示跨过整个数组大小 &arr 与 arr 相差 数组内存大小（2*4）差8；

*3.指针运算

• 指针±整数：实际上是根据指针的类型，指针向前向后移动一个类型的内存；
• 指针-指针：实际上是地址相减；计算两个变量之间相差的数据个数；
• 指针-指针 实际上是 指针±整数 的逆运算；
• 指针的关系运算：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main() {
	int n = 1;
	int* p = &n;
	char s = 1;
	char* ps = &s;
	printf("%p\n", &n);
	printf("%p\n", p + 1);
	printf("%p\n", &s);
	printf("%p\n", ps);
	printf("%P\n", ps + 1);
	system("pause");
	return 0;
}

• 根据这一性质，可以利用指针指向数组首元素地址，通过指针访问数组，每次指针加减，相当于指向数组元素前一位/后一位的改变；

#include<stdio.h>
#include<stdlib.h>
int main(){
	int arr[] = { 1,2,3 };
	int* p = & arr;
		for (int i = 0; i <3; i++) {
			printf("%d ", *(p + i));
		}
	system("pause");
	return 0;
}

• p+i 实际上对应指向数组arr下标为i的元素地址；
• *(p+1) <=>p[1];

*4.二级指针

• 实际上就是一个指针变量指向的是一个指针变量的地址；

int n = 1;
int m=2;
int* p = &n;
int* pp = &p;
* pp = &b;
** pp = 3;

• 如上所示，p是指向整型变量n地址的一级指针变量；pp是指向一级指针p地址的二级指针变量；解引用pp——*pp实际得到的是指针变量p，*pp = &b——实际上就是改变指针p的指向，重新令它指向变量b的地址； **pp = 3——实际上就是先解引用得到指针p，再解引用得到指针p指向的变量b，把3赋值给b；通过指针可以间接访问变量内存，进而访问变量在内存中存储的数据。

*5.数组指针与指针数组

（1）数组指针

char str[]="hello!";
char* p= str; //因为数组名可以隐式转化为数组首元素的地址，故此处&可以省略

• char *p=&str ——字符指针，此处实际上是一个指向该字符数组首元素地址的指针变量；
• int (*p)[5]——整型数组指针； * 和p结合，说明这个是指针变量，指向的是数组元素为5的整型数组；
• int( * )[3] 和 int( * )[4] 不同类型的指针；

（2）指针数组

• 指针数组：一个存放指针的数组；

int * p1[10];   //存放整型指针的数组
char* p2[5];    //存放字符型指针的数组 
char** p3[4];   //存放二级字符型指针的数组
char s1[]="hello";
char* s2[]="hello";

• “hello”是一个字符串常量；故 若尝试对只读区域内存进行修改，就会出现上图这样的写入访问权限冲突的问题；
• 字符数组指针s1和s2都指向 常量字符数组——字符串“hello” ；设置指针指向常量防止误修改操作；
• 为防止修改初始数据，可以考虑写时拷贝进行修改而不影响原始值；

*5.数组参数、指针参数

（1）数组参数正确格式

• 一维数组参数：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void test01(int arr[]) {
	printf("01well\n");
}
void test02(int arr[2]) {
	printf("02well\n");
}
void test03(int* arr) {
	printf("03well\n");
}
void test04(int* arr[2]) {
	printf("04well\n");
}
void test05(int** arr) {
	printf("05well\n");
}


int main() {
	int arr[] = { 1,2 };
	int* arr1[] = {1,2};
	test01(arr);
	test02(arr);
	test03(arr);
	test04(arr1);
	test05(arr1);

	system("pause");
	return 0;
}

以上参数形式都正确；

• 二维数组参数：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void test01(int arr[2][3]) {
	printf("01well\n");
}
void test02(int arr[][3]) {
	printf("02well\n");
}
void test03(int (*arr)[3]) {
	printf("03well\n");
}
void test04(int (*arr)[2]) {  //错误！ int (*)[2] 和 实参int (*)[3]类型不同
	printf("04well\n");
}
void test05(int* arr) {  //错误！ int * 指向实参二维数组第一行地址 类型不匹配
	printf("05well\n");
}
void test06(int** arr) { //错误！ 形参int** 期望的实参是 int * [3]
	printf("06well\n");
}

int main() {
	int arr[2][3] = { 0 };
	test01(arr);
	test02(arr);
	test03(arr);
	test04(arr);
	test05(arr);
	test06(arr);
	system("pause");
	return 0;
}

*6.函数指针

• 函数指针：定义一个指针变量，指向函数的首地址；
• 作用：实现函数多功能调用；

例：利用函数指针实现冒泡排序函数不但能实现升序排列，也能实现降序排列；

• 给冒泡函数添加一个参数时，这个参数就是函数指针——>调用时通过函数指针对应的函数实现不同排序规则的调用；调用冒泡函数时需要具体指定要调用哪一个函数指定排序规则；这个函数也称为回调函数；
• 回调函数：就是通过函数指针调用的函数；当把该函数的指针（地址）作为参数传递给另一个函数时；函数指针通过调用指向的该函数完成对某一事件的相应；

#include<stdio.h>
#inclucde<stdlib.h>
//打印数组函数
void print(int arr[], int len) {
	for (int i = 0; i < len; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//定义一个函数指针类型，返回值为Int型；有两个int参数；
typedef int(*judge)(int a, int b);
//冒泡排序函数
void bubble(int arr[], int len,judge sort) {
	for (int bound = 0; bound < len; bound++) {
		for (int cur = len - 1; cur > bound; cur--) {
			if (sort(arr[cur-1],arr[cur])!=0) { //此处sort函数就指向传入的排序规则，执行不同本次调用的回调函数
				int temp = arr[cur];
				arr[cur] = arr[cur - 1];
				arr[cur - 1] = temp;
			}
		}
	}
}
int ascending(int a, int b) { //回调函数：定义升序排序规则
	return a > b ? 1 : 0;
}
int descending(int a, int b) { //定义降序排序规则
	return a < b ? 1 : 0;
}

int main() {
	int arr1[] = { 3,4,8,1,7,2 };
	int arr2[] = { 2,5,7,3,1,4,6 };
	int len1 = sizeof(arr1) / sizeof(arr1[0]);
	int len2 = sizeof(arr2) / sizeof(arr2[0]);
	bubble(arr1, len1,ascending); //升序
	print(arr1, len1);
	bubble(arr2, len2, descending);//降序
	print(arr2, len2);
	
	system("pause");
	return 0;
}