C语言进阶之旅 （11.5）指针下 提升篇

Posted 2021-06-22 一个正直的男孩

文章目录

• 题1
• 题2（函数传参数）
• • 一维数组
  • 二维数组传参
• 题3 计算器（函数数组指针）
• 题4 回调函数（qsort）
• 题 5
• • 1
  • • 解读
  • 2
  • • 解读
  • 3
  • 4
  • 5
• 题 6
• 题 7
• 题8
• 题9
• 题 10
• 题 11
• 题12
• 总结

题1

• 判断字符串是否相等
• 易错点，内存如何存储常量字符串

#include <stdio.h>
int main() {
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    char *str3 = "hello bit.";
    char *str4 = "hello bit.";
    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;
}

图解：

运行结果：

题2（函数传参数）

一维数组

• 这里的易错点，搞清楚传的是啥，用啥可以接收
• 解释写在代码里

#include <stdio.h>
void test(int arr[])//ok?
{}//数组传数组接收，没毛病
void test(int arr[10])//ok?
{}//这里也是数组，没毛病，可写可不写，
void test(int *arr)//ok?
{}//数组名就是首元素地址，指针接收也没毛病
void test2(int *arr[20])//ok?
{}//数组指针，每个元素都是指针，用数组指针接收也没毛病
void test2(int **arr)//ok?
{}//传过来是元素地址，里面每个元素都是指针，那么二级指针接收似乎也没毛病
int main()
{
    int arr[10] = {0};
    int *arr2[20] = {0};
    test(arr);
    test2(arr2);
}

二维数组传参

void test(int arr[3][5])//ok? 
{}//二维数组传，二维数组接收，perfect
void test(int arr[][])//ok? 
{}//err省行不剩列
void test(int arr[][5])
{}//这个就没问题
void test (int *arr)
{}//err，二维数组指针，你用指针怎么存的下
void test (int *arr[5])
{}//*先和方括号结合了他是数组指针，每个元素是int*
void test(int (*arr)[5])//ok?
 {}//指针数组接收没毛病，
void test(int **arr)//ok?
{}//err，传过来的参数就不是二级指针咋他怎么接收？

int main()
 {
    int arr[3][5] = {0};
    test(arr); 
}

题3 计算器（函数数组指针）

• 该计算器（只有加减乘除的供能，只能操作俩个操作数）
• 具体思路
• 1：应为操作数都是一样，返回类型也是一样的，把地址给指针，然后存到数组里面方便调用
• 然后利用input输入的值进行对函数的调用
  

代码

#include<stdio.h>
void menu()
{
	printf("##################################\\n");
	printf("###1:加 2:减 3:乘 4:除 0:退出#####\\n");
	printf("##################################\\n");

}
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 input = 0;
	
	int ret = 0;
	int x=0;
	int y = 0;
	do
	{
		int(*parr[5])(int, int) = { 0,Add,Sub,Mul,Div };
		menu();
		printf("选择");
		scanf("%d", &input);
		if (input >= 1 && input<=4)
		{
			printf("输入俩个操作数:<");
			scanf("%d%d", &x, &y);
			ret = parr[input](x, y);
			printf("%d\\n", ret);
		}
		else if(input<0||input>4)
		{
			printf("请带上眼镜看选项\\n");
		}
		else
		{
			printf("退出");
			break;
		}
	} while (input);
	
}

图解：函数数组内部

精髓所在就在这里哈哈哈

题4 回调函数（qsort）

• 在冒泡排序基础上排序

冒泡排序：
正序排序
这个是基础算发：
第一个元素小于第二就交换，然后依次后面的比知道正序为止
元素个数有多少个就排序多少次
类似爬那种金字塔类似，下面比较宽就需要多走一些，上面越来窄，走的也少

---

• 那么看看他如何实现的
• 末尾有详细大致介绍
• sqr他里面有三个4个参数
• 1:void* base 指针类型，他不知道你要排序啥类型的数组
• 2:sizet num数组有多少个元素
• 3:sizet size 每个元素是多大
• 4:int (*compar)(const void* 1,const void* 2); //该函数的精髓之一，直接传入第一第二的元素相减，如果大0，那么就交换，小于则不交换，如果等于也不交换
• 这里就是回调函数了，我这个函数的结果会影响qsort函数

#include<stdio.h>

//该函数的在冒泡函数基础上进行
//
//
int comp(void*p1,void*p2)
{
	return *(int*)p1 - *(int*)p2;
}
void swap(char*a,char*b,int typ)
{
	//这里你不知道他是啥类型的，所以直接一个字节一个字节的交换，交换到那个类型的长度
	int i = 0;
	for ( i = 0; i < typ; i++)
	{
		int tmp = *a;
		*a = *b;
		*b = tmp;//err
		a++;
		b++;
	}
}
void bubble(void *basr,//指针
	         int sz,//元素个数
	         int typ,//元素类型
	         int (*comp)(const void*,const void*))
{
	int i = 0;

	for ( i = 0; i < sz-1; i++)
	{
		int j = 0;
		for ( j = 0; j < sz-1-i; j++)
		{
			//这里吗也不知道你啥类型的用char，他可以访问最少的字节，然后+上他那个类型，他就等于那个类型了
			
			if (comp((char*)basr + j * typ , (char*)basr+(j + 1) * typ) > 0)
			{
			     //交换
				swap((char*)basr + j * typ, (char*)basr + (j + 1) * typ, typ);
			}
		}
	}
}
int main()
{

	int arr[] = { 9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	bubble(arr,sz,sizeof(arr[0]),comp);
	//打印
	int i = 0;
	for ( i = 0; i < sz-1; i++)
	{
		printf("%d", arr[i]);
	}
}

解析这个代码：

题 5

1

1. 解释在代码后面
2. 数组在&地址或sizof内部的时候是整个数组，别的时候是数组名

int a[] = { 1,2,3,4 };
	printf("%d\\n", sizeof(a));
	printf("%d\\n", sizeof(a + 0));
	printf("%d\\n", sizeof(*a));
	printf("%d\\n", sizeof(a + 1));
	printf("%d\\n", sizeof(a[1]));
	printf("%d\\n", sizeof(&a)); 
	printf("%d\\n", sizeof(* &a));
	printf("%d\\n", sizeof(&a + 1));
	printf("%d\\n", sizeof(&a[0]));
	printf("%d\\n", sizeof(&a[0] + 1));//这里首元素地址加1arr[1] 也是地址 4/8

解读

• printf("%d\\n", sizeof(a));
  16—>数组单独放在sizeof里面

• printf("%d\\n", sizeof(a + 0));
• printf("%d\\n", sizeof(a + 1));
  4/8---->他先加了后面的0/1，那么就是数组名，就是地址

• printf("%d\\n", sizeof(*a));
  4—>首元素里面的元素的类型

• printf("%d\\n", sizeof(a[1]))
  4—>算的是数组第二个元素的类型

• printf("%d\\n", strlen(&arr));
  4/8—>&arr就是地址吗

• printf("%d\\n", sizeof(* &a));
  16---->计算整个数组的元素类型

• printf("%d\\n", sizeof(&a + 1));
  4/8—>整个数组地址加一，还是地址

• printf("%d\\n", sizeof(&a[0]));
  4/8—>首元素地址

• printf("%d\\n", sizeof(&a[0] + 1));
  4/8—>第二个元素的地址

解析这条代码的能从布局

printf("%d\\n", sizeof(&a + 1))
好丑哈哈哈

2

• strlen 结束标志是\\0
• 接收的参数是const char *
• 模拟实现strlen

	字符数组
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\\n", strlen(arr));
	printf("%d\\n", strlen(arr + 0));
	printf("%d\\n", strlen(*arr));
	printf("%d\\n", strlen(arr[1]));
	printf("%d\\n", strlen(&arr));
	printf("%d\\n", strlen(&arr + 1));
	printf("%d\\n", strlen(&arr[0] + 1));

	
	printf("%d\\n", sizeof(arr));
	printf("%d\\n", sizeof(arr + 0));
	printf("%d\\n", sizeof(*arr));
	printf("%d\\n", sizeof(arr[1]));
	printf("%d\\n", sizeof(&arr));
	printf("%d\\n", sizeof(&arr + 1));
	printf("%d\\n", sizeof(&arr[0] + 1));

解读

• printf("%d\\n", strlen(arr));
  随机值—>这里没有\\0

• printf("%d\\n", strlen(arr + 0))
  随机值—>这里没有\\0，

• printf("%d\\n", strlen(*arr));
  err --> strlen接收是char *，你着指针数组过来凑啥热闹,类型不匹配

• printf("%d\\n", strlen(arr[1]));
  err —>同样类型不匹配，砸场子

• printf("%d\\n", strlen(&arr));
  随机值—>&arr和a地址一样，不过意义不一样，但是strlen把他直接看成首元素地址

• printf("%d\\n", strlen(&arr + 1));
  随机值—>首元素加了一个数组的元素的个数

• printf("%d\\n", strlen(&arr[0] + 1));
  随机值—>首元素加了一个元素个数

• printf("%d\\n", sizeof(&arr));
  4/8. —>取地址，那么它就是地址

---

• printf("%d\\n", sizeof(arr));
  6–>计算元素个数

• printf("%d\\n", sizeof(arr + 0));
  4/8 —>他先和后面的0加，那么就是地址

• printf("%d\\n", sizeof(*arr));
  1 —>解引用找到首元素的地址

• printf("%d\\n", sizeof(arr[1]));
  1—>先和[]结合是数组，里面是第二个元素

• printf("%d\\n", sizeof(&arr + 1));
  4/8---->地址加1还是地址

• printf("%d\\n", sizeof(&arr[0] + 1));//地址4/8
  4/8 ---->取出数组手元素的地址加1还是地址

char arr的内存

3

• 字符串末尾是\\0
• 这儿就在解读了

	char arr[] = "abcdef";
	
	printf("%d\\n", strlen(arr));//6
	
	printf("%d\\n", strlen(arr + 0));//6
	
	printf("%d\\n", strlen(*arr));//err
	
	printf("%d\\n", strlen(arr[1]));//err
	
	printf("%d\\n", strlen(&arr));//6
	
	printf("%d\\n", strlen(&arr + 1));//随机值，加了一个数组的元素个数
	
	printf("%d\\n", strlen(&arr[0] + 1));//5，首元素地址加1



 
	printf("%d\\n", sizeof(arr));//7,sizeof会算\\0
	
	printf("%d\\n", sizeof(arr + 0));//7
	
	printf("%d\\n", sizeof(*arr));//1, 首元素地址的内容
	
	printf("%d\\n", sizeof(arr[1]));//1
	
	printf("%d\\n", sizeof(&arr));//取地址 指针4/8
	
	printf("%d\\n", sizeof(&arr + 1));//取地址加1 4/8
	
	printf("%d\\n", sizeof(&arr[0] + 1));//首元素地址加1 4/8

4

• p指向的是a的地址，abcdef是常量字符串不可更该

char* p = "abcdef";

	printf("%d\\n", strlen(p));//6
	
	printf("%d\\n", strlen(p + 1));//5
	
	printf("%d\\n", strlen(*p));//err
		
	printf("%d\\n", strlen(p[0]))我的C语言学习进阶之旅解决 Visual Studio 2019 报错：错误 C4996 ‘fscanf‘: This function or variable may be unsafe.(代码片段

 我的C语言学习进阶之旅解决 Visual Studio 2019 报错：错误 C4996 ‘fscanf‘: This function or variable may be unsafe.(代码片段
 C语言进阶之旅 新老朋友指针
 C语言进阶学习笔记二指针的进阶（练习篇）
 C语言进阶之旅（留下的足迹）
 C语言进阶之旅（留下的足迹）