C语言学习笔记---指针（3）

目录

用assert语句来完成指针的有效性

指针的使用和传址调用

数组名的理解

一维数组传参的本质

冒泡排序

---

在使用空指针之前要检测指针的有效性！！！

用assert语句来完成指针的有效性

#define NDEBUG//调试完之后关闭assert,这条声明一定要放在assert的头文件上面
//注意：在release版本下，assert也会自动被屏蔽掉
//在debug版本中不影响程序员排查问题，在release版本不影响用户使用时程序的效率
#include<assert.h>//assert的头文件

int main()
{
	int a = 10;
	int* p = &a;
	//...
	//...
	p = NULL;
	//...
	//...
	//if (p != NULL)//也可以用assert来做
	//{

	//}
	assert(p != NULL);//一旦结果为假，编译器就报错，说明p不是个空指针，就不能用
	//assert断言要用头文件
	printf("%d\n", *p);
	
	return 0;
}

//assert：⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为“断⾔”
//例如：
//int b=20;
//assert(b==5);//程序报错

指针的使用和传址调用

//函数的调用：
//传址调用---对应---传值调用

//strlen的模拟实现
//传址例子,比如：

#include<string.h>//strlen的头文件

size_t my_strlen(const char* s)//const表示不希望通过s接收的arr的地址来改变里面的内容（也就是数组里面的值或者字符串）；
{
	size_t count=0;
	//*s='w';//程序会报错，因为上面写了const不允许修改
	//还可以先判断一些传过来的s是否为空指针
	assert(s != NULL);//空指针的话就报错
	while (*s != '\0')
	{
		count++;
		s++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdef\0";//记住：数组名存的是第一个字符串的地址
	size_t len = my_strlen(arr);//size_t=unsigned int
	//复习一下typedef重命名，typedef unsigned int size_t;
	printf("%zd\n", len);//unsigned int的占位符是%zd
	return 0;
}

//有些问题必须要用传址来解决问题！
//因为传值调用函数时，函数的实参传给形参时，形参是实参的一份临时拷贝！
//形参有自己独立的空间，对形参的修改不会影响实参

//比如以下这个例子就是没有用传址来解决问题的后果

void swap(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}

int main()
{
	int a = 10;
	int b = 20;
	printf("交换前：%d %d\n", a, b);
	swap(a, b);
	printf("交换后：%d %d\n", a, b);//打印结果和交换前一样
	return 0;
}

//以上用指针来解决

void swap(int*pa,int*pb)
{
	int z = 0;
	z = *pa;
	*pa = *pb;
	*pb = z;
}

int main()
{
	int a = 10;
	int b = 20;
	printf("交换前：%d %d\n", a, b);
	swap(&a, &b);//
	printf("交换后：%d %d\n", a, b);//打印结果和交换前一样
	return 0;
}

//传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量；
//所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采⽤传值调⽤。
//如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。
//总结，要通过函数来改变主函数中的某个变量时就可以考虑传址调用。

数组名的理解

//之前讲过数组名就是首元素的地址
//如果真是这样的话，用sizeof（arr)来计算数组首元素的字节长度的话，应该输出的是4才对，因为一个整型是4个字节，首元素的地址里面的内容是一个整型元素
//但是用sizeof计算出来的40

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n", sizeof(arr));
	printf("%d\n", &arr[0]);//地址类型：int*
	printf("%d\n", &arr[0]+1);//+4

	printf("%d\n", arr);//地址类型：int*
	printf("%d\n", arr+1);//+4

	printf("%d\n", &arr);//地址类型：？；整个数组的地址也是从首元素的地址开始的
	printf("%d\n", &arr+1);//+0x28,就是涨了40个字节，10个元素的类型大小，因为它其实取出来的是整个数组的地址

	return 0;

}

//注：要记住，虽然数组名存放的是首元素的地址，但是有两个例外：
//1.sizeof(数组名)，sizeof内部单独放一个数组名的时候，数组名表示整个数组，计算的是整个数组的大小，单位是字节
//2.&数组名，&数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）
//除此之外，遇到的所有数组名都是数组首元素的地址

//因为数组在内存中是连续存放的
//数组名就是首元素的地址（方便找到起始位置）
//可以使用指针来访问数组！

int main()
{
	int arr[10] = {0};
	int i = 0;
	int sz = sizeof(arr) / sizeof(int);
	int* p = arr;
	//p==arr
	for (i = 0; i < sz; i++)
	{
		//scanf("%d", &arr[i]);
		//scanf("%d", arr + i);
		scanf("%d", p + i);

	}
	for (i = 0; i < sz; i++)
	{
		//printf("%d ", arr[i]);
		//printf("%d ", arr + i);
		printf("%d ", *(p + i));
		//arr[i]==*(arr+i);
		//p[i]==*(p+i);
		//*(i + arr) == i[arr];//这样写也是可以的，满足加法交换律，但是不建议这样的写法
	     //因为[]只是个操作符而已，是下标引用操作符
	}
	return 0;
}

一维数组传参的本质

void test(int arr[])//也可以写成int*arr本质是一样的
//方块内没有填数组的大小，其实数组传过去的时候形参并没有创建新的数组
//因为传过去的是首元素的地址，虽然形参写的是数组，本质还是指针
{
	int sz = sizeof(arr)/ sizeof(arr[0]);
	printf("%d\n", sz);//1
}

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

}

int main()
{
	//数组传参的时候，传递的并非是数组
	//传递的是数组首元素的地址！！！！！
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	test(arr);//这里的数组名就是数组首元素的地址
	int sz= sizeof(arr) / sizeof(int);//再数组传参之前就要计算好数组的大小一起传过去
	print(arr,sz);
	return 0;
}

冒泡排序

//思想：相邻的两个元素比较，如果不满足顺序就交换

int count = 0;//计算总的比较次数

void Bubblesort(int* arr, int sz)
{
	int i = 0;//控制趟数，10个元素，总共比较9次，9个元素，总共比较8次，所以趟数就是sz-1
	for (i = 0; i < sz-1; i++)
	{
		int flag = 1;//假设已经有序
		//一趟冒泡排序的过程
		int j = 0;//控制比较的对数，第一个元素比较了9次，第二个元素比较了8次，第三个元素比较了7次，所以第j个元素比较了sz-1-i次
		for (j = 0; j < sz - 1 - i; j++)
		{
			count++;
			if (arr[j] >arr[j + 1])
			{
				//每当前一个数小于后面一个数，就进行交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;//一旦进行过一次交换，就把flag置零
			}
		}
		if (flag == 1)
		{
			break;//如果第一趟比较结束之后flag依然是1,那么说明数组里面的元素本来就是有序的，
			//为了提升代码的效率，不要继续进行比较下去，可以提前跳出循环比较
		}
	}
}

int main()
{
	int arr[10] = { 9,0,1,2,3,4,5,6,7,8 };
	int sz = sizeof(arr) / sizeof(int);
	//创建一个函数完成升序排列操作
	Bubblesort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++)//注意：排序完成后依次打印时，i是小于sz
	{
		printf("%d ", arr[i]);
	}
	printf("\ncount=%d\n", count);
	return 0;
}

预知后事如何，请听下回分解......