C语言指针二

指针二

1. 数组名深入理解

数组名就是数组⾸元素(第⼀个元素)的地 址。 &arr[0] = arr; 但是有两个例外:

• sizeof(数组名) ,这里的sizeof()中放的数组名代表整个数组,计算的是整个数组的大小,单位是字节
• &数组名, 这里的数组名代表整个数组,取出的是整个数组的地址

int main() {

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

	return 0;
}

我们发现&arr[0]和&arr[0]+1相差了四个字节,arr与arr+1也相差了四个字节,是因为&arr[0] 和 arr 都是 ⾸元素的地址,+1就是跳过⼀个元素,一个int 四个字节.

&arr 和 &arr+1相差40个字节，这就是因为&arr是数组的地址，+1 操作是跳过整个数组的。

2. 使用指针访问数组

使用指针完成对数组的输入输出

#include <stdio.h>
int main()
{
 int arr[10] = {0};
 //输⼊
 int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //输⼊
 int* p = arr;
 for(i=0; i<sz; i++)
 {
 scanf("%d", p+i);//p+i == &arr[i]
 //scanf("%d", arr+i);//也可以这样写
 }
 //输出
 for(i=0; i<sz; i++)
 {
 printf("%d ", *(p+i));//p[i]也可以
     //扩展跟多写法   *(p+i) = *(i+p)
     //            arr[i]的实质就是  变为*(arr+i) 所以i[arr]也可以
 }
 return 0;
}

​ **** arr[i] == *(arr+i) *(p+i) == p[i]

3. 一维数组传参的本质

在使用函数打印数组时,会将数组传给函数,而且也会用到数组中元素的个数,我们一般在主函数中求出然后传给打印函数,如果再打印函数内部求会有变化吗

#include<stdio.h>

void Print_arr(int arr[]) {  // 形参访问的数组和实参是同一个数组 
    //形参的数组是不会再单独创建空间的,所以形参的数组是可以省略数组大小的
	int sz2 = sizeof(arr) / sizeof(arr[0]);
	printf("sz2 = %d\n", sz2);
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz1 = sizeof(arr) / sizeof(arr[0]);
	printf("sz1 = %d\n", sz1);
	Print_arr(arr);
	return 0;
}

结果却发生了变化,在函数内部没有获得正确的元素个数. 因为我们在调用函数时传给的是数组名即首元素的地址,所以函数形参应该使用一个同类型的指针变量接受这个地址. 在函数内部 使用sizeof(arr)计算的是一个地址的大小(单位字节)是因为函 数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

void Print_arr(int* arr)//参数写成指针形式
{
 printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}

⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

4.冒泡排序

核心思想: 两两相邻的元素比较

#include<stdio.h>


void bouble_sort(int arr[], int sz) {
	
	int i = 0;
	for (i = 0; i < sz - 1; i++)//最外层循环,一次冒泡确定一个数的位置,故总共需要总数减一次排序
	{
		int j = 0; 
		for (j = 0; j <sz-1-i ; j++)//内层循环 每次比较相邻两个数,第一次比较总数减一组,第二次比较总数减二次,以此类推
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j+1] = tmp;
			}
		}
	}

}


void print_sorted(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main() {

	int arr[] = {9 ,7,8,6,5,4,3,2,1,0};
	int sz = sizeof(arr) / sizeof(arr[0]);

	bouble_sort(arr,sz);
	print_sorted(arr, sz);
	return 0;
}

从代码上可以看出循环次数是固定死的,就算第一次排序完成了降序或升序的任务,依然会继续循环,这样对一些接近降序或升序的数组进行冒泡排序就有点浪费时间啦,所以现在对代码优化一下解决这个问题

较于上面的代码多了一个flag

#include<stdio.h>


void bouble_sort(int arr[], int sz) {
	
	int i = 0;
	for (i = 0; i < sz - 1; i++)//最外层循环,一次冒泡确定一个数的位置,故总共需要总数减一次排序
	{
		//假设已经有序
		int flag = 1;
		int j = 0; 
		for (j = 0; j <sz-1-i ; j++)//内层循环 每次比较相邻两个数,第一次比较总数减一组,第二次比较总数减二次,以此类推
		{
			if (arr[j] > arr[j + 1])
			{
				flag = 0;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j+1] = tmp;
				//只要进入这个if 判断肯定不是有训的
				
			}
		}
		if (flag == 1)
		{
			break;
		}
	}

}


void print_sorted(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main() {

	int arr[] = {9,1,0,2,3,4,5,6,7,8};
	int sz = sizeof(arr) / sizeof(arr[0]);

	bouble_sort(arr,sz);
	print_sorted(arr, sz);
	return 0;
}

5.二级指针

存放指针变量的地址就是二级指针

#include<stdio.h>

int main()
{	
	int a = 666;
	int * p = &a;  // int说明p指向的是int型 *说明p是指针变量
	int * * p = &p;// int* 说明pp指向的是int * 类型   * 说明pp是指针变量

	return 0;
}

6.指针数组

整型数组，是存放整型的数组，字符数组是存放字符的数组,所以指针数组就是存放指针的数组

指针数组的每个元素都是地址,又可以指向一块区域

指针数组模拟二维数组

#include<stdio.h>

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 7,4,5,6,7 };

	int* arr[] = { arr1,arr2,arr3 };

	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}



	return 0;
}

---

===========================================================

7. 指针变量

1.字符指针变量

我们一般使用 char*

int main()
{
 char* pstr = "hello world.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗？
 printf("%s\n", pstr);
 return 0;
}

其本质是吧hello world 的首字符的地址放在了pstr中
但是这个字符串不能被修改,所以要换一种写法才更规范

const char * pstr = "hello world";

综合案例

#include <stdio.h>
int main()
{
	char str1[] = "hello woeld.";
	char str2[] = "hello world.";
	const char* str3 = "hello world.";
	const char* str4 = "hello world.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");

	return 0;
}

str1 和str2 是两个存了相同内容的数组, 地址不相同 str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域， 当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始 化不同的数组的时候就会开辟出不同的内存块。

2.数组指针变量

第六小节学习的是指针数组, 它是一种数组, 数组中存放的是指针。所以数组指针变量是一种指针变量

int *p1[10];   // p1是一个指针数组
int (*p2)[10]; //(*p2说明p2是一个指针变量,接着指向一个大小为10的整型数组,所以p2是个数组指针)  ：[]的优先级要⾼于*号的，所以必须加上（）来保证p先和*结合。

数组指针变量来存放数组地址

int arr[10]  = {0};
int (*p)[10] = &arr;//[]中的数字必须与指向的数组一样
//&arr 与p的类型是一样的

8.二维数组传参的本质

写一个打印二维数组的函数

#include<stdio.h>

void Print(int arr[][5],int r,int c)
{
	int i,j =0;
	for(i = 0;i<r;i++)
	{
		for(j = 0;j<c;j++)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[][5] = {{0,1,2,3,4},{1,2,3,4,5},{5,4,3,2,1}};
	Print(arr,3,5);  //实参是二维数组,形参也是二维数组
	
	return 0;
}

我们再传参的时候实参使用的是二维数组的数组名,也是数组首元素的地址,即一维数组的地址
类型为 int (*)[5] 所以二维数组传参本质上也是传递了地址,传递的是二维数组第一行以为数组的地址 所以形参可以写成指针的形式

void Print(int(*p)[5],int r,int c)
{
	int i,j =0;
	for(i = 0;i<r;i++)
	{
		for(j = 0;j<c;j++)
		{
			printf("%d ",*(*(p+i)+j));
			//arr[i]的实质就是  变为*(arr+i)
             // *(p+i) 就是 p[i] ==arr[i]
             // *(*(p+i)+j) p[i][j] == arr[i][j]
			
		}
		printf("\n");
	}
}

⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式

9.函数指针变量

数组指针—指针—指向数组的—存放的是数组的地址

函数指针—指针----指向函数的，存放的是函数的地址

int Fuc(int x)
{
	return x;
}

int main()
{
	printf(" Fuc   =    %p \n",Fuc);
	printf("&Fuc   =    %p \n",Fuc);
	return 0;
}

函数名就是函数的地址，也可以通过 &函数名 的⽅ 式获得函数的地址。

函数指针的写法

int (*pf) (int) = &Fuc;
 |     |    |
 |     |    |
 |	   |    指针变量指向函数参数类型（几个参数写几个）
 |     指针变量名
 指针变量指向函数的返回类型

函数指针变量的使用

#include<stdio.h>
int Fuc(int x)
{
	return x;
}

int main()
{
	int (*pf)(int) = &Fuc;

	int ret1 = Fuc(5);//也可以写为pf(5)
	printf("%d\n",ret1);
	
	int ret2 = (*pf)(666);//pf存放函数地址  *pf 对pf解引用
	printf("%d \n",ret2);

	return 0;
}

( * ( void (*)() ) 0 )();
//void(*)() 是一个函数指针类型
//( void(*)() ) 强制着类型转换
//  ( void(*)() 0) 将0强制类型转换成 void(*)()的函数指针类型
// 也就是说我们在 0地址处放着一个 没有参数，返回类型是void的函数
//最后是调用这个0地址出的函数
//这个代码是无法运行的，因为我们无法访问0地址

void (*signal(int , void(*)(int)))(int);
// signal(int , void(*)(int)) 是一个函数即他的两个参数
//void(* )(int)  函数的返回值类型
// 相当于 void(*)(int) signal(int , void(*)(int)) 但是不能这样写

想要简化上面这行代码可以用到 typedef关键字

typedef 是用来类型重命名的，可以将复杂的类型简单化

typedef int* ptr_t;//将int* 重命名为ptr_t

typedef int(*parr_t)[5];// 将数组指针类型 int(*)[5] 重命名为parr_t
						// 新类型名 必须在*的右边
						
typedef void(*pf_t)(int)//pf_t就是 void(*)(int)

//简化void (*signal(int , void(*)(int)))(int);

typedef void(*pf_t)(int);
pf_t signal(int,pf_t);

10.函数指针数组

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}


int main()
{
	int (*p_add)(int,int) = Add; //p_add是函数指针数组

	int (*pf_arr[])(int, int) = {Add, Sub, Mul, Div};  //pf_arr就是一个函数指针数组
														//必须是同类型的才能组成一个函数指针数组

	//   函数指针的使用
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = pf_arr[i](5,12);
		printf("%d \n",ret);
	}

	return 0;
}

0.函数指针数组

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}


int main()
{
	int (*p_add)(int,int) = Add; //p_add是函数指针数组

	int (*pf_arr[])(int, int) = {Add, Sub, Mul, Div};  //pf_arr就是一个函数指针数组
														//必须是同类型的才能组成一个函数指针数组

	//   函数指针的使用
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = pf_arr[i](5,12);
		printf("%d \n",ret);
	}

	return 0;
}