初识指针

原创

暮云

发布于 2022-11-28 13:11:07

2000

发布于 2022-11-28 13:11:07

文章被收录于专栏：C/C++语言学习

初级指针

指针是什么指针和指针类型野指针指针运算指针和数组二级指针指针数组

1.指针是什么

在计算机科学中，指针是编程语言中的一个对象，利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过指针地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元
指针理解的2个要点：
指针是内存中一个最小单元的编号，也就是地址平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

举例理解假设这是内存空间，将其分为五个格子

一个小的单元是一个字节大小

将第一个格子命名为0xFFFFFFFF

第二个格子命名为0xFFFFFFFE

······

第五个格子命名为0x00000000

这些编号就称为地址

#include<stdio.h>
int mian()
{
    int a = 10;
    int* p = &a;//a的地址被取出来后存放到p里头，p就被称做指针，p也是指针变量，而p存放的是地址，所以常说指针就是地址
    return 0;
}

总结：

指针就是地址，口语中说的指针通常指的是指针变量。（存放在指针中的值都被当成地址处理）
指针大小在32位平台是4个字节，在64位平台是8个字节

2.指针和指针类型

指针也有不同的类型，整型，浮点型，字符型等。

注意点

注意点1：指针类型决定了指针进行解引用操作时，能够访问空间的大小

#include<stdio.h>
int mian()
{
    int a=0x11223344;
    int* pi=&a;
    *p=0;
    //这里进行解引用时，int*类型的能访问4个字节大小
    //将上两行代码屏蔽
    char* pc=&a;
    *p=0;
    //这里进行解引用时，char*类型的只能访问1个字节大小
    return 0;
}

所以，指针类型决定了指针指针进行解引用操作时，能够访问空间的大小
对于int* 能访问4个字节大小
char*能访问4个字节大小
double*能访问8个字节大小
对应不同类型，访问字节的大小与其对应

指针+-整数

#include<stdio.h>
int main()
{
    int a = 10;
    int b = '0';
    int* pi=&a;
    char* pc=&b;
    printf("%p\n",pi);
    printf("%p\n",pi+1);
    printf("%p\n",pc);
    printf("%p\n",pc+1);
    return 0;
}
//输出结果
/*0000008942BFF674
  0000008942BFF678
  0000008942BFF694
  0000008942BFF695*/

注意点2：指针类型决定了指针走一步走多远（指针的步长）

int*p ; p+1 --> 4 对于int ，p+1 相当于跳过一个整型，即4个字节
char*p;p+1 -->1 以此类推
double*p;p+1 -->8

综合理解

#include<stdio.h>
int main()
{
    int arr[10]={0};
    int* p = arr;//数组名-首元素的地址
    int i = 0;
    for(i=0;i<10;i++)
    {
        *(p+i)=1;
    }
    return 0;
}
//对于arr其总共有40个字节，用int*类型，*(p+i)能够将40个字节内容全变位1

#include<stdio.h>
int main()
{
    int arr[10]={0};
    //int* p = arr;//数组名-首元素的地址
    char* p = arr;
    //若改为char*类型，则*(p+i)只能够将前十个字节改为1
    int i = 0;
    for(i=0;i<10;i++)
    {
        *(p+i)=1;
    }
    return 0;
}

3.野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针成因

指针未初始化

#include <stdio.h>
int main()
{ 
    int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
    return 0;
}

指针越界访问

#include<stdio.h>
int main()
{
    int arr[10]={0};
    int* p=arr;
    int i = 0;
    for(i=0;i<=11;i++)
    {
        *(p++)=i;
        //当指针指向的范围超出数组arr的范围时，p就是野指针
    }
    return 0;
}

指针指向的空间释放

#include<stdio.h>
int* test()
{
    int a=10;
    return &a;
}
int main()
{
    int* p=test();
    *p = 20;
    //在调用函数后形参被销毁，*p这里找到的地址将不是原来a的地址，因为在调用函数结束后a的地址被销毁了，所以这里也导致了野指针的出现
    return 0;
}

如何规避野指针

指针初始化
小心指针越界
指针指向空间释放即使置NULL
指针使用之前检查有效性

//避免指针指向的空间释放
//即第3点，使指针变为空指针
#include<stdio.h>
int main()
{
    int a = 10;
    int* pa = &a;
    *pa = 20;
    //当后面pa指针不再使用时，将其置为空指针，就能够避免野指针
    pa = NULL;
    //此时pa指针不再指向任何空间，且不能被访问
    //所以使用指针时要先判断该指针是否为空指针
    if(pa!=NULL)
    {
        *pa = 20;
    }
    return 0;
}

4.指针运算

指针+-整数
指针-指针
指针的关系运算

指针+-整数

// +
#include<stdio.h>
int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    int* p=arr;
    for(i=0;i<10;i++)
    {
        printf("%d ",*p);
        p++;
    }
    return 0;
}

// -
#include<stdio.h>
int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    int* p=&arr[9];
    for(i=0;i<10;i++)
    {
        printf("%d ",*p);
        p--;
    }
    return 0;
}

应用

#include<stdio.h>
int main()
{
    int arr[5]={1,2,3,4,5};
    int* pa;
    int i = 0;
    for(pa=&arr[0];pa<&arr[5];i++)
    {
        *pa++=0;
        printf("%d ",arr[i]);
    }
    return 0;
}//0 0 0 0 0

指针-指针

指针减指针等于中间元素个数（包括第一个）

#include<stdio.h>
int main()
{
    int arr[10] = {1,2,4,5,6,7,8,9,10};
    printf("%d",&arr[9]-&arr[0]);
    return 0;
}

注意！不能拿不同的指针相减

//错误示例
#include<stdio.h>
int main()
{
    char ch[5]={'0'};
    int arr[10] = {1,2,4,5,6,7,8,9,10};
    printf("%d",&arr[9]-&ch[0]);
    return 0;
}

应用

//strlen - 求字符串长度
#include<stdio.h>
int my_strlen(char*str)
{
    char* start=str;
    char* end = str;
    while(*end!='\0')
    {
        end++;
    }
    return end - start;
}
int main()
{
    char arr[]="bit";
    int len = my_strlen(arr);
    printf("%d",len);
    return 0;
}

指针的关系运算

两者代码比较

#define N_VALUES 5
#include<stdio.h>
int main()
{
    float values[N_VALUES];
    float* vp;
    for(vp = &values[N_VALUES]; vp > &values[0];)    
    {
        *--vp = 0;
    }
    return 0;
}

#define N_VALUES 5
#include<stdio.h>
int main()
{
    float values[N_VALUES];
    float* vp;
    for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)    
    {
        *vp = 0;
    }
    return 0;
}
//这种写法可能造成 指向数组元素的指针 与 指向第一个元素前面 的 那个内存位置的指针进行比较

注意：尽量使用第一种写法

标准规定

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素前面的那个内存位置的指针进行比较。

5.指针与数组

#include<stdio.h>
int main()
{
    int arr[10]={0};
    printf("%p\n",arr);//首元素地址
    printf("%p\n",&arr[0]);
    printf("%p",&arr);//000000B876AFFA38
    //1.&arr - &数组名 - 表示的是整个整个数组，取出的是整个数组的地址
    //2.sizeof(arr) - sizeof(数组名) - 数组名表示的是整个数组，sizeof()计算的是整个数组的大小
    //除此之外，都是首元素地址
    //
    return 0;
}//输出结果
/*000000B876AFFA38
  000000B876AFFA38
  000000B876AFFA38*/

//对于&arr的解释
#include<stdio.h>
int main()
{
    int arr[10] = { 0 };
    printf("%p\n", arr);
    printf("%p\n", arr+1);
    printf("%p\n", &arr[0]);
    printf("%p\n", &arr[0]+1);
    printf("%p\n",&arr);
    printf("%p",&arr+1);
    return 0;
}
/*000000C6F699F518
  000000C6F699F51C
  000000C6F699F518
  000000C6F699F51C
  000000C6F699F518
  000000C6F699F540*/
//从输出结果可见，第一行到第二行跳了四个字节，第三行到第四行也是四个字节，而第五行到第六行跳了40个字节，所以&arr是取出一整个数组的地址

结论：数组名表示的是数组首元素地址，&arr这种情况除外

情况2

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

#include <stdio.h>
int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,0};
    int *p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(int i=0; i<sz; i++)
   {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p+i);
   }
    return 0;
}
/*&arr[0] = 0000002BC04FF638   <====> p+0 = 0000002BC04FF638
&arr[1] = 0000002BC04FF63C   <====> p+1 = 0000002BC04FF63C
&arr[2] = 0000002BC04FF640   <====> p+2 = 0000002BC04FF640
&arr[3] = 0000002BC04FF644   <====> p+3 = 0000002BC04FF644
&arr[4] = 0000002BC04FF648   <====> p+4 = 0000002BC04FF648
&arr[5] = 0000002BC04FF64C   <====> p+5 = 0000002BC04FF64C
&arr[6] = 0000002BC04FF650   <====> p+6 = 0000002BC04FF650
&arr[7] = 0000002BC04FF654   <====> p+7 = 0000002BC04FF654
&arr[8] = 0000002BC04FF658   <====> p+8 = 0000002BC04FF658
&arr[9] = 0000002BC04FF65C   <====> p+9 = 0000002BC04FF65C*/

可见，两者结果一模一样，所以可以直接通过指针来访问数组

#include<stdio.h>
int main()
{
    int arr[10]={0};
    int* p = arr;
    int i =0;
    for(i=0;i<10;i++)
    {
        *(p+i)=i;
    }
    for(i=0;i<10;i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
        for(i=0;i<10;i++)
    {
        printf("%d ",*(p+i));
    }
    return 0;
}
/*0 1 2 3 4 5 6 7 8 9
  0 1 2 3 4 5 6 7 8 9*/

6.二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

#include<stdio.h>
int main()
{
    int a = 20;
    int* pa = &a;//*pa一级指针
    int** ppa = &pa;//**ppa就是二级指针
    printf("%p\n",pa);
    printf("%d\n",*pa);
    printf("%p\n",ppa);
    printf("%p\n",*ppa);
    printf("%d",**ppa);
    return 0;
}
/*000000E78CEFF6A4
  20
  000000E78CEFF6C8
  000000E78CEFF6A4
  20*/

从输出结果可见，二级指针就是存放一级指针的地址，通过解引用操作，可以找到一级指针的地址，还可以从一级指针的地址找的该地址的位置，即解引用两次。以此类推***pppa也如此，是二级指针

7.指针数组

是个数组，存放指针的数组

#include<stdio.h>
int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    int* pa = &a;
    int* pb = &b;
    int* pc = &c;
    int* arr[3] = {&a,&b,&c};//指针数组
    //int* arr[3] = {pa,pb,pc};这样写也可以
    int i=0;
    for(i=0;i<3;i++)
    {
        printf("%d ",*(arr[i]));
    }
    return 0;
}

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

编程算法

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

编程算法

登录后参与评论

0 条评论

热度

初识指针

初识指针

初级指针

1.指针是什么

2.指针和指针类型

注意点

3.野指针

4.指针运算

指针+-整数

指针-指针

指针的关系运算

5.指针与数组

6.二级指针

7.指针数组

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐