【C语言】指针进阶（知识满满多图便于理解）

已于 2022-07-25 18:04:47 修改
阅读量227 收藏
点赞数 3
分类专栏： c 文章标签： c语言 c++ 开发语言
于 2022-05-10 00:22:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58465176/article/details/124594593
版权

作者简介：大家好我是狂暴于涛侠本侠
🦸个人主页：狂暴于涛侠
支持我：点关注不迷路提高彼此亲密度💌💌💌

指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：

  1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
  2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
  3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
  4. 指针的运算。

如果不知道的小伙伴可以点这里查看.
🧐让我们来看看C语言中指针都有什么猫腻 冲冲冲！！！
请添加图片描述

指针的进阶

🧐1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}
还有一种写法int main()
{
    const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
    printf("%s\n", pstr);
    return 0;
}

解释

代码 const char* pstr = “hello bit.”; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，但是/本质是把字符串 hello
bit. 首字符的地址放到了pstr中。
在这里插入图片描述
上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

可以通过下面的练习题理解一下

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

在这里插入图片描述
解释
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

🧐2. 数组指针

在《指针》章节学了指针数组，指针数组是一个存放指针的数组。
这里我们再复习一下，下面指针数组是什么意思？

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

🧐3. 指针数组

🚴3.1 数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

下面代码哪个是数组指针？

int *p1[10];
int (*p2)[10];

int (*p)[10];//是数组指针

解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。这里要注意：[ ]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

🚴3.2 &数组名VS数组名

对于下面的数组：
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们看一段代码：

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

结果为
在这里插入图片描述

可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：

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

在这里插入图片描述
解释
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.

🚴3.3 数组指针的使用

那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    //但是我们一般很少这样写代码
    return 0;
}

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    for(i=0; i<row; i++)
   {
        for(j=0; j<col; j++)
       {
            printf("%d ", arr[i][j]);
       }
printf("\n");
   }
}
void print_arr2(int (*arr)[5], int row, int col)
{
    int i = 0;
    for(i=0; i<row; i++)
   {
        for(j=0; j<col; j++)
       {
            printf("%d ", arr[i][j]);
       }
        printf("\n");
   }
}
int main()
{
    int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
   print_arr1(arr, 3, 5);
    //数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收
    print_arr2(arr, 3, 5);
    return 0;
}

🧐4. 数组传参和指针传参

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

🚴4.1 一维数组传参

#include <stdio.h>
void test(int arr[])
{}
void test(int arr[10])
{}
void test(int *arr)
{}
void test2(int *arr[20])
{}
void test2(int **arr)
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
}

🚴4.2 二维数组传参

void test(int arr[3][5])
{}
void test(int arr[][])
{}
void test(int arr[][5])
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)
{}
void test(int* arr[5])
{}
void test(int (*arr)[5])
{}
void test(int **arr)
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

🚴4.3 一级指针传参

//遍历数组
#include <stdio.h>
void print(int *p, int sz)
{
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d\n", *(p+i));
 }
}
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9};
 int *p = arr;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //一级指针p，传给函数
 print(p, sz);
 return 0;
}

思考：

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
指针变量传参指针变量接收

void test1(int *p)
{}
int ch =60;
int* p1 = &ch;
test2(&ch);
test2(p1);


void test2(char* p)
{}

char ch ='w';
char* p1 = &ch;
test2(&ch);//就是char*
test2(p1);

🚴4.4 二级指针传参

//用函数二级指针接收
void test(int** p2)
{
	//   p2 == ** ppa
	// * p2 == *pa
	//** p2 == a
	**p2 = 20;
}
int main()
{
	int a = 10;
	int* pa = &a;//pa是一级指针
	int** ppa = &pa;//ppa是二级指针
	//ppa用什么函数接收呢？
	test(ppa);
	return 0;
}

思考： 当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

//对于上个例子来说
	test(&pa);//传一级指针变量的地址
	//pa本来就是一级指针变量，&后就是二级地址

	int* arr[10] = {0};
	test(arr);//传存放一级指针的数组
	//arr是数组名，本身就是首元素地址再加上之前int* arr[10] 所以实际上也是 ** arr....
	printf("%d\n", a);//?
	//逻辑可以但实测不行，指针数组中存在野指针会导致代码挂掉

总结
当函数的参数为二级指针的时候，可以接收什么参数？
1.二级地址
2.传一级指针变量的地址
3.传存放一级指针的数组

🧐5. 函数指针

首先看一段代码：

int Add(int x, int y)
{
	return x + y;
}

int main()
{
	printf("%p\n", &Add);
	printf("%p\n", Add);

	return 0;
}

注意下面的关系
在这里插入图片描述

int Add(int x, int y)
{
	return x + y;
}

int main()
{
    //函数指针 - 存放函数地址的指针
	//&函数名 - 取到的就是函数的地址
	// 
	//pf就是一个函数指针变量
	//以下两种写法都可
	int (*pf)(int, int) = &Add;
	int (*pf)(int, int) = Add;//Add能放到pf中说明  Add==pf
//前面int是说这个函数返回值是int    后面两个int是传入的两个参数类型 

	//	对pf解引用后就是函数本身这时候将3,5传入计算
    int ret = (*pf)(3, 5);//得数为8   （********pf）同样可以所以这个式子中*4多少没有实际意义 只是为了让我们理解这是个指针
    int ret = Add(3,5);   //得数为8   Add能放到pf中说明  Add==pf 所以得出下面式子
    int ret = pf(3, 5);//得数为8
    
    // 以下写法不对     先执行的是pf（3,5）得数是8 后再解引用
    int ret =*pf(3,5);
    
	return 0;
}

 
你能看明白下面小题么？
 
1.    (*(void()()0))(); 是什么意义？
2.    void (*signal(int, void()(int)))(int);
解释

(*(void(*)()0))()
void (*)()是一种函数指针类型
实际上是对0进行强制转换  void (*)()0  (*)带表指针类型 ()代表是函数  void 是返回值类型
该函数无参数，返回值是void  
将0转化为一个返回值是void 的函数地址  后对0地址进行解引用*(void(*)()0)  
调用0地址处的函数(*(void(*)()0))()

void (*signal(int, void(*)(int)))(int);
1. signal 和()先结合，说明signal是函数名
2. signal函数的第一个参数的类型是int,第二个参数的类型是函数指针
 该函数指针，指向一个参数为int,返回类型是void的函数
3. signal函数的返回类型也是一个函数指针
 该函数指针，指向一个参数为int,返回类型是void的函数

对于void (*signal(int, void(*)(int)))(int);可以简化
typedef void(*pfun_t)(int) ;//对void(*)(int)的函数指针类型重命名为pfun_t
这样写不行------》typedef void(*)(int) pfun_t ;
typedef unsigned int uint;

🧐6. 函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，
比如：

int *arr[10];
//数组的每个元素是int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	int (*pf1)(int, int) = Add;
	int (*pf2)(int, int) = Sub;
	int (*pfArr[2])(int, int) = {Add, Sub};//pfArr就是函数指针数组

	return 0;
}

pfArr 先和 [] 结合，说明 pfArr 是数组，数组的内容是什么呢？

那么函数指针数组的应用是什么样的呢？

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;
}

void menu()
{
	printf("**************************\n");
	printf("**** 1. add    2. sub ****\n");
	printf("**** 3. mul    4. div ****\n");
	printf("****     0. exit      ****\n");
	printf("**************************\n");
}

int main()
{
	int input = 0;
	//计算器-计算整型变量的加、减、乘、除

	do {
		menu();
		
		int x = 0;
		int y = 0;
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误，重新选择!\n");
			break;
		}
		
	} while (input);
	return 0;
}
这样写没问题但是太麻烦了，代码冗余，而且添加新的功能也比较麻烦
将main函数这样改进
int main()
{
	int input = 0;
	do {
		menu();
		//pfArr就是函数指针数组
		//这个其实就是转移表 - 《C和指针》这本书中有提到
		int (*pfArr[5])(int, int) = { NULL, Add, Sub, Mul, Div };
		int x = 0;
		int y = 0;
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);//2

		if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数>:");
			scanf("%d %d", &x, &y);
			ret = (pfArr[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if(input == 0)
		{
			printf("退出程序\n");
			break;
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);
	return 0;
}

🧐7. 指向函数指针数组的指针

指向函数指针数组的指针是一个 指针
指针指向一个 数组 ，数组的元素都是 函数指针 ;
在这里插入图片描述

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[5])(const char*) = &pfunArr;
 (*ppfunArr)[5]
 return 0;
}

🧐8. 回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个
函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数
的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进
行响应。

利用回调函数优化👆面函数

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;
}

void menu()
{
	printf("**************************\n");
	printf("**** 1. add    2. sub ****\n");
	printf("**** 3. mul    4. div ****\n");
	printf("****     0. exit      ****\n");
	printf("**************************\n");
}

int Calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入2个操作数>:");
	scanf("%d %d", &x, &y);
	return pf(x, y);
}

int main()
{
	int input = 0;
	//计算器-计算整型变量的加、减、乘、除
	//a&b a^b a|b a>>b a<<b a>b

	do {
		menu();
	
		int ret = 0;
		printf("请选择:>");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			ret = Calc(Add);
			printf("ret = %d\n", ret);
			break;
		case 2:
			ret = Calc(Sub);
			printf("ret = %d\n", ret);
			break;
		case 3:
			ret = Calc(Mul);//
			printf("ret = %d\n", ret);
			break;
		case 4:
			ret = Calc(Div);//
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误，重新选择!\n");
			break;
		}
	} while (input);
	return 0;
}

🚴8.2 qsort函数的使用

为了方便大家理解我们先来看一下普通冒泡函数

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void bubble_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_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

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

	print_arr(arr, sz);
	bubble_sort(arr, sz);
	print_arr(arr, sz);
	return 0;
}

再来看一下 sqort函数的解释

这里写的不规范是方便大家理解
void qsort(    //void* p   就是为了存放任意类型的指针 但是这种指针类型不能进行解引用操作
void* base, //base中存放的是待排序数据中第一个对象的地址  为什么是void因为这样就可以比较很多类型了
size_t num, //排序数据元素的个数
size_t size,//排序数据中一个元素的大小，单位是字节   因为这个函数并不知道你要比较的是什么类型
int (*cmp)(const void* e1, const void* e2)//是用来比较待排序数据中的2个元素的函数  void因为这样就可以比较很多类型了
			);

以下是实际应用

#include <stdlib.h>//qsort
#include <string.h>//strcmp是比较两个字符大小


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

int cmp_int(const void* e1, const void* e2)
{    //e1 e2 都是void类型 必须转化为（int*）类型再算
	return *(int*)e1 - *(int*)e2;
}

void test1()
{
	//整形数据的排序
	int arr[] = { 1,3,5,7,9,2,4,6,8,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//排序
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	//打印
	print_arr(arr, sz);
}

struct Stu
{
	char name[20];
	int age;
};

int sort_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

int sort_by_name(const void*e1, const void*e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
//如果想要降序排列
//int sort_by_name(const void*e1, const void*e2)
//{                            直接将这个e1和e2换一下位置就好了  其他同理
//	return strcmp(((struct Stu*)e2)->name, ((struct Stu*)e1)->name);
//}


void test2()
{
	//使用qsort函数排序结构体数据
	struct Stu s[3] = { {"zhangsan", 30},{"lisi", 34},{"wangwu", 20} };

	int sz = sizeof(s) / sizeof(s[0]);
	//按照年龄来排序
	qsort(s, sz, sizeof(s[0]), sort_by_age);
	//按照名字来排序
	qsort(s, sz, sizeof(s[0]), sort_by_name);
}
int main ()
{
	test1();
	test2();
}

用自己的方法实现sqort函数

//模仿qsort实现一个冒泡排序的通用算法
void bubble_sort(void* base,int sz,int width,int (*cmp)(const void*e1, const void*e2) )
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		//一趟的排序
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			//两个元素比较
			//arr[j] arr[j+1]
			//这里为什么要转化为（char*）而不是别的呢？ 首先（char*）类型是最小的方便
			//with计算 如果转化为int指针类型 后面with加减运算就比较麻烦了
			if (cmp( (char*)base+j*width, (char*)base+(j+1)*width )>0)
			{
				//交换     
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);//最后一个数是width是因为函数不知道我们要比较的参数所以手动的添加
			}
		}
	}
}
void Swap(char*buf1, char*buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int  main()
{
	//整形数据的排序
	int arr[] = { 1,3,5,7,9,2,4,6,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//排序
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	//打印
	print_arr(arr, sz);
}

🧐9. 指针和数组面试题的解析

首先我们先记住以下规则

  1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
  2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
  3. 除此之外所有的数组名都表示首元素的地址。

操作系统位数不同计算结果不同
先看下面小题

int a[] = { 1,2,3,4 };//4*4=16
printf("%d\n", sizeof(a));//16 整个数组的大小。
printf("%d\n", sizeof(a + 0));//4/8 a + 0 是第一个元素的地址，sizeof(a + 0)计算的就是是该地址的大小
printf("%d\n", sizeof(*a));//4  a是数组名也就是首元素1的地址解引用后就是1  *a是数组的第一个元素，sizeof(*a)计算的是第一个元素的大小
printf("%d\n", sizeof(a + 1));//4/8 a + 1是第二个元素的地址，sizeof(a+1)计算的地址的大小
printf("%d\n", sizeof(a[1]));//4 - 计算的是第二个元素的大小

printf("%d\n", sizeof(&a)); //4/8 - &a虽然数组的地址，但是也是地址，sizeof(&a)计算的是一个地址的大小
printf("%d\n", sizeof(* &a));//16 - 计算的数组的大小    先&取地址在*解引用相当于取消了
//&a -- int(*p)[4] = &a;
printf("%d\n", sizeof(&a + 1));//4/8 - &a + 1 是数组后面的空间的地址
printf("%d\n", sizeof(&a[0]));//4/8       1 的地址
printf("%d\n", sizeof(&a[0] + 1));//4/8   是2的地址

//字符数组
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", sizeof(arr));//6  6个字符每个字符1字节 
printf("%d\n", sizeof(arr + 0));//4/8   就是a的地址  注意字符所占空间大小是一个字节 但是字符的地址编号也是4个字节
printf("%d\n", sizeof(*arr));//1   首元素地址解引用
printf("%d\n", sizeof(arr[1]));//1 b的字节数
printf("%d\n", sizeof(&arr));//4/8  整个数组的地址也是地址也是4个字节
printf("%d\n", sizeof(&arr + 1));//4/8    整个数组后的第一位 也就是f后
printf("%d\n", sizeof(&arr[0] + 1));//4/8 b的地址  &arr[0]取第一个元素的地址，类型是int*  int*类型的指针加一就是跳过一个元素 也就是b


//strlen函数会从这个数向后找\0没有就继续找
printf("%d\n", strlen(arr));//随机值   首元素地址一直向后找\0
printf("%d\n", strlen(arr + 0));//随机值  首元素地址一直向后找\0
printf("%d\n", strlen(*arr));// err   正常strlen（char* str） 但是就本题而言，*arr是a的值，strlen回去找97地址的位置但根本没有
printf("%d\n", strlen(arr[1]));//err 同上
printf("%d\n", strlen(&arr));//随机值  本来&arr是整个数组地址 但是函数strlen（char* str）  将数组char(*)[6];传入会转化为字符指针 系统会认为这个依然是首字符的地址
printf("%d\n", strlen(&arr + 1));//和前面随机值相比    随机值-6
printf("%d\n", strlen(&arr[0] + 1));//和前面随机值相比 随机值-1

char arr[] = "abcdef";
//注意：[a b c d e f \0]
printf("%d\n", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8 
printf("%d\n", sizeof(*arr));//a 1
printf("%d\n", sizeof(arr[1]));//b 1
printf("%d\n", sizeof(&arr));//4/8  char(*)[7]
printf("%d\n", sizeof(&arr + 1));//4/8   跨过整个数组 虽然加一但是类型还是没变 
printf("%d\n", sizeof(&arr[0] + 1));//4/8  b的地址

printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6
printf("%d\n", strlen(*arr));//err 正常strlen（char* str） 但是就本题而言，*arr是a的值，strlen回去找97地址的位置但根本没有
printf("%d\n", strlen(arr[1]));//err 同上
printf("%d\n", strlen(&arr));//6 本来&arr是整个数组地址 但是函数strlen（char* str）  将数组char(*)[7];传入会转化为字符指针 系统会认为这个依然是首字符的地址
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5

char* p = "abcdef"; // p是首元素地址
//注意：[a b c d e f \0]
printf("%d\n", sizeof(p));// 4/8  p存放的是a的地址
printf("%d\n", sizeof(p + 1));//  4/8  b的地址
printf("%d\n", sizeof(*p)); // 1 a的字节
printf("%d\n", sizeof(p[0])); //1  p[0]--> *(p+0) 同上
printf("%d\n", sizeof(&p));//   4/8  p的地址
printf("%d\n", sizeof(&p + 1)); // 4/8 跨过整个p的地址加一
printf("%d\n", sizeof(&p[0] + 1));//  4/8 b 的地址

printf("%d\n", strlen(p));//6   a向后查到\0
printf("%d\n", strlen(p + 1));//5 b向后查到\0
printf("%d\n", strlen(*p));//  首地址解引用 无地址
printf("%d\n", strlen(p[0]));//  同上  
printf("%d\n", strlen(&p));//随机值  无法明确指针地址后有多少数字
printf("%d\n", strlen(&p + 1));// 随机值 和上面随机值没有关系 因为无法明确p数组地址中有没有\0
printf("%d\n", strlen(&p[0] + 1));// 5

printf("%d\n", strlen(&p));
printf("%d\n", strlen(&p + 1));

在这里插入图片描述


	int a[3][4] = { 0 };
	
	printf("%d\n", sizeof(a));//48 = 3*4*sizeof(int)
	printf("%d\n", sizeof(a[0][0]));//4 - a[0][0] - 是第一行第一个元素
	printf("%d\n", sizeof(a[0]));//16
	printf("%d\n", sizeof(a[0] + 1));//4 解释：a[0]作为数组名并没有单独放在sizeof内部，
									//也没取地址,所以a[0]就是第一行第一个元素的地址
									//a[0]+1,就是第一行第二个元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4   整形大小 - 解释：*(a[0] + 1)是第一行第二个元素

	printf("%d\n", sizeof(a + 1));//4 - 解释：a是二维数组的数组名，代表首元素地址即a[0][0-3]并没有取地址
	//也没有单独放在sizeof内部,所以a就表示二维数组首元素的地址，即：第一行的地址
	//a + 1就是二维数组第二行的地址看地址类型所以答案是4

	printf("%d\n", sizeof(*(a + 1)));//16 解释： ==a[1]  a+1是第二行的地址，所以*（a+1）表示第二行
	//所以计算的就是第2行的大小

	printf("%d\n", sizeof(&a[0] + 1));//4 解释：a[0]是第一行的数组名，
	//&a[0]取出的就是第一行的地址,&a[0]+1 就是第二行的地址

	printf("%d\n", sizeof(*(&a[0] + 1)));//  16 &a[0]+1 就是第二行的地址
	//*(&a[0]+1) 就是第二行，所以计算的第二行的大小

	printf("%d\n", sizeof(*a));//16 解释：== a[0]  a作为二维数组的数组名，没有&，没有单独放在sizeof内部
		//a就是首元素的地址，即第一行的地址，所以*a就是第一行，计算的是第一行的大小

	printf("%d\n", sizeof(a[3]));//16 解释：a[3]其实是第四行的数组名（如果有的话）
	//所以其实不存在，也能通过类型计算大小的
	printf("%d\n", sizeof(a[-1])); //16 解释：同上

在这里插入图片描述

int main()
{
	short s = 5;
	int a = 4;
	printf("%d\n", sizeof(s = a + 6));//2   算的是short大小  
	printf("%d\n", s);//5 sizeof内部表达式不参与运算

	return 0;
}
就可以解释上述代码中中的
printf("%d\n", sizeof(a[3]));
printf("%d\n", sizeof(a[-1]));

在这里插入图片描述

🧐10. 指针笔试题

笔试题1：

int main()
{
  int a[5] = { 1, 2, 3, 4, 5 };
  int* ptr = (int*)(&a + 1);
 printf("%d,%d", *(a + 1), *(ptr - 1));

 return 0;
//注意指针类型决定了指针的步长和读取能力  
}

在这里插入图片描述

笔试题2：

由于还没学习结构体，这里告知结构体的大小是20个字节
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}* p;
//假设p 的值为0x100000。 如下表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节

int main()
{
    //0x1 16进制1 
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

在这里插入图片描述

笔试题3：


int main()
{
    int a[4] = { 1, 2, 3, 4 };
    int* ptr1 = (int*)(&a + 1);
    int* ptr2 = (int*)((int)a + 1);

    printf("%x,%x", ptr1[-1], *ptr2);
    return 0;
}

在这里插入图片描述

笔试题4：

#include <stdio.h>
int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int* p;
    p = a[0];
    printf("%d", p[0]);
    return 0;
}

注意括号是（）这是逗号表达式 数组中其实就放的是135000

在这里插入图片描述

笔试题5：

int main()
{
    int a[5][5];
    int(*p)[4];
    p = a;//int (*)[5]
    printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
    //?

    return 0;
}

在这里插入图片描述

笔试题6：

int main()
{
    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int* ptr1 = (int*)(&aa + 1);
    int* ptr2 = (int*)(*(aa + 1));//单个aa 表示第一行地址  (*(aa + 1))==aa[1]拿到的是整个第二行 同时解引用拿到的是首个元素地址
                                 //本身就是整形地址 再来强转(int*)无意义是为了迷惑
    printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));// 10    5
    return 0;
}

在这里插入图片描述

笔试题7：

#include <stdio.h>

int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

在这里插入图片描述

笔试题8：

int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	char*** cpp = cp;

	printf("%s\n", **++cpp);
	printf("%s\n", *-- * ++cpp + 3);
	printf("%s\n", *cpp[-2] + 3);
	printf("%s\n", cpp[-1][-1] + 1);
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

狂暴于涛侠
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【C语言】初级指针 (超多图方便理解)
m0_58465176的博客
04-13 769
指针1. 指针是什么2. 指针和指针类型3. 野指针4. 指针运算5. 指针和数组6. 二级指针7. 指针数组 1. 指针是什么 指针是什么？ 指针理解的2个要点： 指针是内存中一个最小单元的编号，也就是地址 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量 总结：指针就是地址，口语中说的指针通常指的是指针变量。 那我们就可以这样理解：内存 指针变量 我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量 #inclu
【C语言学习】指针再理解（一）
喜欢哲学的女孩
06-19 909
★内存和地址 内存的基本单位是字节，那么内存就可以按字节进行编址，就是给组成内存的所有连续的字节安排地址。其中一个最恰当的比喻就是房子与门牌号，假设有20间连续的房子，从最左边（或者左右边）开始分配门牌号1~20，给内存中字节分配的地址就相当于门牌号，字节就相当于房间。字节的容量只能存储一个字符。那么，内存是如何存储比字符更大的数据呢，比如：整型数据、浮点型数据？ ★更大的内存单元 为了存储
猿创征文丨赶紧进来---看完轻松掌握C语言指针(进阶篇)
记录并分享学习编程时的知识点...
09-05 1266
耐心看完~对指针不再恐惧..本文详细介绍了指针进阶篇内容: > 指针和数组间的关系:字符指针,, 一维数组和二维数组传参以及一维指针和二维指针传参
指针进阶版☞（超easy~）
pingwenqi的博客
01-09 740
指针详解，来看看吧(＾Ｕ＾)ノ~ＹＯ (●'◡'●)
详解指针进阶-初学者也能看懂
C、Java知识分享
01-20 1935
c语言指针，一篇就够~
C语言指针详解（2）
YLG_lin的博客
08-02 186
C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。指针数组是一个存放指针的数组int(*p)[5];解释p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为5个。...
还搞不懂指针？点进来！手把手带你进阶指针（数组指针、指针数组、指针传参、指向函数指针数组的指针等等一切关于复杂指针的问题，统统搞定！）
Stella-F的博客
09-20 260
【手把手带你进阶】指针（数组指针、指针数组、指针传参、指向函数指针数组的指针等等一切关于复杂指针的问题，统统搞定！）字符指针数组指针指针数组数组传参和指针传参 前面我们已经对指针进行了一个初步的讲解，相信大家对于指针都已经有了一个基本的认识，那么今天，我们就把指针拿出来，更加深入全面地扒开指针的皮，看看指针的内涵。 首先我们先回顾一下初阶指针中的内容。（具体可以看这篇看完这篇文章，别再说指针难了！手把手带你入门指针的基本使用 指针是一个用来存放地址的变量，这个地址可且仅可标识一块内存空间。 指针的大小是
c语言程序设计基础8文件.ppt
09-28
本节主要讲解C语言程序设计的文件处理基础知识，包括文件的概念、分类、打开和关闭、读写操作、指针定位、检测函数等。 文件概述 文件是存在计算机存储介质中的一些信息的集合。文件是一些记录（record）的集合，...
C语言文件操作文件PPT学习教案.pptx
10-06
C语言文件操作文件PPT学习教案 本章要点：文件在计算机领域中是...文件指针：C语言系统对文件的操作必须通过一个指向“FILE类型”的指针来实现，我们称这个指针为文件指针。文件指针是C语言系统中对文件的操作的核心。
数据结构---C语言描述-(耿国华)-高等教育出版社出版-课后习题答案.pdf
11-03
本资源摘要信息是关于数据结构的课后习题答案，涵盖了数据结构的基本概念、数据抽象、信息隐蔽、数据对象、对象间的关系、一组处理数据的操作、指针类型、集合结构、线性结构、树形结构、图状结构等知识点。...
数据结构---C语言描述-(耿国华)-高等教育出版社出版-课后习题答案
04-21
数据结构---C语言描述-(耿国华)-高等教育出版社出版-课后习题答案 数据结构是计算机科学中一个基础课题，涉及到数据的存储、操作和管理。数据结构可以分为线性结构、树形结构、图状结构等多种类型，每种结构都有其...
C嵌入式编程设计模式-子类化（1）
08-13
但是，如果你填满了内部缓冲区，那么insert（）操作将会调用flush（）写入磁盘之外的插入缓冲区，然后重置内部缓冲区。对于删除数据，稍有一些复杂。如果内部缓冲区为空，则remove（）调用load（）函数从硬盘上读取...
【C语言进阶篇】什么还没学会指针? 一篇文章让你彻底搞懂指针的奥秘
鸽芷咕的博客
10-08 325
数组和&数组名的区别是我们在考试中最容易出的考察点了。今天就来给大家强训一下关于数组和&数组名的理解！看完直接拿捏数组和&数组名的关系！
让你不再惧怕指针——C语言指针及指针进阶详解
qq_55119554的博客
07-09 329
指针是C语言中一个重要的概念，理解它有助于更好地理解和利用C语言的强大功能。理解指针的概念和使用方法，可以提高程序的效率、灵活性和内存管理能力。理解和掌握它可以提高程序的效率和灵活性
C语言指针的进阶知识详细讲解,你一定会有所收获!
The_emperoor_man的博客
10-28 711
内存就好像是一个自动贩卖机;字符串常量是自动贩卖机里的一个货物;指针是指向货物的地址,也就是指针知道去哪可以买到,所以指针相同,都指向贩卖机里的那个货物字符串是切切实实的买到了这个货物,虽然都是一样的货物,但是被两个不同的人买去,一个是我的货物,一个是你的货物,就不同了,所以字符数组不同;
指针进阶（超详细讲解）
m0_58950498的博客
11-27 160
指针超详细讲解
指针的进阶，进来看看你都知道多少？
lyx_bc的博客
02-15 91
指针进阶内容，进来看看吧
手撕C语言进阶---指针(干货满满！值得收藏！！)
Edward_Asia的博客
09-04 900
指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念： 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。 指针的大小是固定的4/8个字节（32位平台/64位平台）。 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。 指针的运算。 这个章节，我们继续探讨指针的高级主题 字符指针 在指针的类型中我们知道有一种指针类型为字符指针 char* ; 一般使用: int main() { char ch = 'w'; c.
Java的c/s架构如何同时访问多个数据源
最新发布
codemami的博客
06-11 1157
在Java的客户端/服务器（C/S）架构中，当服务器需要同时访问多个数据源时，通常是在服务器端进行配置和实现的。可以通过继承这个类来自定义多数据源的连接。在Java的C/S（客户端/服务器）架构中，实现同时访问多个数据源通常涉及后端服务器的设计和实现。接下来，你需要实现一个动态数据源路由的功能，这通常是通过继承AbstractRoutingDataSource类来实现的。配置数据源：为每个数据源创建DataSource对象，并配置相应的数据库连接信息，如驱动类名、URL、用户名和密码等。
c语言指针进阶 头哥
12-08
C语言指针进阶主要包括以下几个方面： 1.指针的指针：指针的指针是指一个指针变量的地址，即一个指向指针变量的指针。可以通过指针的指针来修改指针变量的值。例如： ```c int a = 10; int *p = &a; int **pp = &p...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

狂暴于涛侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值