第四站:指针的进阶-(二级指针,函数指针)

目录

二级指针

二级指针的用途

多级指针的定义和使用

指针和数组之间的关系

存储指针的数组(指针数组:保存地址值)

指向数组的指针(数组指针)

传参的形式(指针)

数组传参时会退化为指针

?void类型的指针

函数指针

定义:

调用:两种方式:(*指针名)(参数地址)? 或者? 指针名(参数地址)

应用:

---

二级指针

二级指针也是一个普通的指针变量，只是它里面保存的值是另外一个一级指针的地址

#include <iostream>


using namespace std;
int main(void) {
	
	int massage = 888;
	int* guizi1 = &massage;
	int** guizi2 = &guizi1;

	
	cout << "massage的地址" << &massage << endl;
	cout << "guizi1内的地址" << guizi1 << endl;
	cout << "guizi2内的地址" << *guizi2 << endl;

	cout << "guizi1内的值" << *guizi1 << endl;
	cout << "guizi2内的值" << **guizi2 << endl;
	return 0;
}

二级指针和一级指针的类型都是相同的,

二级指针所指向的对象就是一级指针的值,一级指针的值又是指向的变量的值,所以不管有多少级指针,他们只要保存的是上一级指针的地址,那么内部所保存的地址值都是一样的,

这里不要和指针变量本身作为一个变量的指针混淆了,所定义的二级指针和一级指针他们的地址值肯定是不同的但是他们内部所保存的内容(对象的地址)是相同的

二级指针的用途

普通指针可以将变量通过参数“带入”函数内部然后进行修改，但没办法将函数的内部变量“带出”函数

二级指针不但可以将变量通过参数带入函数内部，也可以将函数内部变量 “带出”到函数外部。

?使用的一级指针报警:读取位置 0x0000000000000000 时发生访问冲突。这个全部为0的地址就是给一级指针初始化时设的NULL值(空指针，就是值为 0 的指针,任何程序数据都不会存储在地址为 0 的内存块中，它是被操作系统预留的内存块)

?

#include <iostream>

using namespace std;

void swap(int* a, int* b,int *c) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
	int d = *a + *b;
	c = &d;

}

void boy(int** meipo) {
	static int boy = 22;

	*meipo = &boy;
}
int main(void) {
	
	int a = 8;
	int b = 3;
	int* c = NULL;
	swap(&a, &b, c);
	cout << "一级指针传入之后c的值:"<<endl;
	int* type = NULL;
	boy(&type);
	cout << "通过二级指针带回来的值:" << *type << endl;
	return 0;
}

通过程序调用可以看出给二级指针传入地址值后,二级指针可以通过一级指针把函数内部的变量地址值给带回来

多级指针的定义和使用

#include <iostream>


using namespace std;
int main(void) {

	int massage = 888;
	int* guizi1 = &massage;
	int** guizi2 = &guizi1;
	int*** guizi3 = &guizi2;
	int**** guizi4 = &guizi3;
	int***** guizi5 = &guizi4;

	cout << "massage的地址" << &massage << endl;
	cout << "guizi1内的地址" << guizi1 << endl;
	cout << "guizi2内的地址" << *guizi2 << endl;
	cout << "guizi3内的地址" << **guizi3 << endl;
	cout << "guizi4内的地址" << ***guizi4 << endl;
	cout << "guizi5内的地址" << ****guizi5 << endl;

	cout << "guizi1内的值" << *guizi1 << endl;
	cout << "guizi2内的值" << **guizi2 << endl;
	cout << "guizi3内的值" << ***guizi3 << endl;
	cout << "guizi4内的值" << ****guizi4 << endl;
	cout << "guizi5内的值" << *****guizi5 << endl;
	return 0;
}

指针和数组之间的关系

#include <iostream>


using namespace std;

void print_1(int days[], int len) {
	for (int i = 0; i < len; i++) {
		//用数组的方式输出
		cout << "用数组的方式输出:" << days[i] << " ";
		//用指针的形式输出
		cout << "用指针的方式输出:" << *(days + i);
		cout << endl;
	}
}
void print_2(int* day, int len) {
	for (int i = 0; i < len; i++) {
		//用数组的方式输出
		cout << "用数组的方式输出:" << day[i] << " ";
		//用指针的形式输出
		cout << "用指针的方式输出:" << *(day + i);
		cout << endl;
	}
}
int main(void) {
	int days[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
	int* day = NULL;
	int len = sizeof(days) / sizeof(int);
	day = days;
	//for (int i = 0; i < len; i++){
	//	//用数组的方式输出
	//	cout << "用数组的方式输出:" << days[i] <<" ";
	//	//用指针的形式输出
	//	cout << "用指针的方式输出:" << *(day + i);
	//	cout << endl;
	//}
	//当传入参数是数组时
	cout << "当传入参数是数组时:" << endl;
	print_1(days, len);
	cout << "当传入参数是指针时:" << endl;
	print_2(day, len);
	return 0;
}

存储指针的数组(指针数组:保存地址值)

定义： 类型 *指针数组名[元素个数] ；如:int *p[2]

定义一个有n个元素个数指针数组，每个元素都是一个指针变量

指针数组是先有地址值,然后再通过地址值,指针数组本质可以理解为不是一个指针而是一个只保存地址的数组,在操作指针数组时,这个指针数组是先保存有这个对象的地址(并不是指向这个对象),然后可以通过地址访问这个对象的值

#include <iostream>


using namespace std;

int main(void) {
	int days[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
	int len = sizeof(days) / sizeof(int);

	int* p[1];//代表这个指针数组内,有一个指针变量
	p[0] = days;

	for (int i = 0; i < len; i++){
		if (*p[0] > days[i]) {
			p[0] = &days[i];
		}
	}
	cout << *p[0] << endl;
	return 0;
}

指向数组的指针(数组指针)

1. 指向数组的指针

int (*p)[3]; //定义一个指向三个成员的数组的指针,数组指针的个数,和数组的列数是对应的

访问元素的两种方式：

数组法： (*p)[j]

指针法： *((*p)+j)

#include <iostream>


using namespace std;

int main(void) {
	int days[4][3] = {31,28,31,30,31,30,31,31,30,31,30,31};

	//几维的数据就将元素设为几个元素的指针
	int (*p)[3];//定义一个指针数组,指向4个元素的的数组的指针

	int* little = NULL;
	//使用数组型的指针型数组访问
	p = &days[0];
	for (int i = 0; i < 4; i++){
		for (int j = 0; j < 3; j++){
			cout << (*p)[j] << " ";
		}
		p++;
	}

	cout << endl;

	//使用指针型的指针数组访问
	p = &days[0];
	little = &(*p)[0];

	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 3; j++) {
			if (*little > *((*p) + j)) {
				little = (*p) + j;
			}
		}
        p++;
	}
	cout << *little << endl;
	return 0;
}

传参的形式(指针)

数组传参时会退化为指针

1）退化的意义：C 语言只会以值拷贝的方式传递参数，参数传递时，如果拷贝整个数组，效率会大大降低，并且参数将位于栈上，太大的数组拷贝将会导致栈溢出。

2）因此，C 语言将数组的传参进行了退化。将整个数组拷贝一份传入函数时，将数组名看做常量指针，传数组首元素的地址。(这样参数在进行赋值时,就会和这个数组共用同一个内存空间)

#include <iostream>


using namespace std;
//方法1
void method_1(int days[12]) {
	for (int i = 0; i < 12; i++){
		cout << days[i] << " ";
	}
}
//方法2
void method_2(int days[], int len) {
	for (int i = 0; i < len; i++) {
		cout << days[i] << " ";
	}
}
//方法3
void method_3(int* array, int len) {
	for (int i = 0; i < len; i++) {
		cout << *(array+i) << " ";
	}
}
//方法4
void method_4(int* arr[]) {
	for (int i = 0; i < 12; i++) {
		cout << *arr[i] << " ";
	}
}
//方法5
void method_5(int* arr[], int len) {
	for (int i = 0; i < len; i++) {
		cout << *arr[i] << " ";
	}
}
//方法6
void method_6(int** arr, int len) {
	for (int i = 0; i < len; i++) {
		cout << *arr[i] << " ";
	}
}
//方法7
void method_7(int(*k)[12]) {
	for (int i = 0; i < 12; i++) {
		cout << *(*k+i) << " ";
	}
}
int main(void) {
	//数组作为参数传递,输出数组的6种方式

	int days[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
	int len = sizeof(days) / sizeof(int);

	//方法一;
	cout << "方法一:将数组作为形参参接收数组:" << endl;

	method_1(days);
	cout << endl;
	cout << "方法二:将数组作为形参参接收数组,并指定数组的元素个数:" << endl;

	method_2(days, len);
	cout << endl;
	cout << "方法三:使用指针作为形参接受数组,并指定数组的元素个数:" << endl;

	method_3(days, len);
	cout << endl;
	cout << "方法四:使用指针数组作为形参:" << endl;
	//先为指针数组内的元素赋值
	int* day[12] = {0};//初始化,指针数组时先作为一个数组
	for (int i = 0; i < len; i++){
		day[i] = &days[i];
	}
	method_4(day);
	cout << endl;
	cout << "方法五:使用指针数组作为形参,并指定数组的元素个数:" << endl;
	method_5(day, len);
	cout << endl;
	cout << "方法六:使用二级指针作为形参,并指定数组的元素个数:" << endl;
	method_6(day, len);
	cout << endl;
	int(*k)[12];
	k = &days;
	cout << "方法七:使用数组指针作为形参接受数组:" << endl;
	method_7(k);
	return 0;
}

?void类型的指针

void => 空类型

void* => 空类型指针，只存储地址的值，丢失类型，无法访问，要访问其值，我们必须对这个指 针做出正确的类型转换(其他类型赋值给void指针,会自动转,void的指针赋值给其他类型则需要强制转换)，然后再间接引用指针。

void*类型的指针是无法进行算数运算的,同样无法访问(E0852?? ?表达式必须是指向完整对象类型的指针)

#include <iostream>


using namespace std;

int main(void) {
	int a = 10;
	int* p = &a;
	void* p1 = &a;
	void* p2 = p; //其他类型的指针赋值给void类型的指针自动转换
	p++;//有具体类型的指针可以算术运算
	//p1++;//错误
	int* p3 = (int*)p1;//void类型的指针赋值给其他类型的指针需要进行强制转换

	//cout << *p1 << endl;//E0852:表达式必须是指向完整对象类型的指针
	cout << p1 << endl;//可以输出他的地址值
	cout << p2 << endl;
	cout << *p3 << endl;
	return 0;
}

函数指针

函数指针简单理解就是把整个函数当做一个指针

定义:

把函数声明移过来，把函数名改成 (* 函数指针名)

例如:

定义一个函数为:int man(const void *a,const void *b){}

函数的指针定义为:int (*p)(const void *a ,const void *b);????????

最后将函数的地址赋值给指针:p = &man;

调用:
两种方式:(*指针名)(参数地址)? 或者? 指针名(参数地址)

例如上述:(*p)(&a,&b); 或者 p(&a,&b);

#include <iostream>


using namespace std;
int compare( void* a, void* b) {
	int* x = (int*)a;
	int* y = (int*)b;

	return *x - *y;

}

int main(void) {
	int arr[] = { 2, 10, 30, 1, 11, 8, 7,25 };
	int len = sizeof(arr) / sizeof(int);
	
	int (*p)( void* a, void* b);
	p = &compare;
	cout << arr[0]  << " " << arr[1] << endl;
	

	cout << p(&arr[0], &arr[1]) << endl;
	return 0;
}

应用:

使用VS自带的快速排序函数,来调用自定函数进行排序

#include <iostream>


using namespace std;
int compare(const void* a,const void* b) {
	int *x = (int*)a;
	int *y = (int*)b;

	return *x - *y;//小于0,升序排序,
}

int main(void) {
	int arr[] = { 2, 10, 30, 1, 11, 8, 7,25 };
	int len = sizeof(arr) / sizeof(int);
	cout << "排序前:" << endl;
	for (int  i = 0; i < len; i++){
		cout << arr[i] << " ";
	}
	int (*p)(const void* a,const void* b);
	p = &compare;
	//这里qsort函数的第四个参数需要的函数参数类型为const类型的指针
	qsort(arr, len, sizeof(int), p);
	cout << endl;//这个作用是换行
	cout <<"排序后:" << endl;
	for (int i = 0; i < len; i++) {
		cout << arr[i] << " ";
	}

	return 0;
}