指针
指针的概念
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节（32位平台/64位平台）。
- 指针是有类型，指针的类型决定了指针±整数的步长，指针解引用操作的时候的权限。
- 指针的运算。
一、字符指针
在指针的类型中有一种指针类型为字符指针char*。
使用方式一：
int main()
{
char ch = 'w';
char* pc = &ch;
*pc = 'w';
return 0;
}
使用方式二：
int main()
{
const char* pstr = "I love you";
printf("%s\n", pstr);
return 0;
}
使用方式二中的代码const char* pstr = "I love you";的意思是把一个常量字符串的首字符I的地址存放到指针变量sptr中。
分析一道面试题：
#include <stdio.h>
int main()
{
char str1[] = "I love you.";
char str2[] = "I love you.";
const char* str3 = "I love you.";
const char* str4 = "I love you.";
if(str1 == str2)
printf("str1 and atr2 are same\n");
else
printf("str1 and atr2 are not same\n");
if(str3 == str4)
printf("str3 and atr4 are same\n");
else
printf("str3 and atr4 are not same\n");
return 0;
}
//输出的结果是：str1 and atr2 are not same
// str3 and atr4 are same
因为这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域。当几个指针，指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的字符串去初始化不同点数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。
二、指针数组
指针数组就是一个存放指针的数组。
int* arr[10];//整形指针的数组
char* arr2[4];//一级字符指针的数组
char** arr3[5];//二级字符指针的数组
三、数组指针
1.数组指针的定义
整形指针：int* pint;能够指向整形数据的指针。
浮点型指针：float* pf;能够指向浮点型数据的指针。
故数组指针应该是：能够指向数组的指针。
观察下列代码哪个是数组指针？
int *p1[10];
int (*p2)[10];
解释：
p1先和[ ]结合，说明p1是一个数组，是存放了十个整形指针的指针数组。p2先和*结合，说明p2是一个指针变量，然后指针指向的是一个大小为10个整形的数组。所以p2是一个指针，指向一个数组，叫数组指针。
注意：[ ]的优先级要高于号，所以必须加上（）来保证p先于结合。
2.&数组名VS数组名
我们先分析两段代码：
//代码一
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("&arr = %p\n", &arr);
return 0;
}
//打印的结果是：arr = 00EFF920
// &arr = 00EFF920
//代码二
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("arr+1 = %p\n", arr+1);
printf("&arr = %p\n", &arr);
printf("&arr+1 = %p\n", &arr+1);
return 0;
}
//打印的结果是：arr = 0133FBB0
// arr+1 = 0133FBB4
// &arr = 0133FBB0
// &arr+1 = 0133FBD8
我们先分析代码一发现数组名和&数组名打印的地址是一样的。但是我们在分析代码二又发现数组名和&数组名虽然值是一样的，但是意义应该不一样。
实际上：&arr表示的是数组的地址，而不是数组首元素的地址。在代码二中&arr的类型是：int(*)[10]，是一种数组指针类型数组的地址+1，跳过了整个数组的大小，所以&arr+1相对于&arr的差值是40。
3.数组指针的使用
一个数组指针的使用：
#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;
回顾之前的知识看看下列代码的意思：
int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];
- 第一个是一个整型数组，有5个元素，每个元素是
int类型的。- 第二个是一个指针数组，有10个元素，每个元素是
int*类型的。- 第三个是一个数组指针，该指针指向的是一个有10个元素的数组，每个元素是
int类型的。- 第四个是一个数组，数组有10个元素，数组的每个元素类型是int(*)[5]的数组指针类型。
四、数组参数and指针参数
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[10] = {0};
test(arr);
test2(arr2);
return 0;
}
2.二维数组传参
//正确的传参
#include <stdio.h>
void test(int arr[3][5])
{}
void test(int arr[][5])
{}
void test(int (*arr)[5])
{}
//错误的传参
void test(int arr[][])
{}
void test(int* arr)
{}
void test(int* arr[5])
{}
void test(int** arr)
{}
int main()
{
int arr[3][5] = {0};
test(arr);
return 0;
}
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;
}
思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
#include <stdio.h>
void test1(int* p)
{}
//test1能接收的函数
int main()
{
int a = 10;
int* p1 = &a;
test1(&a);
test1(p1);
return 0;
}
void test2(char* p)
{}
//test2能接收的函数
int main()
{
char ch = 'w';
char* p2 = &ch;
test2(&ch);
test2(p2);
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;
}
思考：
当函数的参数为二级指针的时候，可以接收什么参数？
#include <stdio.h>
void test(char** p)
{}
int main()
{
char c = 'w';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);
return 0;
}
五、函数指针
先看一段代码:
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
//输出的结果是：013211DB
// 013211DB
输出的两个地址相同，都是test函数的地址。
为了保存函数的地址我们书写了以下代码：
#include <stdio.h>
void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void* pfun2();
首先，能存放地址的是指针，就要知道pfun1和pfun2哪个才是指针？
分析：
pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回类型是void。
而pfun2先和()结合，说明了pfun2是函数，函数的返回类型是void*。
六、函数指针数组
我们之前学到过指针数组，是说一个数组里面存放的每个元素都是指针。
比如：
int* arr[10];
//数组的每一个元素是int*
那么把函数的地址存放到一个数组中，这个数组就叫函数指针数组，那函数指针数组应该如何定义？
int (*parr1[10])();
int* parr2[10]();
int (*)() parr3[10];
答案是：parr1
因为parr1先和[ ]结合，说明了parr1是数组，数组的内容是int (*)()类型的函数指针。
函数指针数组的用途：转移表
例子：（计算器）（这里使用了后面回调函数的内容如果不懂可以先去看回调函数部分的内容）
#include <stdio.h>
void menu()
{
printf("******************************\n");
printf("****** 1.add 2.sub ******\n");
printf("****** 3.mul 4.div ******\n");
printf("****** 0.exit ******\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;
}
void Calc(int (*pf)(int, int))
{
int x = 0;
int y = 0;
printf("请输入两个操作数>");
scanf("%d%d", &x, &y);
printf("%d\n", pf(x, y));
}
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;
}
我们对其进行改进，使用函数指针数组来实现：
#include <stdio.h>
void menu()
{
printf("******************************\n");
printf("****** 1.add 2.sub ******\n");
printf("****** 3.mul 4.div ******\n");
printf("****** 0.exit ******\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 x = 0;
int y = 0;
int(*pfArr[5])(int, int) = { 0,Add,Sub,Mul,Div };
do
{
menu();
printf("请输入>");
scanf("%d", &input);
if (input <= 4 && input >= 1)
{
printf("请输入两个操作数>");
scanf("%d%d", &x, &y);
int ret = pfArr[input](x, y);
printf("%d\n", ret);
}
else if (input == 0)
{
printf("退出！\n");
}
else
{
printf("选择错误！\n");
}
} while (input);
return 0;
}
七、指向函数指针数组的指针
首先，指向函数指针数组的指针是一个指针。指针指向一个数组，数组的元素都是函数指针。
定义方法：
#include <stdio.h>
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];
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}
八、回调函数
回调函数就是一个通过函数指针调用的函数。如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指的函数时，我们就说这是回调函数。回调函数不是由该函数的实现直接调用，而是在特定的事件或条件发生时有另一方调用的，用于对该事件或条件进行响应。
首先演示一下qsort函数的使用：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int cmp_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
int main()
{
int arr[10] = { 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);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
我们再使用回调函数，模拟实现qsort（采用冒泡的方式）。
#include <stdio.h>
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++;
}
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(void* e1, void* e2))
{
int i = 0;
for (i = 0; i < sz; i++)
{
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubblle_sort(arr, sz, sizeof(arr[0]), cmp_int);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
九、巩固练习
为了更好的吸收上面的知识我们来分析两道例题：
例题一
#include <stdio.h>
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int* ptr = (int *)(&a + 1);
//因为&a是整个数组的地址+1就代表跳过了整个数组。
//所以指针ptr指向的是数组a后面的地址。
printf("%d,%d", *(a + 1), *(ptr - 1));
//首先单独的数组名a代表首元素地址+1代表第二个元素的地址再进行解引用操作得到第二个元素为2。
//然后ptr是数组a后面的地址那么-1就得到数组a最后一个元素的地址再进行解引用操作得到最后一个元素为5。
return 0;
}
//输出的结果是：2
// 5
例题二
#include <stdio.h>
int main()
{
int a[4] = { 1, 2, 3, 4 };
int* ptr1 = (int *)(&a + 1);
//因为&a是整个数组的地址+1就代表跳过了整个数组。
//所以指针ptr1指向的是数组a后面的地址。
int* ptr2 = (int *)((int)a + 1);
//因为单独的数组名a代表首元素地址然后强制类型转换成int类型再+1后再取地址就相对于只偏移了1个字节。
printf("%x,%x", ptr1[-1], *ptr2);
//因为ptr1指向的是数组a的后面所以ptr1[-1]代表的就是数组a的最后一个元素输出十六进制数前面的0省略结果为4。
//低地址 高地址
//小端存储模式
//a(01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00)
// ^
// |
//ptr2所指的位置
//根据上图可知ptr2所指的位置那么输出的十六进制数是02 00 00 00前面的0省略结果为2000000。
return 0;
}
//输出的结果是：4
// 2000000
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
