指针进阶（1）
文章目录
- 目录
- 1. 字符指针
- 2. 指针数组
- 3. 数组指针
- 3.1 数组指针的定义
- 3.2 &数组名VS数组名
- 3.3 数组指针的使用
- 4. 数组参数、指针参数
- 4.1 一维数组传参
- 4.2 二维数组传参
- 4.3 一级指针传参
- 4.4 二级指针传参
- 5. 函数指针
目录
- 字符指针
- 数组指针
- 指针数组
- 数组传参和指针传参
- 函数指针
- 函数指针数组
- 指向函数指针数组的指针
- 回调函数
- 指针和数组面试题的解析
1. 字符指针
在指针的类型中我们知道有一种指针类型为字符指针 char* 。
一般是这样使用:
int main()
{
char ch = 'w';
//ch = 'a';
char* pc = &ch;//pc就是字符指针
*pc = 'a';
return 0;
}
还有一种使用方式如下：
#include <stdio.h>
int main()
{
char arr[] = "abcdef";
//[a b c d e f \0]
const char* p = "abcdef";//常量字符串
printf("%s\n", p);//abcdef
printf("%c\n", *p);//a
return 0;
}
代码 const char* p = “abcdef”; 并不是把字符串 abcdef 放到字符指针 p 里去，而是把字符串 abcdef 首字符的地址放到 p 中去；同时，因为 abcdef 是一个常量字符串，所以要用 const 进行修饰，以保证 p 中的内容不会被修改。
注：
不能被改变的常量的数据是放在代码区的，比如代码、常量字符串等等。
有这样一道面试题：
#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;
}
首先，我们要知道数组名就是数组首元素的地址，因为 str1 和 str2 是两个不同的数组，所以 str1 和 str2 不相等；而常量字符串是不允许修改的，所以在内存中只需要存一份就可以了，又因为 str3 和 str4 中存的是字符串首字符的地址，所以 str3 和 str4 相等。
2. 指针数组
//指针数组
//整型数组 - 存放整型的数组
//字符数组 - 存放字符的数组
//指针数组 - 存放指针的数组
int main()
{
int* arr[10];//存放整型指针的数组
return 0;
}
使用指针数组模拟实现二维数组：
#include <stdio.h>
int main()
{
int arr1[] = { 1, 2, 3, 4, 5 };//arr1 - int*
int arr2[] = { 2, 3, 4, 5, 6 };
int arr3[] = { 3, 4, 5, 6, 7 };
//指针数组
int* arr[3] = { arr1, arr2, arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
3. 数组指针
3.1 数组指针的定义
通过类比：
整型指针：能够指向整型数据的指针
浮点型指针：能够指向浮点型数据的指针
我们可以得知：
数组指针应该是：能够指向数组的指针
3.2 &数组名VS数组名
//数组名的理解
//数组名是数组首元素的地址
//有2个例外：
//1. sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
//2. &数组名，这里的数组名表示整个数组，&数组名取出的是整个数组的地址
//除此之外，所有的地方的数组名都是数组首元素的地址
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr[0]);
return 0;
}
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%d\n", sizeof(arr));
return 0;
}
#include <stdio.h>
int main()
{
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;
}
//对于数组名来说
//&数组名得到的是数组的地址
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int (*p)[10] = &arr;//数组的地址，存储到数组指针变量
//解释：p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组，所以p是一个指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
return 0;
}
3.3 数组指针的使用
打印数组中的每个元素：
#include <stdio.h>
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
也可以通过数组指针来实现：
#include <stdio.h>
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int (*p)[10] = &arr;//*&arr --> arr
int i = 0;
for (i = 0; i < 10; i++)
{
//printf("%d ", *((*p) + i));
printf("%d ", (*p)[i]);
}
return 0;
}
但是在这种情况下使用数组指针并不方便，那么数组指针怎么使用呢？
一般在二维数组上才方便
//1 2 3 4 5
//2 3 4 5 6
//3 4 5 6 7
//二维数组传参，形参是二维数组的形式
#include <stdio.h>
void Print(int arr[3][5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", 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 };
Print(arr, 3, 5);
return 0;
}
//二维数组传参，形参是指针的形式
#include <stdio.h>
void Print(int (*p)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
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 (*parr3[10])[5];
首先， parr3 和 [ ] 结合，说明 parr3 是一个数组，而数组中的每个元素是数组指针类型，每个元素指向一个有五个元素的整型数组；也就是说 parr3 这个数组里可以存10个 int (*)[5] 类型的数组指针。
4. 数组参数、指针参数
4.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);
return 0;
}
4.2 二维数组传参
void test(int arr[3][5])//ok
{
}
void test(int arr[][])//err 形参部分，行可以省略，但是列不能省略。
{
}
void test(int arr[][5])//ok
{
}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//err
{
}
void test(int* arr[5])//err 这里的形参是指针数组
{
}
void test(int (*arr)[5])//ok
{
}
void test(int** arr)//err
{
}
int main()
{
int arr[3][5] = {0};
test(arr);
return 0;
}
总结：
//一维数组传参，形参的部分可以是数组，也可以是指针
void test1(int arr[5], int sz)
{
}
void test2(int* p, int sz)
{
}
int main()
{
int arr[5] = { 0 };
test1(arr, 5);
test2(arr, 5);
return 0;
}
//二维数组传参，形参的部分可以是数组，也可以是指针
void test3(char arr[3][5], int r, int c)
{
}
void test4(char(*p)[5], int r, int c)
{
}
int main()
{
char arr[3][5] = { 0 };
test3(arr, 3, 5);
test4(arr, 3, 5);
return 0;
}
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]);
print(p, sz);
return 0;
}
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
void test(char* p)
{
}
int main()
{
char ch = '2';
char* ptr = &ch;
char arr[] = "abcdef";
test(&ch);
test(ptr);
test(arr);
return 0;
}
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 n = 'a';
char* p = &n;
char** pp = &p;
char* arr[5];
test(&p);
test(pp);
test(arr);
return 0;
}
5. 函数指针
//函数指针 - 指向函数的指针
//数组指针 - 指向数组的指针
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
//int arr[10] = { 0 };
//int (*pa)[10] = &arr;
printf("%p\n", &Add);
printf("%p\n", Add);
//函数名是函数的地址
//&函数名也是函数的地址
int (*pf)(int, int) = &Add;//pf是函数指针变量
//int (*)(int, int) 是函数指针类型
return 0;
}
再举一个例子：
void test(char* pc, int arr[10])
{
}
int main()
{
void (*pf)(char*, int[10]) = &test;
void (*pf)(char*, int[10]) = test;
void (*pf)(char*, int[]) = &test;
void (*pf)(char*, int*) = &test;
return 0;
}
那么，函数指针如何使用呢？
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
//int (*pf)(int, int) = &Add;
int (*pf)(int, int) = Add;
int r = Add(3, 5);
printf("%d\n", r);
//int m = (*pf)(4, 5);
int m = pf(4, 5);
printf("%d\n", m);
return 0;
}
以下是两段有趣的代码：
//0 - int
//0 - int*
//0x0012ff40 - int
//0x0012ff40 - int*
//void (*p)() - p是函数指针
//void (*)()是函数指针类型
int main()
{
//调用0地址处的函数
//1. 将0强制类型转换为void (*)() 类型的函数指针
//2. 调用0地址处的这个函数
(*(void (*)())0)();
return 0;
}
int main()
{
//signal 是一个函数声明
//signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(*)(int) 函数指针类型
//该函数指针指向的函数有一个int类型的参数，返回类型是void
//signal 函数的返回类型也是void(*)(int) 函数指针类型，该函数指针指向的函数有一个int类型的参数，返回类型是void
void (*signal(int, void(*)(int)))(int);
return 0;
}
第二段代码看上去非常复杂，应该如何简化呢？
我们先来看一下typedef的用法：
typedef unsigned int uint;
typedef int* ptr_t;
typedef int (*parr_t)[10];
typedef int (*pf_t)(int, int);
int main()
{
uint u1;
ptr_t p1;
int* p2;
return 0;
}
因此，我们可以这样进行简化：
int main()
{
typedef void (*pf_t)(int);
pf_t signal(int, pf_t);
void (*signal(int, void(*)(int)))(int);
return 0;
}