【进阶】2. 指针的进阶

已于 2023-08-14 22:08:04 修改
阅读量489 收藏
点赞数
分类专栏： C语言 文章标签： 算法 开发语言 c语言
于 2023-08-14 22:06:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/The_bad/article/details/132134095
版权

指针的进阶

文章说明：该文章的知识点源于B站上比特鹏哥的C语言课程，结合鹏哥上课的讲义、课堂代码以及自己的理解整理形成。

1. 字符指针

常规用法：

int main()
{
    char ch = 'w';
    char *pc = &ch;
    *pc = 'w';
    return 0;
}

另一种使用方式：

int main()
{
    const char* ps = "hello bit."; //常量字符串无法更改
    printf("%s\n", ps);
    return 0;
}

本质是把字符串首字符 h 的地址放到指针变量 ps 当中。

#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 不同。

添加下面的代码会报错，因为常量字符串不允许更改！

//const char *str3 = "hello bit.";改为下行代码
char *str3 = "hello bit.";
*str3 = 'w';

2. 指针数组

本质是数组，数组中存放的是指针。

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

int main()
{
	int a[5] = { 1,2,3,4,5 };
	int b[] = { 2,3,4,5,6 };
	int c[] = { 3,4,5,6,7 };

	int* arr[3] = {a,b,c}; //模拟了一个二维数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			//printf("%d ", *(arr[i] + j)); 
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

arr[i][j] 和*(arr[i] + j) 等价。

3. 数组指针

3.1 数组指针的定义

数组指针是指针。

数组指针和指针数组的辨析：

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

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

double *d[5];
double* (*pd)[5] = &d; //pd是一个数组指针

int arr[10] = {1,2,3,4,5};
int (*parr)[10] = &arr; //parr就是一个数组指针，其中存放的是数组的地址

3.2 &数组名 VS 数组名

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    printf("%p\n", arr);	//00EFF920
    printf("%p\n", &arr);	//00EFF920 值一样，但是类型不一样
    return 0;
}

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    printf("arr = %p\n", arr);		//arr = 0133FBB0
    printf("&arr= %p\n", &arr);		//&arr = 0133FBB0
    printf("arr+1 = %p\n", arr+1);	//arr+1 = 0133FBB4
    printf("&arr+1= %p\n", &arr+1);	//&arr+1 = 0133FBD8
    //数组的地址+1，跳过整个数组的大小，所以&arr+1相对于&arr的差值是40.
    return 0;
}

数组名是数组首元素的地址，但是有2个例外：

  1. sizeof(数组名) - 数组名表示整个数组，计算的是整个数组大小，单位是字节
  2. &数组名 - 数组名表示整个数组，取出的是整个数组的地址

3.3 数组指针的使用

一般很少这样写代码，很少用数组指针直接指向一维数组

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	int (*pa)[10] = &arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *((*pa) + i)); //非常变扭
	}

	return 0;
}

二维数组的首元素是：第一行！

void print(int(*p)[5], int r, int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}

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

	print(arr, 3, 5);//arr数组名，表示数组首元素的地址
	return 0;
}

int arr[5];			//整型数组
int *parr1[10];		//存放整型指针的数组
int (*parr2)[10];	//数组指针，指向一个有10个元素的数组，每个元素的类型是int
int (*parr3[10])[5];//存放数组指针的数组，存放10个数组指针，每个数组指针指向有5个元素的数组，每个元素的类型是int

4. 数组传参和指针传参

关键在于传递的是什么

4.1 一维数组传参

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

4.2 二维数组传参

void test(int arr[3][5])//ok？ -> yes
{}
void test(int arr[][])//ok？ -> no
{}
void test(int arr[][5])//ok？ -> yes
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok？ -> no 第一行的地址是数组的地址
{}
void test(int* arr[5])//ok？ -> no 这是一个指针数组
{}
void test(int (*arr)[5])//ok？ -> yes
{}
void test(int **arr)//ok？ -> no
{}
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 test(char* p)
{}

char ch = 'w';
char *pc = &ch;
test(&ch);
test(pc);

4.4 二级指针传参

#include <stdio.h>
void test(int** ptr)
{
    printf("num = %d\n", **ptr);    
}
int main()
{
    int n = 10;
    int*p = &n;
    int **pp = &p;
    test(pp);
    test(&p);
    return 0;
}

当函数的参数为二级指针的时候，可以接收什么参数？

void test(char **p)
{}

int main()
{
    char c = 'b';
    char*pc = &c;
    char**ppc = &pc;
    char* arr[10];
    test(&pc);
    test(ppc);
    test(arr);//Ok? - Yes
    return 0;
}

5. 函数指针

函数指针：存放函数地址的指针。

函数名 == &函数名

#include <stdio.h>
void test()
{
    printf("hehe\n");
}
int main()
{
    printf("%p\n", test);	//输出结果：013211DB
    printf("%p\n", &test);	//输出结果：013211DB -> 取到的是函数的地址
    return 0;
}

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

int main()
{
    //int (*pf)(int, int) = Add; 效果同下
    int (*pf)(int, int) = &Add; //pf就是一个函数指针    Add 等价于 pf
    
    int ret1 = (*pf)(3, 5); //调用函数指针
    int ret2 = pf(3, 5); 	//调用函数指针
    int ret3 = Add(3, 5);	//调用函数
    
    return 0;
}

阅读两段有趣的代码：

//代码1
(*(void (*)())0)(); 

//该函数无参，返回类型是void
//1. void(*)() - 函数指针类型
//2. (void(*)())0 - 对0进行强制类型转换，被解释为一个函数地址
//3. *(void(*)())0 - 对0地址进行了解引用操作
//4. (*(void(*)())0)() - 调用0地址处的函数
//将0强制类型转换为函数指针，然后再调用0地址处的函数，该函数无参，返回值为void


//代码2
void (*signal(int , void(*)(int)))(int);

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

代码2简化：

typedef void(*pfun_t)(int); //void(*)(int) -> pfun_t
pfun_t signal(int, pfun_t);

6. 函数指针数组

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

函数指针数组的用途：转移表，以计算器为例。

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();

		//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;
    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;
	//计算器-计算整型变量的加、减、乘、除

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

演示一下 qsort 函数的使用：

void qsort (void* base, //指向要排序的第一个对象
            size_t num, //要排序元素的个数
            size_t size, //要排序元素的大小
            int (*compar)(const void*,const void*)); //比较函数的指针

#include <stdio.h>
//qosrt函数的使用者需要实现一个比较函数
int int_cmp(const void * p1, const void * p2)
{
      return (*( int *)p1 - *(int *) p2);
}

int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
    {
       printf( "%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

模拟实现 qsort 函数（采用冒泡的方式），为数组排序：

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)
{
	return *(int*)e1 - *(int*)e2;
}

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

//模仿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]
			if (cmp( (char*)base+j*width, (char*)base+(j+1)*width )>0)
			{
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

void test3()
{
	//整形数据的排序
	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);
}

int main()
{
	test3();
	return 0;
}

模拟实现 qsort 函数（采用冒泡的方式），为结构体排序：

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

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

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]
			if (cmp( (char*)base+j*width, (char*)base+(j+1)*width )>0)
			{
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

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

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

int main()
{
	test4();
	return 0;
}

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

//一维数组
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));

// 16 - sizeof(a)表示整个数组的大小
// 4/8 - a表示数组的首元素地址 -> 求的是数组第1个元素地址的大小
// 4 - a表示数组的首元素地址，*a表示数组的首元素 -> 求的是数组第1个元素的大小
// 4/8 - a表示数组的首元素地址，a+1示数组的第2个元素地址 -> 求的是数组第2个元素地址的大小
// 4 - a[1]表示数组的第2个元素 -> 求的是数组第2个元素的大小

// 4/8 - &a表示的是整个数组的地址 -> 求的是整个数组地址的大小
// 16 - &a表示的是整个数组的地址; *&a表示整个数组 -> 求的是整个数组地址的大小
// 4/8 - &a表示的是整个数组的地址; &a+1表示整个数组后面的地址 -> 求的是数组后面地址的大小
// 4/8 - a[0]是数组的第1个元素; &a[0]是取出第1个元素的地址 -> 求的是第1个元素地址的大小
// 4/8 - &a[0]是取出第1个元素的地址; &a[0]+1取出第2个元素的地址 -> 求的是第2个元素地址的大小

//字符数组
char arr[] = {'a','b','c','d','e','f'};
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));
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));

// 6 - sizeof(arr)表示整个数组的大小
// 4/8 - arr表示数组首元素的地址; arr+0也还是数组首元素的地址 -> 求的是数组首元素地址的大小
// 1 - arr表示数组首元素的地址; *arr表示数组的首元素 -> 求的是数组首元素的大小
// 1 - arr[1]表示的是数组的第2个元素 -> 求的是数组第2个元素的大小
// 4/8 - &arr表示的是整个数组的地址 -> 求的是整个数组地址的大小
// 4/8 - &arr表示的是整个数组的地址; &arr+1表示的是整个数组后面的地址 -> 求的是数组后面地址的大小
// 4/8 - arr[0]表示的是数组的首元素; &arr[0]表示的是数组第1个元素的地址; 
//		 &arr[0]+1表示的是数组第2个元素的地址 -> 求的是第2个元素地址的大小

// 随机值 - arr表示数组首元素的地址 -> 一直找到'\0'字符为止
// 随机值 - arr表示数组首元素的地址;  arr+0也还是数组首元素的地址 -> 一直找到'\0'字符为止
// err - arr表示数组首元素的地址; *arr表示数组的首元素 -> 地址为a的ASCII码值 97 报错
// err - arr[1]表示数组的第2个元素 -> 地址为b的ASCII码值 98 报错
// 随机值 - &arr表示整个数组的地址; 隐含强制类型转换 strlen(char* str) -> 一直找到'\0'字符为止
// 随机值-6 - &arr表示的是整个数组的地址; &arr+1表示整个数组后面的地址 -> 一直找到'\0'字符为止
// 随机值-1 - arr[0]表示数组的首元素; &arr[0]表示数组第1个元素的地址; 
//			 &arr[0]+1表示数组第2个元素的地址 -> 一直找到'\0'字符为止

char arr[] = "abcdef";
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));
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));

// 7 - sizeof(arr)表示整个数组的大小
// 4/8 - arr表示的是数组首元素地址; arr+0表示的是数组首元素地址 -> 求的是数组首元素地址的大小
// 1 - arr表示的是数组首元素地址; *arr表示的是数组首元素 -> 求的是数组首元素的大小
// 1 - arr[1]表示的是数组第2个元素 -> 求的是数组第2个元素的大小
// 4/8 - &arr表示的是整个数组的地址 -> 求的是整个数组地址的大小
// 4/8 - &arr表示的是整个数组的地址; &arr+1表示整个数组后面的地址 -> 求的是整个数组后面地址的大小
// 4/8 - arr[0]表示的是数组首元素; &arr[0]表示的是数组首元素的地址; 
//		 &arr[0]+1表示的是数组第2个元素的地址 -> 求的是数组第2个元素地址的大小

// 6 - arr表示数组首元素的地址 -> 一直找到'\0'字符为止
// 6 - arr表示数组首元素的地址;  arr+0也还是数组首元素的地址 -> 一直找到'\0'字符为止
// err - arr表示数组首元素的地址; *arr表示数组的首元素 -> 地址为a的ASCII码值 97 报错
// err - arr[1]表示数组的第2个元素 -> 地址为b的ASCII码值 98 报错
// 6 - &arr表示整个数组的地址; 隐含强制类型转换 strlen(char* str) -> 一直找到'\0'字符为止
// 随机值 - &arr表示的是整个数组的地址; &arr+1表示整个数组后面的地址 -> 一直找到'\0'字符为止
// 5 - arr[0]表示数组的首元素; &arr[0]表示数组第1个元素的地址; 
//	   &arr[0]+1表示数组第2个元素的地址 -> 一直找到'\0'字符为止

char *p = "abcdef";
printf("%d\n", sizeof(p));
printf("%d\n", sizeof(p+1));
printf("%d\n", sizeof(*p));
printf("%d\n", sizeof(p[0]));
printf("%d\n", sizeof(&p));
printf("%d\n", sizeof(&p+1));
printf("%d\n", sizeof(&p[0]+1));

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

// 4/8  - p指向字符串的'a'字符; p存储的是字符'a'的地址 -> 求的是字符'a'地址的大小
// 4/8 - p存储的是字符'a'的地址; p+1指向字符串的'b'字符;-> 求的是字符'b'地址的大小
// 1 - p存储的是字符'a'的地址; *p表示的是字符'a' -> 求的是字符'a'的大小
// 1 - p[0]等价于*p -> 求的是字符'a'的大小
// 4/8 - &p表示的是p的地址 -> 求的是p地址的大小
// 4/8 - &p表示的是p的地址; &p+1表示的是p后面的地址 -> 求的是p后面地址的大小
// 4/8 - p[0]表示字符'a'; &p[0]表示字符'a'地址; &p[0]+1表示字符'b'地址 -> 求的是字符'b'地址的大小


// 6 - p指向字符串的'a'字符 -> 一直找到'\0'字符为止
// 5 - p指向字符串的'a'字符; p+1指向字符串的'b'字符 -> 一直找到'\0'字符为止
// err - p指向字符串的'a'字符; *p表示的是字符'a' -> 地址为a的ASCII码值 97 报错
// err - p[0]等价于*p -> 地址为a的ASCII码值 97 报错
// 随机值 - &p表示的是p的地址; 从p的地址开始找, 一直找到'\0'字符为止
// 随机值 - &p表示的是p的地址; &p+1表示的是p后面的地址;从p+1的地址开始找, 一直找到'\0'字符为止
// 5 - p[0]表示字符'a'; &p[0]表示字符'a'地址; &p[0]+1表示字符'b'地址-> 一直找到'\0'字符为止

//二维数组 -> 关键a[0] a[1] a[2] 可以看作是单独的数组名; 每个数组有4个元素
int a[3][4] = {0};
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(a[0][0]));
printf("%d\n",sizeof(a[0]));
printf("%d\n",sizeof(a[0]+1));
printf("%d\n",sizeof(*(a[0]+1)));
printf("%d\n",sizeof(a+1));

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

// 3*4*4=48 - sizeof(a)表示整个数组 -> 求的是整个数组的大小
// 4 - a[0][0]表示数组第1行第1列的元素 -> 求的是元素a[0][0]的大小
// 4*4=16 - a[0]单独在sizeof内部表示第1行的数组名 -> 求的是数组第1行的大小
// 4/8 - a[0]表示第1行第1列元素的地址; a[0]+1表示第1行第2列元素的地址 -> 求的是a[0][1]地址的大小
// 4 - a[0]+1表示第1行第2列元素的地址; *(a[0]+1))表示a[0][1]的值 -> 求的是元素a[0][1]的大小
// 4/8 - a表示数组第1行的地址; a+1表示数组第2行的地址 -> 求的是数组第2行地址的大小

// 4*4=16 - a+1表示数组第2行的地址; *(a+1)表示数组的第2行 -> 求的是数组第2行的大小
// 4/8 - &a[0]表示第1行的地址; &a[0]+1表示第2行的地址 -> 求的是数组第2行地址的大小
// 4*4=16 - &a[0]+1表示第2行的地址; *(&a[0]+1)表示第2行 -> 求的是数组第2行的大小
// 4*4=16 - a表示数组第1行的地址; *a表示数组的第1行 -> 求的是数组第1行的大小
// 4*4=16 - a[3]表示数组第4行地址, 实际不存在 -> sizeof(a[3])可以根据类型推算出大小

int main()
{
	short s = 5;
	int a = 4;
	printf("%d\n", sizeof(s = a + 6));//2 -> s=a+6并没有进行计算
	printf("%d\n", s);//5
	return 0;
}

【总结】数组名的意义：

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

10. 指针笔试题

10.1 笔试题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,5

10.2 笔试题2

//指针类型决定了指针的运算
struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
    printf("%p\n", p + 0x1);	
    printf("%p\n", (unsigned long)p + 0x1);
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}

//程序的结果：
//0x100014
//0x100001 - 整数加1
//0x100004

10.3 笔试题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 2000000  -> ((int)a + 1) 是指向a[0]中的第2个字节，配合小端存储

10.4 笔试题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;
}

//程序的结果：
//1		->	a[3][2] = {1,3,5,0,0,0}
//把a[0]单独看出一个数组名; a[0]表示数组首元素的地址, 即a[0][0]的地址

10.5 笔试题5

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

//程序的结果：
//0xFFFFFFFC -4

10.6 笔试题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));
    printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
    return 0;
}

//程序的结果：
//10 5

10.7 笔试题7

#include <stdio.h>
int main()
{
    char *a[] = {"work","at","alibaba"};
    char**pa = a;
    pa++;
    printf("%s\n", *pa); 
    return 0;
}

//程序的结果：
//at

10.8 笔试题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;
}

//程序的结果：
//POINT
//ER
//ST
//EW
夏日晴风
关注
专栏目录
C语言—指针进阶（详解）
m0_63601181的博客
05-07 776
大家好，我是Abert，这篇文章跟大家分享指针的高阶内容。众所周知，指针堪称C语言的灵魂，掌握指针是学好C语言的关键。 这篇文章建立在上篇（初阶指针)文章的基础上进行的，建议大家配合上篇文章一起食用效果更佳。 文章目录 1.指针数组 1.1字符指针数组 1.2整形指针数组 2.数组指针 3.函数指针 4.函数指针数组 5.结构体指针 6.指针进阶题目 正文 1.指针数组 指针数组是数组，数组内存放的是指针 1.1字符指针数组 存放字符指针...
从初识C语言到C语言进阶源码.zip
10-18
3. **进阶话题**：随着学习的深入，可能会涉及到指针、结构体、联合体、位运算、预处理器等进阶主题。这些内容是C语言的强大之处，也是挑战所在。通过学习这些，可以提升编程能力，解决更复杂的问题。 4. **项目...
【进阶C语言】指针的进阶（万字图文详解）
m0_75058342的博客
03-24 1536
【C语言】长达万字的指针进阶内容，含有详细图文讲解
c语言进阶.pdf,C语言程序设计进阶：文件.pdf
weixin_32866237的博客
05-19 206
格式化输⼊输出格式化的输⼊输出• printf• %[flags][width][.prec][hlL]type• scanf• %[flag]type%[flags][width][.prec][hlL]typeFlag 含义- 左对⻬+ 在前⾯放 + 或 -(space) ...
【C语言进阶】函数指针技术详解
极客代码
07-08 1299
函数指针是C语言中一个非常重要的概念，它允许我们定义指向函数的指针，并使用这些指针来调用函数。在C语言中，函数指针的使用场景非常广泛，如动态选择函数、回调函数等。本文将深入探讨函数指针的工作原理，并解释其背后的技术细节。文章将分为三个部分，本部分将详细介绍函数指针的基本概念和原理。
c语言程序设计指针进阶,C语言程序设计进阶：指针.pdf
weixin_42544461的博客
05-19 130
9.1-1 取地址运算运算符 &• scanf(“%d”, &i);⾥的&• 获得变量的地址，它的操作数必须是变量• int i; printf(“%x”,&i);• 地址的⼤⼩是否与int相同取决于编译器• int i; printf(“%p”,&i);&不能取的地址• &不能对没有地址的东⻄取地址• &...
指针进阶之数组指针和指针数组
人生得意须尽欢
01-04 6543
指针进阶之数组指针和指针数组，超详细，不会来看
C语言——指针（进阶版）
热门推荐
weixin_59796310的博客
02-01 1万+
C语言——指针（进阶版）
C语言进阶——指针详解
都市隸人的博客
03-05 849
本文介绍了指针的有关知识，适合初学者食用
进阶指针【指针的进阶使用方法】
_featherbrain的博客
03-23 818
进阶指针目录前言字符指针指向字符指向字符串常量指向同一个字符串常量的字符指针指针数组指针数组的定义和使用数组指针数组指针的定义 前言 进阶指针，是指针的进阶用法，也是我们能不能掌握指针的关键所在。这里涉及到字符指针、指针数组、数组指针、函数指针、回调函数等，如果有哪里不对的地方可以直接指出。 字符指针 我们都知道在指针中有一种类型叫做字符指针，一般是指向一个字符的指针，还有一种指向字符串常量的就有点不同了。 指向字符 字符指针的一般写法，其含义就是指向字符W。 char* ptr = 'W';
C语言进阶——指针进阶
07-09 976
C语言指针进阶一、字符指针 指针的初阶我们可以参看这篇博客C语言初阶——指针 ，这篇博客主要有四个重要结论，也是初阶指针的重要概念： 1. 指针是地址，指针变量是一个变量，用来存放内存单元的地址，通过指针能找到以它为地址的内存单元。 2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。 3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。 4. 指针的运算。 下面我们将继续探讨指针的进阶部分 一、字符指针 在2.1指针的类型中我们知道有一种指针类型为字符指针 ch
第十三周进阶练习.zip_C语言_planet2h6
09-22
在本进阶练习中，我们将使用C语言来开发一个成绩录入系统。C语言是一种底层、高效且广泛应用的编程语言，适合实现系统级和性能敏感的应用程序。"planet2h6"可能代表项目的一个特定版本或迭代，暗示我们正在处理一个...
498446120315226692830 C语言程序设计进阶教程.7z
10-13
《C语言程序设计进阶教程》是一本专为已经掌握C语言基础知识的读者设计的教程。这本教程深入探讨了C语言的高级概念和技术，旨在帮助读者提升编程技能，掌握更复杂的程序设计方法。通过阅读这本书，学习者将能够更好...
Csharp通览(进阶).pdf
06-05
委托在C#中类似于C或C++中的函数指针，是一种引用类型变量，它引用了某个方法。委托可以在运行时改变所引用的方法。所有的委托都派生自System.Delegate类。声明委托决定了它所引用的方法类型。委托实例化需要使用new...
二叉树最小深度
2301_80161204的博客
09-27 466
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1277
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 367
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
最新发布
m0_57859086的博客
10-01 1001
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
C语言指针进阶：指向指针的指针与链表实现
"指向指针的指针是C语言中的一...第11章的"指针进阶"涵盖了C语言中一些高级的指针概念，它们对于深入理解和高效编程至关重要。通过对这些知识点的掌握，开发者能够编写出更灵活、更高效的代码，解决更复杂的编程问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值