前提
- 内存会划分为小的内存单元每个内存单元都有一个编号这个编号就被称谓地址把地址也叫指针
- 内存编号=地址=指针
- 指针或者地址,要存储，就可以存放到：指针变量中。
int* p;
- 指针的概念：
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节（32位平台/64位平台）。
- 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
- 指针的运算。
一、 字符指针 char*
int main()
{
const char* pstr = "hello bit.";
printf("%s\n", pstr);
return 0;
}
- 这并不是字符串 hello bit 放到字符指针 pstr 里了，而是把字符串
hello bit.首字符的地址放到了pstr中。 - 注意：
- 虽然指向字符串的首字符，但无法通过
*pstr="w";来修改首字符，因为常量字符串是无法修改的，所以要加上const
- 虽然指向字符串的首字符，但无法通过
相关面试题
#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指向的是一个同一个完全相同的常量字符串（不论是否加const都这样），所以C/C++会把常量字符串存储到单独的一个内存区域，来节省空间。当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。
- 但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。
- 所以str1和str2不同，str3和str4不同。
二、指针数组
1、说明（不常用）
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* parr[3] = { arr1, arr2, arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
//printf("%d ", parr[i][j]);
printf("%d ", *(parr[i]+j));
}
printf("\n");
}
return 0;
}
2、使用场景
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* parr[3] = { arr1,arr2, arr2 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j< 5; j++)
{
//printf("%d ", parr[i][j]);//类似模拟出一个二维数组
printf("%d "，*(parr[i]+j));//这两个写法都可以
}
printf("\n");
}
return 0;
}
- 🔺数组中[]表示一次解引用—>
arr[i] = *(arr+i)
三、数组指针
- 理解
- 类似：好孩子，前提是个孩子。
- 数组指针，前提是个指针。
1、int * p1[10];
- p1[10]：存放十个元素的数组
- 数组中的十个元素都是指针。
2、int (*p)[10];–>数组指针：指向数组的指针
- 解释：
- p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。
- 所以p是一个指针，指向一个数组，叫数组指针。
- 这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
int main()
{
int a = 10;
int* p = &a;
int arr[10] = {0};
//数组是首元素的地址
printf("%p\n", arr);//int*
printf("%p\n", arr+1);
printf("%p\n", &arr[0]);//int*
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);//int(*)[10]数组指针类型
printf("%p\n", &arr+1);
return 0;
}
-
运行结果：
-
问：p的类型
char* arr[5]; p=&arr;- p首先是指针(*p)=&arr
- 其次是含有5个元素的数组，并且是指向char*类型
- 故，char*(*p)[5]=&arr
3、数组名
[[章6 数组与函数#其他]]中第四点也有提及一下这点。
- 通常情况下，我们说的数组名都是数组首元素的地址，但是有2个例外：
- sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小
- &数组名，这里的数组名表示整个数组，&数组名，取出的是整个数组的地址
4、数组指针的使用
两种经典的写法
//形参写出数组
//void print1(int arr[], int sz)
//{
// int i = 0;
// for (i = 0; i < sz; i++)
// {
// printf("%d ", arr[i]);
// }
// printf("\n");
//}
//形参写成指针的形式
void print1(int* arr, int sz)//arr[]传入的是首元素的地址，即等价于*arr
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(arr + i));
}
printf("\n");
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//写一个函数打印arr数组的内容
int sz = sizeof(arr) / sizeof(arr[0]);
print1(arr, sz);
return 0;
}
- 若不小心传参的arr，误传成数组地址&arr
- 这不是推荐的写法！太多此一举了
void print1(int (*p)[10], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
//p 是整个个数组的地址
//*p 相当于拿到数组名，数组名又是首元素的地址，所以*p就是&arr[0]
//(*p + i)表数组中下标为i的元素的地址
//为了拿出该地址的元素内容，还要再解引用一次，故*(*p + i)
printf("%d ", *(*p + i));
}
printf("\n");
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//写一个函数打印arr数组的内容
int sz = sizeof(arr) / sizeof(arr[0]);
//
print1(&arr, sz);
return 0;
}
一维数组很少用数组指针，二维数组才会常用
//①写成数组的形式
//void print2(int arr[3][5], int c, int r)
//{
// int i = 0;
// for (i = 0; i < c; i++)
// {
// int j = 0;
// for (j = 0; j < r; j++)
// {
// printf("%d ", arr[i][j]);
// }
// printf("\n");
// }
//}
//②写成指针的形式
void print2(int(*p)[5], int c, int r)
{
int i = 0;
for (i = 0; i < c; i++)
{
int j = 0;
for (j = 0; j < r; j++)
{
//p+i是指向第i行的
//*(p+i)相当于拿到了第i行，也相当于第i行的数组名
//数组名表示首元素的地址，*(p+i) 就是第i行第一个元素的地址
printf("%d ", *(*(p + i) + j));
//printf("%d ", p[i][j]);
}
//arr[i]
//*(arr+i)
//
//arr[i][j]
//*(arr+i)[j]
//*(*(arr+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} };
//int (*ptr)[3][5] = &arr;
//写一个函数，打印arr数组
print2(arr, 3, 5);//三行五列，arr二维数组传入相当于降维了
return 0;
}
区分
int arr[5];
- arr是一个整形数组，每个元素是int类型的，有5个元素
int* parr1[10];
- parr1是一个数组，数组10个元素，每个元素的类型是int*
int(*parr2)[10] ;
- parr2是一个指向数组的指针，指向的数组有10个元素，每个元素的类型是int
int(*parr3[10])[5];
- parr3是一个数组，数组有10个元素，把数组名parr3去掉就是每个元素的类型int(*)[5]，即数组指针
- parr3是存放数组指针的数组
四、数组参数、指针参数
1、一维数组传参
#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);
}
2、二维数组传参
void test(int arr[3][5])//ok
{}
void test(int arr[][5])//可以省略行，不能省略列
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int (*arr)[5])//ok
{}
void test(int **arr)//ok
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}
- 二级指针是用来存放一级指针的地址的数组指针是用来存放数组的地址的
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;
}
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;
}
5、函数指针
- 指向函数的指针
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
- 函数指针变量
int test(char* str)
{
……
}
int main(){
//函数指针变量如下
int(*pt)(char*)=test;
}
- 详细介绍
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int arr[10];
//arr
//&arr
int (*p)[10] = &arr;//p是一个数组指针变量
printf("%p\n", &Add);
printf("%p\n", Add);
int (* pf)(int, int) = Add;//就是函数指针变量
//去掉变量名 int (* )(int, int)就是函数指针类型
// 0x0012ff40
int ret = (*pf)(2,3);//(*pf)找到函数、调用函数
//int ret = pf(2, 3);//此处*不管多少个、有没有，都没影响，但有*就要加括号内
printf("%d\n", ret);
return 0;
}
代码1：( *( void (*)() )0 )();
- 整体含义
- ①首先是把0强制类型转换为一个函数指针类型，这就意味着0地址处放一个返回类型是void，无参的一个函数
- ②调用0地址处的这个函数
int main()
{
//代码1
( *( void (*)() )0 )();
//void (*)() 是函数指针类型
//void (*p)()
//( void (*)() ) 强制类型转换
//(类型)
//( void (*)() )0 对0进行强制类型的转换
}
代码2：void (* signal(int, void(*)(int)) )(int);
int main()
{
//类比别的函数声明
//int Add(int, int);
//代码2
void (* signal(int, void(*)(int)) )(int);//函数声明
//signal是一个函数的声明
//signal函数的参数，第一个是int类型的，第二个是void(*)(int)的函数指针类型
//signal函数的返回值类型也是：void(*)(int)的函数指针
//void(*)(int) signal(int, void(*)(int));//err,但含义可这样理解
//简化上面函数声明的写法如下
//typedef void(* pf_t)(int) ;//给函数指针类型void(*)(int)重新起名叫：pf_t
//pf_t signal(int, pf_t);
return 0;
}
6、函数指针数组
- 存放函数指针的数组
函数指针数组例子
//函数指针数组
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()
{
//指针数组
//字符指针数组
char* arr[5];
//整形指针数组
int* arr2[4];
//int (*pf1)(int, int) = Add;
//int (*pf2)(int, int) = Sub;
//int (*pf3)(int, int) = Mul;
//int (*pf4)(int, int) = Div;
//函数指针数组
int (* pf[4])(int, int) = { Add, Sub, Mul, Div };
int i = 0;
for (i = 0; i < 4; i++)
{
int ret = pf[i](8, 2);
printf("%d\n", ret);
}
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");
}
- 不用函数指针数组，主函数用switch-case重复函数多,十分冗余
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do{
menu();
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;
}
- 主函数采用函数指针数组后
- 局限性在于函数指针数组中，函数结构（如：传入的参数和返回类型）要相同
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
//转移表（对于此处函数指针称谓，起一个跳转效果）
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };
do{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}
7、指向函数指针数组的指针
- 范例
int main()
{
//函数指针数组
int (*pfarr[4])(int, int) = {Add,Sub,Mul,Div};
int (*(* p3)[4])(int, int) = &pfarr;
//p3是一个指向函数指针数组的指针
int i = 0;
for (i = 0; i < 4; i++)
{
//①*p
//②*(p3+0)
//③p3[0]
//这三个可以等价代替
//int ret = (*p3)[i](3,4);
int ret = p3[0][i](3, 4);
printf("%d\n", ret);
}
return 0;
}
int (*(* p3)[4])(int, int)为什么不能是写成(int*)(*p3)[4](int,int)呢？- 是因为最内层的函数返回值是int，而不是int*
- 不管嵌套多少层，最左侧都只能是单独的int，因为最左侧是指向的是最内层的返回值（比如这里指向的最内层是函数，函数返回类型是int）
*p3 --> pfarr(*p3)[i]--->pfarr[i]- 图解
- p3是4/8个字节的指针，指向的是存放4个函数指针地址的数组指针
8、回调函数
定义
- 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
- 回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
void test()
{
printf("hehe\n");
}
void print_hehe(void (*p)()) //把test函数地址传递给该函数中所提供的接收指针
{
if (1)
p();//通过print_hehe来调用test函数
}
int main()
{
print_hehe(test);
return 0;
}
回调函数的应用1
- 回顾：[[指针进阶#函数指针数组的应用]]
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");
}
void calc(int (*pf)(int,int))
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pf(x, y);
printf("ret = %d\n", ret);
}
int main()
{
int input = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
calc(Add);
break;
case 2:
calc(Sub);
break;
case 3:
calc(Mul);
break;
case 4:
calc(Div);
break;
case 0:
printf("退出计算器\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}
回调函数的应用2
- qsort是一个库函数，基于快速排序
void qsort( void *base, //待排序数据的起始位置，且void能接受任意类型
size_t num, //数组的元素个数
size_t width, //一个元素的字节大小-->方便找下一个元素位置
int (*cmp)(const void *e1, const void *e2 ) //函数指针
// 比较函数 待比较的两个元素的地址
);
-
要求qsort函数的使用者，自定义一个比较函数
- 排序的整型数据：用> <
- 排序的结构体数据：可能不方便直接用> <比较了
- 使用者根据实际情况，提供一个函数，实现2个数据的比较
// 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]);
}
}
//void test1()
//{
// int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
// //排序为升序
// int sz = sizeof(arr) / sizeof(arr[0]);
// bubble_sort(arr, sz);
// print_arr(arr, sz);
//}
int main()
{
test1();
//int a = 10;
//float* pf = &a;//int*
//void* pf = &a;
//pf + 1;//err
//*pf;//err
return 0;
}
- qsort 排序大小
int cmp_int(const void* e1, const void* e2)
{
/*if (*(int*)e1 > *(int*)e2) //这样写法太复杂了
return 1;
else if (*(int*)e1 == *(int*)e2)
return 0;
else
return -1;*/
return (*(int*)e1 - *(int*)e2);
//正常逻辑e1>e2返回大于0就是升序，把e2和e1的位置交换，逻辑相反就是降序(如下)
//return (*(int*)e2 - *(int*)e1);
}
void test2()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
int main()
{
test2();
return 0;
}
- qsort 排序结构体
struct Stu
{
char name[20];
int age;
double score;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
//使用qsort排序结构体
void test3()
{
struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
int sz = sizeof(arr) / sizeof(arr[0]);
//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test3();
return 0;
}
- 改造更普遍的冒泡排序
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 num, int width, int (*cmp)(const void* e1, const void* e2))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
//if (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()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
int main()
{
test4();
return 0;
}
9、指针和数组笔试题解析
总结：数组名的意义
- sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小
- &数组名，这里的数组名表示整个数组，取出的是整个数组的地址
- 除此之外所有的数组名都表示首元素的地址
- 数组名没有取地址也没有sizeof，就表首元素地址
- 其他提及：[[指针进阶#3、数组名]]
一维数组
int main()
{
int a[] = { 1,2,3,4 };
// 0 1 2 3
int (*p)[4] = &a;
printf("%d\n", sizeof(a));//4*4 = 16
printf("%d\n", sizeof(a + 0));
//4/8 a+0是数组第一个元素的地址，是地址，大小就是4/8个字节
printf("%d\n", sizeof(*a));
//4 a表示数组首元素的地址，*a表示数组的第一个元素，sizeof(*a)就是第一个元素的大小-4
printf("%d\n", sizeof(a + 1));
//4/8 a表示数组首元素的地址，a+1数组第二个元素的地址，sizeof(a+1)就是第二个元素的地址的大小
printf("%d\n", sizeof(a[1]));
//4 计算的是第二个元素的大小
printf("%d\n", sizeof(&a));
//4/8 &a取出的是数组的地址，数组的地址也是地址呀，是地址大小就是4/8字节
printf("%d\n", sizeof(*&a));
//16 计算的整个数组的大小
printf("%d\n", sizeof(&a + 1));
//4/8 - &a是数组的地址，+1跳过整个数组，产生的4后边位置的地址
printf("%d\n", sizeof(&a[0]));
//4/8 取出的数组第一个元素的地址
printf("%d\n", sizeof(&a[0] + 1));
//4/8 数组第二个元素的地址
return 0;
}
字符数组
int main()
{
char arr[] = { 'a','b','c','d','e','f' };
//[a b c d e f]
printf("%d\n", strlen(arr));
//随机值，arr数组中没有\0，所以strlen函数会继续往后找\0，统计\0之前出现的字符个数
printf("%d\n", strlen(arr + 0));
//随机值，arr+0还是数组首元素的地址
printf("%d\n", strlen(*arr));
//err - arr是数组首元素的地址，*arr是数组的首元素，‘a’-97
//虽然得到了97的地址，但我们不能访问的
printf("%d\n", strlen(arr[1]));
//err -'b' - 98
printf("%d\n", strlen(&arr));
//随机值
printf("%d\n", strlen(&arr + 1));
//随机值
printf("%d\n", strlen(&arr[0] + 1));
//随机值
printf("%llu\n", sizeof(arr));
//6
printf("%llu\n", sizeof(arr + 0));
//4/8 arr + 0是数组首元素的地址
printf("%llu\n", sizeof(*arr));
//1 - *arr是首元素，首元素是一个字符，大小是一个字节
printf("%llu\n", sizeof(arr[1]));
//1 - arr[1]是数组的第二个元素，大小是1个字节
printf("%llu\n", sizeof(&arr));
//4/8 &arr是数组的地址
printf("%llu\n", sizeof(&arr + 1));
//4/8 &arr + 1是从数组地址开始向后跳过了整个数组产生的一个地址
printf("%llu\n", sizeof(&arr[0] + 1));
//4/8 &arr[0] + 1 是数组第二个元素的地址
return 0;
}
sizeof是一个操作符
- sizeof 计算的是对象所占内存的大小—单位是字节,size_t
- 不在乎内存中存放的是什么，只在乎内存大小
strlen 库函数
- 求字符串长度，从给定的地址向后访问字符，统计
\0之前出现的字符个数
字符串数组
int main()
{
char arr[] = "abcdef";
//[a b c d e f \0]
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，从b的位置开始数
printf("%d\n", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8 arr+0是数组首元素的地址
printf("%d\n", sizeof(*arr));//1 - *arr 数组的首元素
printf("%d\n", sizeof(arr[1]));//1 arr[1]数组的第二个元素
printf("%d\n", sizeof(&arr));//4/8 - &arr数组的地址，但是数组的地址依然是地址，是地址大小就是4/8
printf("%d\n", sizeof(&arr + 1));//4/8 - &arr + 1是\0后边的这个地址
printf("%d\n", sizeof(&arr[0] + 1));//4/8 - &arr[0] + 1是数组第二个元素的地址
int main()
{
char* p = "abcdef";//p存的是a的地址
//练习①
printf("%d\n", strlen(p));
//6 -- p是存a的地址，从a开始数到\0,，共6个
printf("%d\n", strlen(p + 1));
//5 -- 从b的位置开始向后数字符
//printf("%d\n", strlen(*p));
//err -- p就是a地址，*p就是a，把a传给strlen是错误的
//printf("%d\n", strlen(p[0]));
//err -- p[0]=*p,错误如上
printf("%d\n", strlen(&p));
//随机值 -- &p取出p的地址，和abcdef无关了已经
printf("%d\n", strlen(&p + 1));
//随机值 -- 如图示①
printf("%d\n", strlen(&p[0] + 1));
//5 -- &p[0]即&(*p),就是a，+1后就是从b的位置开始向后数字符
//练习②
printf("%d\n", sizeof(p));
//4/8 p是指针变量，计算的是指针变量的大小
printf("%d\n", sizeof(p + 1));
//4/8 p+1是'b'的地址
printf("%d\n", sizeof(*p));
//1 -- *p 其实就是'a'
printf("%d\n", sizeof(p[0]));
//1 -- p[0]-> *(p+0)-> *p
printf("%d\n", sizeof(&p));
//4/8 -- &p是指针变量p在内存中的地址
printf("%d\n", sizeof(&p + 1));
//4/8 -- &p+1是跳过p之后的地址
printf("%d\n", sizeof(&p[0] + 1));
//4/8 -- &p[0]是‘a’的地址，&p[0]+1就是b的地址
二维数组
int main()
{
//二维数组
int a[3][4] = { 0 };
printf("%d\n", sizeof(a));
//计算的是整个数组的大小，单位是字节3*4*4 = 48
printf("%d\n", sizeof(a[0][0]));
//4 第1行第一个元素的大小
printf("%d\n", sizeof(a[0]));
//16 -- a[0]是第一行的数组名，sizeof(a[0])就是第一行的数组名单独放在sizeof内部，计算的是第一行的大小
printf("%d\n", sizeof(a[0] + 1));
//4/8 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/8 - a表示首元素的地址，a是二维数组，首元素的地址就是第一行的地址
//所以a表示的是二维数组第一行的地址，a+1就是第二行的地址
printf("%d\n", sizeof(*(a + 1)));
//16 -- 对第二行的地址解引用访问到就是第二行
//*(a+1) -> a[1] --> sizeof(a[1])
printf("%d\n", sizeof(&a[0] + 1));
//4/8 - a[0]是第一行的数组名，&a[0]取出的就是第一行的地址
//&a[0] + 1 就是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));
//16 -- 对第二行的地址解引用访问到就是第二行
printf("%d\n", sizeof(*a));
//16 - a就是首元素的地址，就是第一行的地址，*a就是第一行
//*a - > *(a+0) -> a[0]
printf("%d\n", sizeof(a[3]));
//16 -- 类型：int [4]
//int a = 10;
//printf("%d\n", sizeof(a));//4
//printf("%d\n", sizeof(int));//4
return 0;
}
- arr[i]只是形式上这么些（为了方便初学理解），底层本质上是*(arr+i)
10、指针笔试题
笔试题1
- 程序的结果是什么？
- 2 5
- 把数组指针转换为整型指针，步长变小了
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1); //原本&a-->int(*)[5]，故要强制类型转换成int*
printf( "%d,%d", *(a + 1), *(ptr - 1));
// 2 5
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()
{
p=(struct Test*)0x100000
printf("%p\n", p + 0x1); ①
printf("%p\n", (unsigned long)p + 0x1); ②
printf("%p\n", (unsigned int*)p + 0x1); ③
return 0;
}
- 指针类型决定了指针+1是加几个字节
- ①0x100000+20（一个结构体的大小）=0x100014（16进制）
- ②整型long大小就是一个字节+0x1（一个long类型的大小，一个字节）=0x100001
- ③一个int* 类型的大小，4个字节=0x100004
笔试题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;
}
- %#x会在输出前加个0x
笔试题4
- 结果：1
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
// 1 3 5
//此处是逗号表达式，若是二维数组则应该用大括号括起来
// {0, 1}, {2, 3}, {4, 5}
int *p;
p = a[0];
printf( "%d", p[0]); //p[0]=a[0][0]
return 0;
}
笔试题5
int main()
{
int a[5][5];
int(*p)[4]; //p是数组指针，指向的数组是4个元素
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
p[4][2]-->*(*(p+4)+2)- 指针-指针得到的是指针之间元素的个数
- 低地址-高地址为负数
- -4以%p的形式打印
- 图示：
![![[Pasted image 20220715203956.png]]](https://img-blog.csdnimg.cn/34e6998cfb0a4e2eac297429e46edb65.png)
笔试题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表第一行的地址，+1后就是第二行的地址，一旦*接引用，就表第二行首元素地址
//*(aa + 1)也可表aa[1],即第二行的取地址，数组首元素地址
//ptr2就是指向6
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
// 10 5
return 0;
}
- 图示：
![![[Pasted image 20220715211301.png]]](https://img-blog.csdnimg.cn/de826146e2044baf969d8ed336f79493.png)
笔试题7
#include <stdio.h>
int main()
{
char* a[] = {"work","at","alibaba"};
//每个字符串的首元素的地址传到char*的指针数组里去
char**pa = a;
//a的每个元素都是char*
//一级指针char*的地址放到二级指针变量pa里头去
pa++;
printf("%s\n", *pa);
return 0;
}
- 结果：a
![![[Pasted image 20220715212815.png]]](https://img-blog.csdnimg.cn/550959dfb36a4b498d3bbcbe24cfd5b4.png)
笔试题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);
//++ → 从cp[0]指向cp[1],即c+2;
//解引用，通过c+2的地址访问了POINT的首元素P，并向后打印得POINT
printf("%s\n", *--*++cpp+3);
//先算++ → 指向cp[2];
//再*解引用 → 取出cp[2]的内容c+1，
//再-- → c+1-1=c，cp[2]的原内容c+1被修改成c
//再*解引用 → 找到c的空间后，指向首元素E
//最后+3 → 指向ENTER的第四个元素E，并向后打印，得ER
printf("%s\n", *cpp[-2]+3);
//*cpp[-2]+3,即**(cpp-2)+3
//cpp-2 → cpp指向了cp[0]，但并不会使得cpp改变
//解引用找到c[3]的空间，指向FIRST的首元素F
//+3 → 指向S元素，并向后打印，得ST
printf("%s\n", cpp[-1][-1]+1);
//cpp[-1][-1]，即* (*(cpp-1) -1) +1
//cpp-1 → 指到cp[1]处
//*(cpp-1)→通过地址找到c+2
//*(cpp-1) -1 → c+2-1=c+1
//再解引用 → 通过c+1地址找到c[1]位置，即“NEW”，指向首元素“N”
//+1 → 指向“E”，并向后打印，得EW
return 0;
}
- 结果：POINT；ER；ST；EW
- 图示：
-
最初
-
最后
-
- 🔺 注意转化：a[1] --> *(a+1)
![![[Pasted image 20220715220222.png]]](https://img-blog.csdnimg.cn/bcbfbbd2ddd2440f82660d7e226d6106.png)
![![[Pasted image 20220715220148.png]]](https://img-blog.csdnimg.cn/d97325f0efea4fb28281ad13cb05af7e.png)
碎碎念
本章节的笔记是我先在本地obsidian中完成后，再传至CSDN中，故文中存在些链接其他文件的段落，但无法查看的情况。
说起来已经是第三次学指针。第一次囫囵吞枣，第二次还是有点稀里糊涂，第三次是因为数据结构学习有困难，回头再重过一遍C语言，又到了指针部分，有幸听到好老师细致的讲解，详细做了笔记。
每次学习指针，都有新的收获和体会，但即使如此自己也深知学的仍不够扎实。希望分享笔记和大家共同进步。