首页 > 其他分享 >指针的学习

指针的学习

时间：2023-08-28 19:44:41浏览次数：32  
标签：10 const int 学习 数组 printf 指针

一、什么是指针

指针是一种特殊的数据类型，使用它可以定义指针变量，指针变量中存储的是整型数据，该数据代表了内存的编号(地址)，可以通过这个编号访问到对应的内存

二、为什么要使用指针

1、函数之间内存是相互独立的，但有时候需要函数之间共享变量

  • 普通传参是单向值传递

  • 全局变量容易命名冲突

  • 使用数组还需要额外传递长度

虽然函数之间内存空间和命名空间是相互独立的，但是地址空间是同一个，所以使用指针可以解决这个问题

2、由于函数之间普通变量是单向值传递(拷贝)，因此对于一些字节数比较多的变量，值传递的效率很低，如果传递的是地址只需要4(32位)\8(64位)字节，可以提高传参效率

3、堆内存无法取名字，它不像data、bss、stack这些可以让变量名与对应的内存建立联系，只能使用指针变量记录堆内存的地址从而使用堆内存（）

三、如何使用指针

1、定义：

类型名* 变量名_p;

①指针变量与普通变量的用法有很大区别，建议在取名时以p结尾加以区分
②指针变量的类型表示它存储的是什么类型变量的地址，它决定了通过该指针变量能够连续访问的字节数
③一个*只能定义一个指针变量

int* a,b,c; //  a是指针变量，bc是int类型变量
int *p1,*p2,*p3;    //p1p2p3都是指针变量

④指针变量与普通变量一样，默认初始值是随机的，一般初始化为NULL

2、赋值

变量名_p = 地址;    //必须是有权限且有意义的内存地址

栈内存：（自动申请和释放）

 int num;
 int* p;
 p = #    //指针p指向变量num的地址

堆内存：（手动申请和释放）

int* p;
p = malloc(字节数);

3、解引用

通过该指针变量中存储的内存编号去访问对应的内存，具体连续访问的字节数由该指针类型决定（地址的内容）

指针：取地址

解引用：取地址里的数据/内容
注意：该过程可能会产生段错误，根源是该指针变量中存储的是非法内存地址

#include <stdio.h>

void func(int* num)
{
    printf("func:num=%d\n",*num);    //func:num=10
    *num = 100;
    printf("func:num=%d,%p\n",*num,num);    //func:num=100,0xbfb38f9c

}

int main(int argc,const char* argv[])
{
    int num = 10;
    func(&num);
    printf("main:num=%d,%p\n",num,&num) ;    //main:num=100,0xbfb38f9c
}

练习1：实现一个变量交换函数

#include <stdio.h>

void swap(int** pp1,int** pp2)    //二级指针，存指针的地址
{
    int* temp = *pp1;
    *pp1 = *pp2;
    *pp2 = temp;
}

int main(int argc,const char* argv[])
{
    int num1 = 10,num2 = 20;
    int* p1 = &num1,*p2 = &num2;
    printf("num1=%d,num2=%d\n",num1,num2);     //num1=10,num2=20

    printf("p1=%p,p2=%p\n",p1,p2);     //p1=0xbfc310a0,p2=0xbfc310a4

    swap(&p1,&p2);

    printf("num1=%d,num2=%d\n",num1,num2);     //num1=10,num2=20

    printf("p1=%p,p2=%p\n",p1,p2);     //p1=0xbfc310a4,p2=0xbfc310a0
}

四、空/野指针--使用指针需要注意的问题

1、空指针

值为NULL的指针变量叫做空指针。

printf("%p\n",NULL);    //值为0x00000000，表示不指向任何有效空间，

如果对空指针解引用就会产生段错误

  • NULL一般用于初始化指针变量

  • NULL是一种错误标志，如果一个函数的返回值类型是指针类型时，该函数执行出错则可以返回NULL

  • NULL可以被判断

    if(NULL == p)   if(!p)

⭐ 绝大多数系统中NULL就是0，个别系统中是1

如何避免空指针带来的段错误？

当使用来历不明的指针前一定要先做判断

1、当函数的返回值是指针类型，获取后先判断后使用

2、当你函数的参数是指针时，别人可能会传空指针，使用前先判断

2、野指针

指向不确定的内存空间的指针叫做野指针。

野指针比空指针危害更大，因为它无法判断出来 ，并且它的问题可能是隐藏性的短时间内不暴露而已

所有的野指针都是程序员自己制造

对野指针解引用有什么后果：

1、一切正常

2、段错误

3、脏数据

产生野指针的原因：

1.指针未初始化

int* p;    //p没有初始化，意味着没有明确的指向，此时放置的是一个随机值
*p = 10;    //非法访问内存

2.指针越界访问，如数组越界

3.指针指向的空间释放，这种野指针是经常在函数返回类型为指针且该指针指向的空间出了函数会被释放掉的情况下出现。

#include <stdio.h>

int* func(void)
{
    int num = 10;
    int* p = &num;
    return p;
}
int main(int argc,const char* argv[])
{
    int* p = func();    //函数结束后内存被释放，即该空间还给了操作系统，
                        //这里面的数据并不一定会发生改变，只有当下一次用到该空间时候才有可能发生改变
    printf("%d\n",*p);    //10
    printf("hehe\n");
    printf("%d\n",*p);    //0
}

如何避免产生野指针：

1、定义指针变量时一定要初始化

2、函数不要返回局部变量(栈内存)的地址

3、当指针所指向的内存被释放后，指针变量要及时置空（NULL）

五、指针的运算

指针变量中存储的是整数，理论上整形数据可以使用的运算符它都可以使用，但是绝大多数运算都无意义

指针 + n  <=>  指针+指针类型字节数*n  前进了n个元素
指针 - n  <=>  指针-指针类型字节数*n  后退了n个元素
    运算后得到的结果依然是一个临时的指针

指针 - 指针 <=> (指针-指针)/类型字节数 计算出两个指针变量之间间隔了多少个指针元素个数(必须类型相同的指针才可以相减)

对指针进行加法（减法）运算时，它前进（后退）的步长与它指向的数据类型有关

六、const与指针

当我们为了提高传参效率而使用指针时，传参效率提高了，但是变量共享后有被修改的风险，因此配合const可以进行保护

就近原则：看const右边先跟着的是*(内存数据) 还是 p(指向类型)

const int* p;   p指针所指向的内存数据不能修改，p本身可以变（可以对p赋值，不能对*p赋值）
int const *p;   同上
int* const p;   p本身不能变，p指向的内存数据可以变
const int* const p; 保护指针指向的内存和指向都不能修改
int const * const p; 同上

1、 const int a

const int a = 1;/* 等价于int const a = 1; */

常用的只读变量的定义方式，不希望a被修改时添加const修饰。

2、 const int *p

int a = 1;
const int *p = &a;

const(常量先)->*(指针后)，按顺序就是“常量指针”，常量指针即常量的指针，强调指针，p指针（认为自己）指向的量是一个常量（在C里是只读变量）。(地址可变数据不可变)

  • 从标识符p开始往左看，声明中有*号，则p为指针，p指向的类型为const int或int const(等价)；

  • 标识符p旁边没有const关键字，则指针的指向可以被改变（可以对p赋值）；

  • const关键字贴近数据类型int，则指针指向的数据不可变（不能对*p赋值）；

    实例：

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int num1 = 10;
    int num2 = 100;

    const int* p = &num1;
    printf("%d %d %p %p\n",num1,*p,&num1,p);    //10 10 0xbfd0c7f4 0xbfd0c7f4
    //*p = 20;    报错,不可以对*p赋值
    num1 = 20;
    printf("%d %d %p %p\n",num1,*p,&num1,p);    //20 20 0xbfd0c7f4 0xbfd0c7f4
    p = &num2;     //可以对p赋值
    printf("%d %d %p %p\n",num2,*p,&num2,p);    //100 100 0xbfd0c7f8 0xbfd0c7f8
}

3、int * const p

int a = 1;
int * const p = &a;

*(指针先)->const(常量后)，按顺序就是“指针常量”，指针常量强调常量，即p本身是常量，因此p不能赋值，p指针（认为自己）指向的是一个整形数的地址，但自己不能被改变。(地址不可变数据可变)

  • 从标识符p开始往左看，声明中有*号，则p为指针；

  • const关键字贴近标识符p，则指针的指向不可被改变（不能对p赋值）；

  • 数据类型int旁边没有const关键字，则指针指向的数据可以被改变（可以对*p赋值）；

  • 由于指针的指向不可被改变，p在定义时必须完成初始化，后续再对p赋值将编译失败。

    实例：

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int num1 = 10;
    int num2 = 100;

    int* const p = &num1;
    printf("%d %d %p %p\n",num1,*p,&num1,p);    //10 10 0xbf9a9794 0xbf9a9794
    *p = 20;    //可以对*p赋值
    printf("%d %d %p %p\n",num1,*p,&num1,p);    //20 20 0xbf9a9794 0xbf9a9794
    //p = &num2;    报错，不能对p赋值
}

4、const int * const p

int a = 1;
const int * const p = &a;

  • 从标识符p开始往左看，声明中有*号，则p为指针；

  • const关键字贴近标识符p，则指针的指向不可被改变（不能对p赋值）；

  • const关键字贴近数据类型int，则指针指向的数据不可被改变（不能对*p赋值）；

  • 由于指针的指向不可被改变，p在定义时必须完成初始化，后续再对p赋值将编译失败

实例：

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int num1 = 10;
    int num2 = 100;

    const int * const p = &num1;
    printf("%d %d %p %p\n",num1,*p,&num1,p);
    // *p = 20;        报错，不能对*p赋值
    // p = &num2;    报错，不能对p赋值
}

5、const int * const *pp

int a = 1;
const int * const p = &a;
const int * const *pp = &p;

  • 从标识符pp开始往左看，声明中有*号，则pp为指针；

  • 声明中有两个*号，则pp为指针的指针；

  • 将const int * const *pp分为两部分：const int * const 和 *pp，可以发现pp是const int * const类型的指针，而const int * const 类型本身就是个指针类型，这个类型指针指向的数据不可被改变、指针的指向不可被改变；

  • const int * const为“指向常量的常量指针”类型 （中文叫法可忽略），则const int * const *为“指向常量的常量指针的指针”类型 （中文叫法可忽略）；

  • pp本身只是用于容纳const int * const类型的指针，因此pp本身不必须在定义时完成初始化，后续可以对pp赋值，pp的值为const int * const类型，因此不能对*pp赋值，也不可对**pp赋值。

七、指针数组与数组指针

当使用堆内存的二维数组时会使用指针数组和数组指针

指针数组：

就是由指针组成的数组，它的成员都是类型相同的指针变量

类型* arr[长度] = {};
int* arr[10];

例如：char *arr[]={“Sunday”,“Monday”}，存储了两个指针，第一个指针指向了字符串"Sunday"，第二个指针指向了字符串"Monday"，字符数组 arr中存放的是字符串的首地址，不是字符串本身，

而sizeof(arr)=8，因为在32位平台，指针类型大小占4个字节。

指针数组最重要的用途是对多个字符串进行处理操作，因为字符指针比二维数组更快更有效。

实例：

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int* arr[5] = {};
    int arr1[5] = {10,20,30,40,50};

    int* p = arr1;
    printf("%p %p\n",arr1,&arr1[0]);
    for(int i=0; i<5; i++)
    {
        arr[i] = &arr1[i];
        printf("%d %d %d %d\n",*arr[i],*(p+i),p[i],*(arr1+i));
    }
}

输出：

0xbfce88b4 0xbfce88b4
10 10 10 10
20 20 20 20
30 30 30 30
40 40 40 40
50 50 50 50

指针数组的解引用

*( p[i] + j )         //等价于 *( a[i] + j )

*( *(p+i)+ j )        //等价于 *( *(a+j) + j )

( *(p+i) )[ j ]        //等价于( *(a+i) )[ j ]

p[ i ][ j ]                //等价于 a[i][j]

p+1会使得指针指向二维数组的下一行，p-1会使得指针指向数组的上一行。

实例：

#include<stdio.h>
int main()
{
    int i = 0;
    int a[3][4] = { {1,2,3,4} ,{5,6,7,8} ,{9,10,11,12} };//定义一个二维数组
    int* pa[3];//定义一个指针数组
    for (i = 0; i < 3; i++)//给指针数组赋值
        pa[i] = a[i];
    printf("指针数组的内容为:\n");
    for (i = 0; i < 3; i++)//打印出指针数组的内容
    {
        int j;
        for (j = 0; j < 4; j++)
            printf("%d ", *(*(pa + i) + j));
        printf("\n");
    }
    //以下均为不同方式的解引用操作
    printf("不同解引用操作的结果为:\n");
    printf("%d,%d\n", a[1][1], *(pa[1] + 1));
    printf("%d,%d\n", a[1][1], *(*(pa+1) + 1));
    printf("%d,%d\n", a[1][1], (*(pa + 1))[1]);
    printf("%d,%d\n", a[1][1], pa[1][1]);
    return 0;
}

输出：

指针数组的内容为:

1 2 3 4
5 6 7 8
9 10 11 12

不同解引用操作的结果为:

6,6
6,6
6,6
6,6

指针数组与字符串数组

#include <stdio.h>
int main(){
    char *str[3] = {"lirendada","C语言","C Language"};

    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    printf("%d %d %d\n",sizeof(str),sizeof(str[0]),sizeof(*str[0]));
    return 0;
}
输出:
lirendada
c语言
C Language
12 4 1

等价于：

#include <stdio.h>
int main(){
    char *str0 = "lirendada";
    char *str1 = "C语言";
    char *str2 = "C Language";
    char *str[3] = {str0, str1, str2};
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
}

指针数组与二维数组

char *p1[]={"lirendada","C","C++"};
char p2[][8]={"liren","C","C++"};

p1， (p1+1)，*(p1+2)：所指向的字符串常量是不规则长度的，且sizeof(p1)=12。

p2[0]，p2[1]，p2[2]所指向的字符串都是一定长度的，且sizeof(p2)=24。

数组指针：

专门指向数组的指针

类型 (*arrp)[长度];
int (*arrp)[10];
含义：arrp是一个专门指向类型为int，长度为10的数组的指针

数组指针的解引用

a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)

实例：

#include <stdio.h>

int main(int argc,const char* argv[])
{
    //一维指针数组
    int arr[5] = {1,2,3,4,5};
    int (*arrp)[5] = &arr;
    printf("sizof(arrp) = %d,sizeof(*arrp)=%d\n",sizeof(arrp),sizeof(*arrp));    //4,20
    printf("%d %d %d %d\n",**arrp,arr[0],*(*arrp+1),arr[1]);//1 1 2 2


    int arr1[3][4] = {1,2,3,5,6,7,8,9,10,9,8};

    int *p_arr[3];
    p_arr[0] = arr1[0];
    printf("%d\n",sizeof(p_arr));    //12

    int (*arrp1)[4] = arr1;
    printf("sizeof(arrp1)=%d, sizeof(*arrp1)=%d\n",sizeof(arrp1),sizeof(*arrp1));    //4, 16
    printf("sizeof(arrp1[2])=%d, sizeof(arrp1[5])=%d\n",sizeof(arrp1[2]),sizeof(arrp1[5]));    //16, 16

    printf("%d %d %d %d\n",**arrp1,arr1[0][0],arr1[1][1],*(*(arrp1+1)+1));//1 1 7 7
    printf("%d\n",*arrp1[1]);    //6
}

1、p指向数组 a 的开头，也即第 0 行；p+1前进一行，指向第 1 行。

2、*(p+1)表示取地址上的数据，也就是整个第 1 行数据。

3、*(p+1)+1表示第 1 行第 1 个元素的地址。

4、 * (*(p+1)+1)表示第 1 行第 1 个元素的值。很明显，增加一个 * 表示取地址上的数据。

八、指针与数组名

  • 数组： 有序的元素序列，数组名有限个类型相同的变量的集合命名。数组在内存中所占的大小由数组长度以及成员类型大小决定。
  • 指针： 又称指针变量，在32位系统内存下占4个byte（64位系统内存下占8个byte），其中保存的值是某一块内存的地址。eg:0x0000FF00.

数组名是一种特殊的"指针"，数组名就是数组的首地址，它与数组在内存中的首地址之间存在映射关系，它没有自己的存储空间，数组名是常量，不能修改它所代表的值

数组作为函数的参数传递时，蜕变成指针，因此长度丢失

  • sizeof（数组名） ； 计算的是整个数组在内存中的大小。
  • &数组名；取出的值与第一个元素的首地址一致，但其偏移量并非数组的一个元素大小而是整个数组的大小，
&arr[0] == &arr == arr

指针变量有自己的存储空间，它与内存之间是指向关系，如果它存储了数组的首地址时，那么指针可以当做数组使用，同时数组名也可以当做指针使用

int* p = arr;
p[i] == *(p+i)
arr[i] == *(arr+i)

九、二级指针

二级指针就是指向指针的指针，里面存储的是指针变量的地址

定义：
        类型名** 变量名_pp;
 赋值：
        变量名_pp = &指针变量;
解引用：
        *变量名_pp == 指针变量;
        **变量名_pp == *指针变量 == 数据

注意：

当函数间需要共享普通变量时，传递一级指针

当函数间需要共享指针变量时，传递二级指针

实例：

#include <stdio.h>

int main(int argc,const char* argv[])
{
    int num = 10;
    int* p = &num;
    int** pp = &p;
    printf("%p %p\n",*pp,p);    //0xbfe856c4 0xbfe856c4
    printf("%d %d\n",*p,**pp);    //10 10
}

十、函数指针

函数名就是一个地址(整数)，代表了该函数在代码段中的位置

函数指针就是专门指向某种函数的指针，它里面存储的是该函数在代码段中的位置(函数名)

int (*funcp)(const char*, ...) = scanf;    //直接使用函数名给函数指针赋值，scanf代表一个函数名
funcp是指向返回值为int，参数为const char*和...这样函数的指针
funcp("%d",&num);

实例：

int Func(int x);   /*声明一个函数*/
int (*p) (int x);  /*定义一个函数指针*/
p = Func;          /*将Func函数的首地址赋给指针变量p*/

typedef 返回值类型 (*FP)(参数类型1,参数类型2,...);
FP 相当于函数指针类型 可以用于定义函数指针变量

FP funcp;
funcp(实参1，实参2)

函数回调：就是将一个函数作为参数传递给另一个函数，让后者在适当的时候调用前者。

回调模式的函数：

void qsort(
    void *base,     //数组
    size_t nmemb,     //数组元素个数
    size_t size,    //数组元素大小
    int (*compar)(const void *, const void *));    //此为指向比较函数的函数指针，决定了排序的顺序。
功能：是对数组进行排序

十一、万能指针 void*

在C语言中，任意类型的指针可以自动转换为void，void类型的指针也可以自动转换为任意类型

void*大小为4字节

标签：10,const,int,学习,数组,printf,指针
From： https://www.cnblogs.com/ljf-0804/p/17663247.html

相关文章

  • Python学习日记 2023年8月28日
    importrequestsfromlxmlimportetreeimportreurl='https://image.baidu.com/search/acjson?tn=resultjson_com&logid=8700291432374701138&ipn=rj&ct=201326592&is=&fp=result&fr=ala&word=%E8%A1%A8%E6%83%85%E5%8C%85&query......
  • Docker学习
    Docker实用篇 0.学习目标  1.初识Docker1.1.什么是Docker微服务虽然具备各种各样的优势，但服务的拆分通用给部署带来了很大的麻烦。分布式系统中，依赖的组件非常多，不同组件之间部署时往往会产生一些冲突。在数百上千台服务中重复部署，环境不一定一致，会遇到各种问题......
  • 记一次基础学习Ubuntu的经历
    系统版本查阅plengong@plengong:~$lsb_release-aNoLSBmodulesareavailable.DistributorID:UbuntuDescription:Ubuntu20.04.6LTSRelease:20.04Codename:focal网络配置plengong@plengong:~$vim/etc/netplan/00-installer-config.yaml#Thisis......
  • 【学习目录】
    大数据后端Elasticsearch黑马https://www.bilibili.com/video/BV1Gh411j7d6/?p=4&spm_id_from=pageDriver&vd_source=6916013ff10f407b3c711485467e61ca前端Vue商医通(vue3+vite+pinia+ts)分类框架技术栈视频连接备注学习周期后端前端Vuehttps:/......
  • dos命令简单学习
    Dos命令打开命令行window+rcmd管理员身份右键window图标.命令dir查看目录cd/d目录名称进入目录cd：changedirectory通常情况下进入不同盘符中的文件需要两次命令：1.进入盘符，2.进入目录加入/d就可以直接进入不同盘符的目录同一盘符中更换目录，若使用/......
  • Markdown学习笔记
    标题标题只有1-6#ctrl+横排数字键字体加粗两个**斜体一个**列表无续列表-/**加空格有序列表数字+点加空格 引用这是一个引用右书名号加空格表格直接右键建立         代码块   这是一个代码块  ......
  • javascript学习笔记day7
    今天学了挺多新东西的，在学校教的东西都是很老了东西了，果然互联网完全真能靠自学，下面是今天的笔记varletconst优先使用const，即不会改变的变量，假设后续发现这个变量会改变就再使用letconsole.log打印属性console.dir打印信息innerText只修改标标签内容不解析标签innerHTML识......
  • 一般图最大匹配学习笔记
    Uoj#79LuoguP6113带花树算法（匈牙利算法\(Pro~max\)）我们考虑现在访问到\(u\)点（黑色），\(u\)连向\(v\)点，分类讨论\(v\)点。1、\(v\)点没有被匹配过，直接令\(u\)点和\(v\)点匹配，然后更新答案2、\(v\)点匹配过，但之前还未被访问过，那么把\(v\)点染成白色，然后把\(v\)......
  • python+playwright 学习-78 获取浏览器cookies
    前言playwright操作浏览器上的页面后，后续如果想结合其他的框架操作接口（如：requests),可以直接获取到浏览器的cookies。context.cookies()获取浏览器cookies使用示例fromplaywright.sync_apiimportsync_playwright,expectwithsync_playwright()asp:browser=......
  • 学习笔记：分块
    前言非常粗略概念什么是分块算法？很简单就是暴力把一段长度为\(n\)的序列分成\(\sqrt{n}\)块块长为\(\sqrtn\)然后进行一系列暴力乱搞它的好处就是非常暴力好！先来看一道板子题目要求我们区间加一个数区间查询一段和这个东西怎么搞？考虑分块！首先呢把原数列......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99