一篇文章带你深入了解“指针”
希望这篇博客可以带领你重新学习指针,其实指针很简单,指针就是一个逻辑题,多想想就会了.同时也希望我的这篇指针可以可以指引方向
内存和地址
我们知道，每一台电脑都有内存，内存有8G，16G，32G等等。
计算机的CPU（中央处理器）在处理数据时，需要将数据从内存中读取出来，然后再将处理后的数据放回到内存中。
计算机中内存被划分为一个个内存单元，每一个内存单元占用一个字节。
下面是计算机中经常见到的计算单位：
bit-----比特位
Byte-----字节
KB-----千字节
MB-----兆
GB-----吉咖字节
TB
PB
它们之间的换算为:
1 Byte = 8 bit
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
CPU在访问内存中每个字节的空间时,必须其所在空间的内存单元编号,我们可以称之为地址,在C语言中被称为"指针".
- 了解指针,必须先要了解地址,我们现在所使用的机器都是64位机器,我们假设在32位机器上,32位机器有32个地址总线,每根线有俩种形态,表示0或者1,表示电脉冲的有无.那么我们就可以知道,一根线可以表示俩种可能,俩根线就有四种可能,在32位机器上就有2^32种可能.
当地址信息被被下达给内存,就可以通过地址信息找到对应内存中的数据,然后数据会通过数据总线传入CPU寄存器.
了解指针
在计算机科学中,指针是编程语言的一个对象,通过地址可以直接指向存在电脑存储器中另一个地方的值.
- 总的来讲,指针就是变量,用来存放内存单元的地址.
- &(取地址操作符),可以查找到所保存的数据的地址.
- 通过打印的方式,找到存放a的地址
这里要注意的是,每一次运行的时候,内存都会开辟不同的空间来存放数据,所以内存也会不同.
- 我们可以将变量a的地址存在一个指针变量里面,而此时p的类型为int*,*说明了p是一个指针变量,可以存放一个地址,而前面的int说明了p指向的是一个整型类型的变量a.
- 此时,我们使用*(解引用操作符),*p的意思是通过p的存放的地址,找到指向的空间,将所指向的空间里的值改为10.
在这里,*p等价于a,可以理解为p是a的地址
此时,我们大概了解了指针是什么,那么这个指针变量是否占用空间呢?
- 我们应该清楚,每个数据的地址是不会占用空间的,而当一个指针变量将地址保存起来,这个指针变量就会占用一定空间.
int main(void)
{
printf("%zd\n", sizeof(int*));
printf("%zd\n", sizeof(char*));
printf("%zd\n", sizeof(float*));
printf("%zd\n", sizeof(double*));
return 0;
}
从这里我们可以知道,在x86(即32位机器)环境下,指针变量的大小只有4个字节.
- 之前我们讲过在32位机器下,假设有32个地址总线,每根地址总线的电信号转换为数字信号,只有0和1俩种情况,将32根地址线产生的二进制当作一个地址,那么一个地址在存储的时候就会占用32个bit位,也就是4个Byte(字节).
- 同样,在x64(即64位机器)环境下,个地址在存储的时候就会占用64个bit位,也就是8个Byte(字节).
指针类型
之前我们所了解,在定义一个变量的时候,变量前面的type(类型)是用来决定这个变量所占内存大小的.
int main(void)
{
int a = 0;
char b = 'B';
float c = 1.5;
return 0;
}
而在了解到指针变量所占的内存空间只有4或8个字节的时候,我们所定义的指针类型是否没有意义.
- 首先,我们先了解指针的类型
int main(void)
{
int* pi = NULL;
char* pc = NULL;
short* ps = NULL;
long* pl = NULL;
long long* pll = NULL;
float* pf = NULL;
double* pd = NULL;
return 0;
}
- 指针定义方式是type *+name.
而在这里,char * 是为了存储char变量类型的地址,int * 是为了存储int变量类型的地址,short * 是为了存储short变量类型的地址, long * 是为了存储long变量类型的地址,long long * 是为了存储long long变量类型的地址,float * 是为了存储float变量类型的地址,double * 是为了存储double变量类型的地址.
int main(void)
{
int a = 0X11223344;
int* pa = &a;
*pa = 0;
return 0;
}
- 使用指针改变int的变量的值,由于int是4个字节,所以*pa改变了四个字节的数据.
int main(void)
{
int a = 0X11223344;
char* pc = (char* )&a;
*pc = 0;
return 0;
}
- 当我们将一个int类型的数据强制类型转换为char*指针类型时,*pc改变的值为char类型的长度.
由此我们可以得出结论:
指针的类型决定了,对指针解引用操作的权限的大小.
char* 可以访问1个字节
int* 可以访问4个字节
short* 可以访问2个字节
…
const修饰指针
int main(void)
{
int a = 10;
a = 20;
//打印
printf("%d\n",a);
return 0;
}
通常来讲,在使用一个类型定义变量的时候,这个变量都是可以被修改的.
int main(void)
{
const int b = 10;
b = 30;
return 0;
}
当我们在类型前面定义const,可以限制变量,使得变量不能被修改.
int main(void)
{
const int c = 10;
int* pc = &c;
*pc = 20;
//打印
printf("%d\n",c);
return 0;
}
但是我们使用指针变量将变量的地址存储起来,解引用指针变量的值却可以改变变量的值.
int main(void)
{
int d = 10;
int f = 20;
const int* p = &d;
*p = 30;
p = &f;
return 0;
}
当const在类型左边时,指针指向的内容不能通过指针改变,但是指针本身的内容可以改变.(换一种说法,就是指针指向的数据不能改变,但是存在在指针变量里的地址可以改变)
int main(void)
{
int d = 10;
int f = 20;
int const * p = &d;
*p = 30;
p = &f;
return 0;
}
当const在类型和*中间时,和const在类型左边时的情况相同,指针指向的内容不能通过指针改变,但是指针本身的内容可以改变.(换一种说法,就是指针指向的数据不能改变,但是存在在指针变量里的地址可以改变)
int main(void)
{
int d = 10;
int f = 20;
int* const p = &d;
*p = 30;
p = &f;
return 0;
}
当const在*的右边时,此时指针指向的内容可以被改变,但是指针本身的内容不可以被改变.(换言之,指针指向的数据可以被改变,但是指针变量中存储的地址不能被改变)
int main(void)
{
int d = 10;
int f = 20;
int const * const p = &d;
*p = 30;
p = &f;
return 0;
}
当*俩边都放const时,即结合了上面的俩种情况,指针指向的内容不能被改变,指针本身的内容也不能被改变.
从上面的例子中,我们可以总结除:
1.const放在 * 左边时,修饰的时指针指向的内容,保证指针指向的内容不能通过指针改变,但是指针变量本身的内容可以被改变.
2.const放在 * 右边时,修饰的时指针变量本身,保证指针变量本身的内容不能修改,但是指针指向的内容可以通过指针所改变.
3.const放在 * 左右俩侧时,可以同时修饰指针指向的内容和指针变量本身.
指针的运算
指针与整数之间的运算
int main(void)
{
int arr[5] = { 1,2,3,4,5 };
int* pa = arr;//arr等价于&arr[0]
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ",*pa);
pa = pa + 1;//pa++;
}
return 0;
}
指针在通过+或者-整数时,可以跳过一个指针变量类型的字节(例如,int跳过4个字节,char跳过1个字节等等)
指针与指针之间的运算
int main(void)
{
int arr[5] = { 1,2,3,4,5 };
//将p1指向3
int* p1 = arr;
p1 += 3;
//p2指向1
int* p2 = arr;
//打印p1到p2的距离
printf("%d\n", p1 - p2);
return 0;
}
指针与指针之间±可以计算出指针之间的距离.
值得注意的是:指针与指针之间的计算一般只能在数组中进行.
标准规定:允许指向元素的指针,与指向数组元素最后一个元素后面的那个内存位置的指针进行比较,但是不允许与指向数组元素第一个元素前面的那个内存位置的指针进行比较.
指针的关系运算
int main(void)
{
int arr[5] = { 1,2,3,4,5 };
//将p1指向3
int* p1 = &arr[0];
p1 += 3;
//p2指向1
int* p2 = arr;
//比较俩个指针变量
if (p1 > p2)
{
printf("Yes\n");
}
return 0;
}
指针与指针之间进行比较,比较的是指针变量中的地址.而且同时我们可以发现,数组是由高地址到低地址以此排序的.
void* 指针
指针的类型决定了指针访问内存的字节大小,那么在指针类型中还存在着一种特别的指针,空指针,即void* 指针.
int main(void)
{
int a = 10;
void* pc= &a;
return 0;
}
void* 类型的指针,可以理解为无具体类型的指针,也可以称为泛型指针.这类指针可以用来接收任何类型的指针.
- void* 类型的指针也有局限性,在这里,说明了void* 类型的指针不可以进行解引用操作.
- 同时,void* 类型的指不可以用于指针的运算.
传值调用和传址调用
int add(int x, int y)
{
return x + y;
}
int main(void)
{
int a = 3;
int b = 5;
//传值调用
int ret =add(a, b);
//打印
printf("%d", ret);
return 0;
}
传值调用,是将变量中的数据直接传递给函数使用,过程中不会改变变量中的值,仅仅只是使用了变量中的值.
int add(int* px, int* py)
{
return *px + *py;
}
int main(void)
{
int a = 3;
int b = 5;
//传值调用
int ret = add(&a, &b);
//打印
printf("%d", ret);
return 0;
}
传址调用是将变量的地址传递给函数,然后函数根据地址找到变量,在变量内部进行计算
这里需要提醒大家,传值和传址是俩个完全不同的看待角度的问题,传值调用仅仅只是将数值给函数使用,函数不管怎么用都不会改变变量变量本身.而传址调用则是将变量的地址提供给了函数,函数找到变量,在变量的内存中进行改变.
可以看看下面的例子:
int change(int x)
{
x = 10;
return x;
}
int main(void)
{
int a = 5;
//传值调用
int ret = change(a);
//打印ret的值
printf("%d\n",ret);
//打印a的值
printf("%d\n",a);
return 0;
}
- 传值调用
int change(int* px)
{
*px = 10;
return *px;
}
int main(void)
{
int a = 5;
//传值调用
int ret = change(&a);
//打印ret的值
printf("%d\n", ret);
//打印a的值
printf("%d\n", a);
return 0;
}
- 传址调用
数组和指针的关系
int main(void)
{
int arr[5] = { 1,2,3,4,5 };
//打印数组名的地址
printf("%p\n",arr);
//打印数组第一个元素的地址
printf("%p\n",&arr[0]);
return 0;
}
当我们以数组名打印地址时,和以数组首元素打印地址时所打印的地址相同,我们可以任务,数组名即为首元素的地址.
野指针
野指针,即指针指向的位置是不可知的,随机的,不正确的,没有明确限制的.
野指针的形成原因
int main(void)
{
int* p;
*p = 10;
return 0;
}
- 指针未初始化
int main(void)
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = arr;
int i = 0;
for (i = 0; i < 12; i++)
{
*(pa++) = 0;
}
return 0;
}
- 指针越界访问
int* num()
{
int x = 2;
return &x;
}
int main(void)
{
int* p = num();
printf("%d\n",*p);
return 0;
}
- 指针指向的空间释放(当调用完num函数时,num函数会被释放,而指针p指向的内容可能随时会被改变)
规避野指针
1.指针初始化
2.防止数组越界
3.指针不在使用时,应该及时置NULL
4.指针在使用之前应该及时检查其有效性
5.避免返回局部变量的地址
二级指针
int main(void)
{
int a = 10;
//取变量a的地址
int* pa = &a;
//取指针变量pa的地址
int** ppa = &pa;
printf("%p\n",&pa);
printf("%p\n",ppa);
return 0;
}
指针变量也存在地址,可以使用二级指针将指针变量的位置存储起来.
int main(void)
{
int a = 0;
int* pa = &a;
int** ppa = &pa;
//*ppa==pa
printf("%p\n",*ppa);
printf("%p\n", pa);
return 0;
}
解引用二级指针,可以得到一次指针的地址
int main(void)
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
//*ppa==pa
printf("%d\n", **ppa);
printf("%d\n", *pa);
return 0;
}
解引用俩次二级指针得到的是初始变量的值,解引用一次一次指针得到的是初始变量的值
int main(viod)
{
int a = 10;
int* pa = &a;
*pa = 20;
printf("%d\n",a);
int** ppa = &pa;
**ppa = 30;
printf("%d\n", a);
return 0;
}
可以利用解引用俩次二级指针改变初始变量的值.
字符指针
int main(void)
{
char ch= 'a';
char* pc = &ch;
*pc = 'w';
printf("%c",ch);
return 0;
}
当在char类型中存放的是字符时,和普通指针的用法相同,将字符的地址存入指针变量中,然后解引用即可.
int main(void)
{
char* pc = "abcdef";
printf("%p",pc);
return 0;
}
这里值得注意的时,在使用指针变量存储字符串地址时,只会将字符串的首个元素的地址保存
同时,这里在指向字符串时,可能会认为字符串首先是没有被存储在某个内存中的.
但是在C\C++中,会把常量字符串先保存在单独的内存区域,而当几个指针同时指向一个字符串时,实际都是指向同一个内存块.
这与数组储存字符串不同,数组储存字符串,会将字符串的每个元素由高到低依次排放,每次出现一个数组,尽管字符串相同,系统都会开辟出一份空间给数组,这样打印数组的地址每次都会时不同的.
可以看下面的例子:
int main(void)
{
char str1[] = "abcdef";
char str2[] = "abcdef";
char* str3 = "abcdef";
char* str4 = "abcdef";
printf("%p\n", str1);
printf("%p\n", str2);
printf("%p\n", str3);
printf("%p\n", str4);
return 0;
}
指针数组
int main(void)
{
int a = 1;
int b = 2;
int c = 3;
int* arr[3] = { &a,&b,&c };
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%p ", arr[i]);
}
return 0;
}
和整型数组,字符数组相同,指针数组也是数组,指针数组是用来存储指针变量的数组,每个指针变量指向一个地址.
int main(void)
{
int a = 1;
int b = 2;
int c = 3;
int* arr[3] = { &a,&b,&c };
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d ", *arr[i]);
}
return 0;
}
使用解引用操作符也可以找到初始元素.
int main(void)
{
int arr1[5] = { 1,1,1,1,1 };
int arr2[5] = { 4,4,4,4,4 };
int arr3[5] = { 3,3,3,3,3 };
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));
}
}
return 0;
}
一个数组的名称代表首元素的地址,也可以通过保存数组首元素地址的指针数组找到每个数组中的每个元素.
int main(void)
{
int arr1[5] = { 1,1,1,1,1 };
int arr2[5] = { 4,4,4,4,4 };
int arr3[5] = { 3,3,3,3,3 };
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]);
}
}
return 0;
}
这里也可以将 *(parr[i] + j)转换为parr[i][j],这俩个是完全等价的.
这里可以给大家介绍一下[]操作符:
[]这个操作符,是个双目操作符,i和arr都是这个操作符的操作数,就如同a + b一样,在左边和右边是一样的.
int main(void)
{
int arr[3] = {1,2,3};
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d ",i[arr]);
}
return 0;
}
数组指针
int main(void)
{
int arr[3] = { 1,2,3 };
int(*p)[3] = &arr;
return 0;
}
数组指针式存放数组地址的指针,也是指向数组的指针
数组名----代表数组首元素的地址
&数组名----代表数组的地址
它们俩个在打印地址时,得出的数据相同,但是俩者的意义不同.数组名只是代表一个元素,数组名+1,只会跳过一个元素,而&数组名不同,它代表的是一个数组,&数组名+1会跳过一个数组.
int main(void)
{
//指针数组
int* p1[10];
//数组指针
int(*p2)[10];
return 0;
}
我们要区分指针数组和数组指针.
- []的优先级高于 * 的优先级,在使用数组指针时一定要使用()
int* p1[10];
- 表示一个指针数组,数组10个元素,每个元素都是int*类型的
int(*p2)[10];
- 表示一个数组指针,该指针指向一个数组,数组是个元素,每个元素int类型
在这里我们区分指针数组和数组指针时,我们应该知道,指针数组[10]里有10个指针,它会指向10个地址,而指针数组[10]仅仅只指向一个地址,这个地址是个数组,而且有10个元素
数组传参
一维数组传参
//传数组
void fun(int arr[]);
//传数组
void fun(int arr[10]);
//传地址
void fun(int arr);
int main(void)
{
int arr[10] = { 0 };
fun(arr);
return 0;
}
指针数组传参
//传数组，数组中的每个元素都是int *类型
void fun2(int *arr2[20]);
//传这个指针数组的地址
void fun2(int** arr2);
int main(void)
{
int* arr2[10] = { 0 };
fun2(arr2);
return 0;
}
二维数组传参
//传数组
void fun3(int arr[3][5]);
//可以不传行数，但是不能不传列数
void fun3(int arr[][5]);
//数组指针，传的是一个指针，接收到是第一行的指针
void fun3(int(*arr)[5]);
int main(void)
{
int arr3[3][5] = { 0 };
fun3(arr3);
return 0;
}
指针传参
一级指针传参
将函数的参数部分变为一级指针
void fun(int* p);
int main(void)
{
//取地址传参
int a = 10;
fun(&a);
//一级指针传参
int* p = &a;
fun(p);
//数组传参
int arr[10] = { 0 };
fun(arr);
return 0;
}
二级指针传参
将函数的参数部分变为二级指针
void fun(int** p);
int main(void)
{
int b = 10;
//一级指针取地址传参
int* p = &b;
fun(&p);
//二级指针直接传参
int** pp = &p;
fun(pp);
//指针数组传参
int* arr[10] = { 0 };
fun(arr);
return 0;
}
函数指针
int add(int x ,int y)
{
return x + y;
}
int main(void)
{
int a = 5;
int b = 3;
//创造一个函数指针，指针是指向add
int (*pf)(int, int) = &add;
//使用指针接收add函数的返回值
int ret = (*pf)(a, b);
printf("%d ",ret);
return 0;
}
需要创建一个函数指针,首先需要有一个函数,然后&函数,然后将这个地址给一个指针即可.
这里需要提一下,在使用指针的时候,最重要的就是找到地址,找到地址的类型,使用一个指针变量即可.
例如这个函数指针:
add函数的的类型参数是(int,int),返回参数也是int,然后取地址,使用pf这个指针变量存放函数地址保存即可,
int add(int x ,int y)
{
return x + y;
}
int main(void)
{
int a = 5;
int b = 3;
//创造一个函数指针，指针是指向add
int (*pf)(int, int) = add;
//使用指针接收add函数的返回值
int ret = (*pf)(a, b);
printf("%d ",ret);
return 0;
}
- &函数名和函数名都是函数的地址
int add(int x ,int y)
{
return x + y;
}
int main(void)
{
int a = 5;
int b = 3;
//创造一个函数指针，指针是指向add
int (*pf)(int, int) = add;
//使用指针接收add函数的返回值
int ret = pf(a, b);
printf("%d ",ret);
return 0;
}
- 指针pf的解引用操作符 * 也可以省略
函数指针数组
int div(int x, int y)
{
return x * y;
}
int mul(int x, int y)
{
return x * y;
}
int sub(int x, int y)
{
return x - y;
}
int add(int x, int y)
{
return x + y;
}
int main(void)
{
int a = 5;
int b = 3;
//创造一个函数指针数组，指针是指向四个函数
int (*pf[4])(int, int) = { add, sub, mul,div };
return 0;
}
同样的道理,创建函数指针数组,因为是数组,则需要多个指针,指针指针需要指向多个函数(这里的函数的类型都是相同的),根据函数类型即可写出这个函数指针数组
指向函数指针数组的指针
函数的参数类型和返回类型与上面相同,那么该如何写出这个"指向函数指针数组的指针"
1.首先这个一个指针,而不是多个指针
- 这里肯定指针需要和解引用操作符 * 用()括起来
2.这个指针指向的是一个数组
- 需要[ ]包含一个数组,[ ]里面是元素的个数
3.同时这是一个指向函数指针
- 我们需要先写出函数指针,这里包括函数的参数类型和返回类型,以及这是指针
- 假如是之前那个例子:
- int (* )(int,int)
将三者结合起来:
- int (* (*pp)[4])(int,int) = &p;
int(*(8pp)[4](int,int))= &p;
回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
其实回调函数就是在调用一个函数时,这个函数的参数中包含一个指向函数的一个指针,在合理的情况下,函数会通过指针找到另外一个函数,进行使用
#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);
//这里使用一个函数指针找到int_cmp函数
return 0;
}
!!!好累啊!!!
写了快一万五的字数,劳烦各位大哥给个关注
我要去吃饭了…
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
