五、指针（C语言）

博主：彼岸花露
发布时间：2024 年 04 月 14 日
1574 次浏览
暂无评论
3432字数
分类： C语言

# 五、指针

## 1.指针的定义

内存区域中的每字节都对应一个编号， 这个编号就是“地址”，如果在程序中定义了一个变量， 那么在对程序进行编译时， 系统就会给这个变量分配内存单元。按变量地址存取变量值的方式称为“直接访问”, 如printf("%d",i);、scanf("%d",&i);等; 另一种存取变量值的方式称为“间接访问”， 即将变量i的地址存放到另一个变量中。在 C语言中， 指针变量是一种特殊的变量，它用来存放变量地址.

指针变量的定义格式如下：

```c
基类型 *指针变量名;
int *i_pointer;
```

指针与指针变量是两个概念， 一个变量的地址称为该变量的“指针”， 例如， 地址2000是变量 i的指针， 如果有一个变量专门用来存放另一变量的地址 (即指针)， 那么称它为“指针变量”， 图中的i_pointer就是一个指针变量.

那么i_pointer本身占多大的内存空间呢? 程序是64位应用程序，寻址范围为**64位即8字节**， sizeof(i_pointer)=8, 如果编写的程序是**32位, 那么寻址范围就是4字节**(考研中往往会强调程序是32位的程序).

![指针变量](https://photo.w-4.cn/typora/image-20240414105412226.png)

## 2. 取地址操作符与取值操作符，指针本质

取地址操作符为&， 也称引用， 通过该操作符我们可以获取一个变量的地址值； 取值操作符为\*， 也称解引用， 通过该操作符可以得到一个地址对应的数据. 如下例所示， 我们通过&i获取整型变量i的地址值， 然后对整型指针变量p进行初始化， p中存储的是整型变量i的地址值， 所以通过\*p(printf函数中的\*p)就可以获取整型变量 i的值. p中存储的是一个绝对地址值.那为什么取值时会获取4字节大小的空间呢? 这是因为 p为整型变量指针， 每个int型数据占用4字节大小的空间，所以p在解引用时会访问 4字节大小的空间，同时以整型值对内存进行解析.

```c
#include <stdio.h>
int main() {
    int i=5;
    //定义了一个指针变量，i_pointer就是指针变量名
    //指针变量的初始化是某个变量取地址来赋值，不能随机写个数
    int *i_pointer;
    i_pointer=&i;
    printf("i=%d\n",i);//直接访问
    printf("*i_pointer=%d\n",*i_pointer);//间接访问
    return 0;
}
```

注意

1. 指针变量前面的“\*”表示该变量为指针型变量。例如，
   
   ```c
   float *pointer_1;
   ```
   
   注意指针变量名是 pointer_1, 而不是\*pointer_1.
2. 在定义指针变量时必须指定其类型， 需要注意的是， 只有整型变量的地址才能放到指向整型变量的指针变量中。 例如， 下面的赋值是错误的：
   
   ```c
   float a;
   
   int * pointer_1;
   
   pointer_1=&a； //毫无意义而且会出错
   ```
3. 如果已执行了语句
   
   ```c
   pointer_1=&a;
   ```
   
   那么&\* pointer_1的含义是什么呢?
   
   “&”和“\*”两个运算符的优先级别相同， 但要按自右向左的方向结合. 因此， &* pointer_1与&a相同, 都表示变量a的地址, 也就是 pointer_1.
   
   \*&a的含义是什么呢?
   
   首先进行&a运算, 得到a的地址, 再进行\*运算. \*&a 和\*pointer_1的作用是一样的, 它们都等价于变量a， 即\*&a 与a等价。
4. int \*a， a被声明成类型为 int\*的指针。 但类似int \*a，b，c的语句，“\*”实际上是\*a的一部分， 只对 a标识符起作用， 其余两个变量只是普通的整型变量。要声明三个指针变量，正确的语句如下：

```c
int *a,*b,*c;
```

**指针的使用场景通常只有两个：传递与偏移**

## 3. 指针的传递

在本例的主函数中，定义了整型变量 i， 其值初始化为10， 然后通过子函数修改整型变量i的值. 但是, 我们发现执行语句 printf("after change i=%d\n",i);后, 打印的i的值仍为10，子函数 change并未改变变量i的值

【例】指针的传递使用场景。

```c
#include <stdio.h>
//在子函数内去改变主函数中某个变量的值
void change(int j)//j是形参
{
    j=5;
}

int main() {
    int i=10;
    printf("before change i=%d\n",i);
    change(i);//C语言的函数调用是值传递，实参赋值给形参，j=i
    printf("after change i=%d\n",i);
    return 0;
}
```

栈空间的变化， 当main函数开始执行时， 系统会为main函数开辟函数栈空间，当程序走到int i时， main函数的栈空间就会为变量i分配4字节大小的空间，调用 change 函数时，系统会为change函数重新分配新的函数栈空间，并为形参变量j分配4字节大小的空间，在调用change(i)时，实际上是将i的值赋值给j，我们把这种效果称为值传递 (C语言的函数调用均为值传递). 因此，当我们在change函数的函数栈空间内修改变量 j的值后，change函数执行结束，其栈空间就会释放，j就不再存在，i的值不会改变。

![原理图](https://photo.w-4.cn/typora/image-20240414112629673.png)

【例】在子函数中修改 main函数中某个变量的值.

```c
#include <stdio.h>
//在子函数内去改变主函数中某个变量的值
void change(int *j)//j是形参
{
    *j=5;//*j等价于变量i，只是间接访问
}

int main() {
    int i=10;
    printf("before change i=%d\n",i);
    change(&i);//C语言的函数调用是值传递，实参赋值给形参，j=&i
    printf("after change i=%d\n",i);
    return 0;
}
```

```c
before change i=10
after change i=5
```

将变量i的地址传递给 change函数时，实际效果是j=&i，依然是值传递，只是这时我们的j是一个指针变量， 内部存储的是变量i的地址，所以通过\*j就间接访问到了与变量i相同的区域， 通过*j=5 就实现了对变量i的值的改变.变量 j自身的地址与变量i的地址依然不相等。

## 4.指针的偏移

指针的另一个场景是对其进行加减， 对指针进行乘除是没有意义的，把对指针的加减称为指针的偏移， 加就是向后偏移，减就是向前偏移。

```c
#include <stdio.h>
//指针的偏移使用场景，也就是对指针进行加和减

#define N 5
int main() {
    int a[N]={1,2,3,4,5};//数组名内存储了数组的起始地址，a中存储的就是一个地址值
    int *p;//定义指针变量p
    p=a;
    int i;
    for(i=0;i<N;i++)
    {
        printf("%3d",*(p+i));//这里写a[i]等价的
    }
    printf("\n-----------------\n");
    p=&a[4];//指针变量p指向了数组的最后一个元素
    for(i=0;i<N;i++)
    {
        printf("%3d",*(p-i));
    }
    return 0;
}
```

**偏移的长度是其基类型的长度**, 也就是偏移sizeof(int), 这样通过*(p+1)就可以得到元素 a[1]. 编译器在编译时， 数组取下标的操作正是转换为指针偏移来完成。

## 5.指针与一维数组

为什么一维数组在函数调用进行传递时，它的长度子函数无法知道呢? 这是由于**一维数组名中存储的是数组的首地址**. 如下例所示， 数组名c中存储是一个起始地址， 所以子函数change 中其实传入了一个地址，定义一个指针变量时， 指针变量的类型要和数组的数据类型保持一致， 通过取值操作， 就可将“h”改为“H”， 这种方法称为指针法. 获取数组元素时， 也可以通过取下标的方式来获取数组元素并进行修改， 这种方法称为下标法。

```c
#include <stdio.h>
//指针与一维数组的传递
//数组名作为实参传递给子函数时，是弱化为指针的
//练习传递与偏移
void change(char *d)
{
    *d='H';
    d[1]='E';//*(d+1)='E'与其等价
    *(d+2)='E';
}

int main() {
    char c[10]="hello";
    change(c);
    puts(c);
    return 0;
}
```

```c
HEElo
```

## 6.指针与动态内存申请

C语言的数组长度固定是因为其定义的整型、浮点型、字符型变量、数组变量都在栈空间中，而**栈空间**的大小在编译时是确定的，如果使用的空间大小不确定，那么就要使用**堆空间**。

```c
#include <stdio.h>
#include <stdlib.h> //malloc使用的头文件
#include <string.h>
int main() {
    int size;//size代表我们要申请多大字节的空间
    char *p;//void*类型的指针不能偏移的，因此不会定义无类型指针
    scanf("%d",&size);//输入要申请的空间大小
    //malloc返回的void*代表无类型指针
    p=(char*)malloc(size);
    strcpy(p,"malloc success");
    puts(p);
    free(p);//释放申请的空间时，给的地址，必须是最初malloc返回给我们的地址
    printf("free success\n");
    return 0;
}
```

首先我们来看 malloc函数. 在执行#include <stdlib.h>  void\*malloc(size_t size);时, 需要给 malloc传递的参数是一个整型变量，这里的 size_t即为int；**返回值为 void\*类型的指针**， **void\*类型的指针只能用来存储一个地址而不能进行偏移**， 因为 malloc并不知道我们申请的空间用来存放什么类型的数据， 所以确定要用来存储什么类型的数据后， 都会将void\*强制转换为对应的类型， 上例用来存储字符， 所以将其强制转换为char*类型。

注意指针本身大小，和其指向的空间大小，是两码事，不能和前面的变量类比去理解！

如下图所示， 定义的整型变量i、指针变量p均在main函数的栈空间中，通过malloc申请的空间会返回一个堆空间的首地址，我们把首地址存入变量 p.知道了首地址，就可以通过 strcpy函数往对应的空间存储字符数据。

![栈空间与堆空间](https://photo.w-4.cn/typora/image-20240414114717105.png)

**堆的效率要比栈低得多**

栈空间由系统自动管理，而堆空间的申请和释放需要自行管理，所以在具体例子中需要通过 free函数释放堆空间， free函数的头文件及格式为

```c
#include <stdlib.h>
void free(void *ptr);
```

其传入的参数为 void类型指针， 任何指针均可自动转为 void\*类型指针， 所以我们把 p传递给free函数时， 不需要强制类型转换。**p的地址值必须是 malloc当时返回的地址值，不能进行偏移**，也就是在 malloc 和free之间不能进行 p=p+1 等改变变量p的操作，原因是申请一段堆内存空间时， 内核帮我们记录的是起始地址和大小，所以释放时内核用对应的首地址进行匹配，匹配不上时，进程就会崩溃。如果要偏移进而存储数据，那么可以定义两个指针变量来解决.

## 7. 栈空间与堆空间的差异

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//堆和栈的差异

char* print_stack()//函数栈空间释放后， 函数内的所有局部变量消失
{
    char c[100]="I am print_stack func";
    char *p;
    p=c;
    puts(p);
    return p;
}

char *print_malloc()
{
    char *p=(char*)malloc(100);//堆空间在整个进程中一直有效，不因为函数结束，而消亡
    strcpy(p,"I am print malloc func");
    puts(p);
    return p;
}

int main() {
    char *p;
    p=print_stack();
    puts(p);
    p=print_malloc();
    puts(p);
    free(p);//只有free时，堆空间才会释放
    return 0;
}
```

```c
I am print_stack func
I am priޘ`�� func
I am print malloc func
I am print malloc func
```

第二次打印会有异常,原因是print_stack()函数中的字符串存放在栈空间中，**函数执行结束后，栈空间会被释放**，字符数组c的原有空间已被分配给其他函数使用, 因此在调用 print_stack()函数后, printf("p=%s\n",p);中的p不能获取栈空间的数据，而 print_malloc()函数中的字符串存放在堆空间中，**堆空间只有在执行free操作后才会释放，否则在进程执行过程中会一直有效。**

## 8.例题

输入一个整型数，然后申请对应大小空间内存，然后读取一个字符串（测试用例的字符串中含有空格），字符串的输入长度小于最初输入的整型数大小，最后输出输入的字符串即可（无需考虑输入的字符串过长，超过了内存大小）

```c
#include <stdio.h>
#include <stdlib.h>
//malloc的使用
int main() {
    int n;//代表申请空间大小
    scanf("%d",&n);//读取
    char c;
    scanf("%c",&c);//清除标准输入缓冲区中的\n
    char *p;
    p=(char*)malloc(n);//申请n个字节大小的空间，强制类型转换为char*
    gets(p);//可以使用fgets(p,n,stdin); gets被去掉是因为不安全，会访问越界
    puts(p);
    return 0;
}
```

注意：清除标准输入缓冲区中的\n

End

本文作者：彼岸花露
文章标题：五、指针（C语言）
本文地址：https://blog.tianlei.work/archives/112/
版权说明：若无注明，本文皆悟思记原创，转载请保留文章出处。

最后修改：2024 年 04 月 14 日

如果觉得我的文章对你有用，请随意赞赏

此处评论已关闭

今日已经过去小时

这周已经过去天

本月已经过去天

今年已经过去个月

五、指针（C语言）

彼岸花露 • 2024 年 04 月 14 日

# 五、指针

## 1.指针的定义

指针变量的定义格式如下：

```c
基类型 *指针变量名;
int *i_pointer;
```

![指针变量](https://photo.w-4.cn/typora/image-20240414105412226.png)

## 2. 取地址操作符与取值操作符，指针本质

注意

```c
int *a,*b,*c;
```

**指针的使用场景通常只有两个：传递与偏移**

## 3. 指针的传递

【例】指针的传递使用场景。

```c
#include <stdio.h>
//在子函数内去改变主函数中某个变量的值
void change(int j)//j是形参
{
    j=5;
}

![原理图](https://photo.w-4.cn/typora/image-20240414112629673.png)

【例】在子函数中修改 main函数中某个变量的值.

```c
#include <stdio.h>
//在子函数内去改变主函数中某个变量的值
void change(int *j)//j是形参
{
    *j=5;//*j等价于变量i，只是间接访问
}

```c
before change i=10
after change i=5
```

## 4.指针的偏移

指针的另一个场景是对其进行加减， 对指针进行乘除是没有意义的，把对指针的加减称为指针的偏移， 加就是向后偏移，减就是向前偏移。

```c
#include <stdio.h>
//指针的偏移使用场景，也就是对指针进行加和减

## 5.指针与一维数组

int main() {
    char c[10]="hello";
    change(c);
    puts(c);
    return 0;
}
```

```c
HEElo
```

## 6.指针与动态内存申请

注意指针本身大小，和其指向的空间大小，是两码事，不能和前面的变量类比去理解！

![栈空间与堆空间](https://photo.w-4.cn/typora/image-20240414114717105.png)

**堆的效率要比栈低得多**

栈空间由系统自动管理，而堆空间的申请和释放需要自行管理，所以在具体例子中需要通过 free函数释放堆空间， free函数的头文件及格式为

```c
#include <stdlib.h>
void free(void *ptr);
```

## 7. 栈空间与堆空间的差异

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//堆和栈的差异

char* print_stack()//函数栈空间释放后， 函数内的所有局部变量消失
{
    char c[100]="I am print_stack func";
    char *p;
    p=c;
    puts(p);
    return p;
}

int main() {
    char *p;
    p=print_stack();
    puts(p);
    p=print_malloc();
    puts(p);
    free(p);//只有free时，堆空间才会释放
    return 0;
}
```

```c
I am print_stack func
I am priޘ`�� func
I am print malloc func
I am print malloc func
```

## 8.例题

注意：清除标准输入缓冲区中的\n

五、指针（C语言）

Handsome美化（六十一—八十五）

Handsome美化（一—三十）

Handsome美化（三十一—六十）

获取qq头像api接口

更换全局音乐播放器为无损本地音乐过程记录

一、C语言导学与数据类型、数据输入输出（C语言）

勾指成誓

二、运算符与表达式（C语言）

五、指针（C语言）

获取qq头像api接口

五、指针（C语言）