C语言笔记（十二）——一维指针（一）

左手的ㄟ右手 2022-05-23 10:55 200阅读 0赞

## 小常识： ##

计算机中绝大部分数据都是放在内存中的，不同数据放在不同的内存区域：变量放在堆中，常量放在栈中

*  在内存中，数据以二进制的形式存在，以字节为单位进行数据的存取，每8个二进制组成一个字节。
 *  内存中每个字节都有唯一的编号，按字节编号，从0开使依次递增，如下图冒号左边。
 *  不同数据类型占据的字节数不同，如：int占4个字节，short占2个字节。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70][]

# 怎样得到变量的内存地址？ #

## 1. 直接寻址 ##

内存的地址是一个无符号整数，一般用取地址运算符‘&’得到某变量的地址。

比如定义一个变量i，输出它的值和存取地址：

int main()
    {
    	int i = 6;
    	printf("i = %d\n", i);
    	printf("i的地址为：%d\n", &i);
    
    	return 0;
    }

![20200223095716426.png][]

## 2. 间接寻址 ##

通过**存放变量地址**的其他变量访问该变量。可通过指针类型来实现该功能

### 2.1 指针变量 ###

定义：具有指针类型的变量

变量的指针<==>变量的地址

![20200310103808871.png][]

### 2.2 指针变量的定义 ###

> int a = 8;    
> 
> int \*p；//定义了可以指向int型数据的指针变量。告诉编译器p是一个指针变量，占4个字节，需要用一个int类型的地址给它赋值。“\*”表示间接寻址运算符，用来取地址单元p中的内容
> 
> p = &a；//初始化指针，给出指针p指向的地址
> 
> 还可以写成
> 
> int\* p = &a；

注：定义指针时必须要**初始化指针**，给出指针指向的地址。指针变量只能存放地址，不能将一个int型变量直接赋值给一个指针。如：p = 10；将整数10直接赋值给指针变量p，是不可以的

int main()
    {
        int a = 2;
        // int *p ; //定义一个指针变量，*p代表指针所指内存的实际数据
        //p = &a; //这两句实现的功能=int  *p = &a;
        int* p = &a; //声明指针变量时，将*和数据类型放一块。采用int型，即内存中前4个字节保存的数据是p的
        int b = *p; //*紧挨着指针变量代表“取p指针地址指向的数据”
        printf("b =%d\n", b);
        *p = 10;//修改指针变量p所指向的b变量的值，称为指针的解引用，此时b=10
        printf("a = %d\n", a);
        return 0;
    }

> 其中\*p = 10; 中引用指针指向的变量的值，称为指针的解引用

## **注：** ##

*  **指针变量的值一般不能直接赋值一个整数，而是通过取变量地址的方式赋值；**
 *  **\*pint的意思是取pint指针指向的变量内存中的数据；**
 *  **pint代表i的地址，\*pint代表i的值；**
 *  **\*pint = 4间接更改i的值，相当于将I的地址编号为0x123里面的值改为4.**

为了访问pint所指向的实际对象，我们必须先用**解引用操作符（\*）**来接除pint的引用。例如：下面我们通过pint间接的给i加1：

//通过pint间接地给ival加1
    *pint = *pint + 1；
    
    它等价于值传递中直接对i操作的语句：
    
    //直接给i加1
    i = i + 1；

## 2.3 无类型指针 ##

定义一个指针变量，但不指定它指向具体哪种数据类型。可以通过强制转化将void \*转化为其他类型指针，也可以用（void\*）将其他类型指针强制转化为void类型指针。

>     void \*p；

## 2.4 空指针（NULL） ##

空指针表示值为NULL的指针，即无效指针，相当于0。当指针不指向任何一个有效内存地址的时候，我们应该把指针设置为NULL。

**注**：

并非所有编译器都使空指针指向0地址，有些编译器为空指针使用不存在的内存地址。

没有指向任何变量地址的指针叫野指针，程序应该避免野指针的存在

int main()
    {       
        int a = 10;
        int *p = &a;
        p = NULL;
        if (p)
        {
            printf("true\n");
        }
        else
        {
            printf("fasle\n");
        }
        return 0;
    }

## ![70][] ##

## 2.5 野指针 ##

int main () //野指针，不是空指针，只是没有指向具体的地址内存，所以显示不确定
    {
        int a = 10;
        int *p; //避免使用野指针，更不能读写野指针指向的内存
        *p = a;
        printf("a = %d\n", *p);
        return 0;
    }

会出现错误提示：

![20200226102123549.png][]

## 2.6 兼容性问题 ##

指针间赋值比普通数据类型赋值检测更严格，例如：不能把一个int \*赋值给char \*类型。原则上一定是相同类型的指针指向相同类型的变量地址，不能用一种类型的指针指向另一种类型的变量地址。

![70 1][]

int main()//指针的兼容性
    {
        int a = 0x1310;
        char *d = &a; //int-char会导致数据丢失，因为d是一个字节的，所以只显示最小的两位
        
        char b = 2;
        int *p = &b; //p为整型，一个字节2位，所以2为02. 
        
        printf("%x %x %x %x\n", a, *d, b, *p);
        return 0;
    }

![70 2][]

## 1.8 指向常量的指针和指针常量 ##

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td style="width:102px;">名字</td> 
 <td style="width:102px;">形式</td> 
 <td style="width:295px;">例子</td> 
 <td style="width:295px;">区别</td> 
 </tr> 
 <tr> 
 <td style="width:102px;">指针常量</td> 
 <td style="width:102px;">*&nbsp; &nbsp;const&nbsp; p1</td> 
 <td style="width:295px;">int&nbsp;* const p1 = &amp;data1;</td> 
 <td style="width:295px;"> 定义后，就固定指向一个地址， 程序运行期间指针指向的地址不变，但可对该地址对象（*p1）赋值来改变p1所指向空间的内容 即 *p1 = 200； </td> 
 </tr> 
 <tr> 
 <td style="width:102px;">常量指针</td> 
 <td style="width:102px;">const&nbsp; &nbsp;*&nbsp; p1</td> 
 <td style="width:295px;">const int *p = &amp;data2;</td> 
 <td style="width:295px;"> const 修饰的是*p，p可以更改自身的指向，但不通过*p给p所指向的空间赋值。 定义后，只能指向一个变量，但指针的指向地址可以改变 即 p = &amp;data1; &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="width:102px;">指向常量的常量指针</td> 
 <td style="width:102px;">const (type) * const 变量名</td> 
 <td style="width:295px;">const int * const p2 = &amp;data1；</td> 
 <td style="width:295px;"> *号左边的const修饰的是*p2，*号右边的const修饰的是p2。p2不能更改自身的指向，也不能通过*p2去修改p2所指向空间的内容 </td> 
 </tr> 
 </tbody> 
</table>

（1） 常量指针例子：

const char *p；//定义一个指向常量的指针。
    
        char *const p； //定义一个指针常量，一旦初始化后其内容不可以更改
    
    int main()//常量指针
    {
        int a = 10;
        int b = 4;
        const int *p = &a;//p这个指针只能指向一个常量，即*p是个只读的值，不能修改它的值，但可以修改它指向的地址，比如下面的p = &b
       //*p = 20;  // 不能通过*p的方法修改一个const指针，即不能将const int *作为左值使用
        a = 20; //可通过修改变量的值改变结果
        p = &b;
        printf("*p = %d，a = %d\n", *p, a);
        return 0;
    }

![70 3][]

（2）指针常量的例子：

int main()//指针常量：一旦定义之后就固定的指向一个地址，这个地址是不能在程序运行期间改变的 
    { 
        int a = 10; 
        int b = 4; 
        int * const p = &a;//定义一个常量指针p，可通过它修改或读取一个变量的值 
        *p = 20; 
        //a = 22; 
        //p = &b; //错误，常量指针一旦定义，就不能修改其指向的变量 
        printf("a = %d %d\n", *p, a); 
        return 0; 
    }

## 1.9 指针与数组的关系 ##

一个变量有地址，一个数组包含若干个元素，每个元素在内存中都有地址。

int a\[10\]；

int \*p = a；

此时p和&a\[0\]的地址相同

p\[10\] = 5;//将数组的第11位赋值为5.

使用指针访问数组，从语法上可以和数组方式一样，就是通过“指针名\[下标\]”的方式访问

int main()
    {
        int array[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
        int *p = &array;
        printf("%d\n", p[5]);
        p[5] = 10;
        printf("%d\n", p[5]);
        return 0;
    }

## ![70 4][] ##

## 1.10 指针运算 ##

1）指针运算不是简单的整数加减法，而是指针指向的数据类型在内存中占用字节数作为倍数的运算，

char \*p；

p++； //表示一次移动了sizeof（char）这么多的字节数，即一次一位

int \*p1；

p++； //表示一次移动了sizeof（int）这么多的字节数，即一次4位

2）地址可以求差值，p1 - p2，表示同一数组中两元素之间的距离，是**位置差**。但不能将地址相加，无意义

注：p++；改变了指针的初始地址

3）比较两个指针地址是否相等，即通过判断p1==p2来比较两指针是否指向同一个位置。

## 1.11 给数组中某元素赋值 ##

int main() 
 { 
 int buf[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 
 int *p = buf; 
 //法1：将数组中下标为3的成员赋值 
 *(p + 3) = 20; 
 //法2：将数组中下标为5的成员赋值 
 p[5] = 10; 
 //法3：将数组中下标为7的成员赋值 
 p += 7; 
 *p = 30; 
 //法一、二都没有改变p指向的内存地址，但法三修改了p指向的值 
 for(int i = 0; i <10; i++) 
 { 
 printf("buf[%d] = %d\n", i, buf[i]); 
 }
 return 0;
 }

![70 5][]

## **1.12 指针在函数中的作用** ##

当指针在**函数中**使用时，可以在函数中通过改变形参的值来改变对应实参的值。

如：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70]: /images/20220523/f747414d259344d2be7614a014ba64e4.png
[20200223095716426.png]: /images/20220523/413f7f96f60e483682469570011a5216.png
[20200310103808871.png]: /images/20220523/20cca208868d448088726aa7f921a51f.png
[70]: /images/20220523/d8493c010c5b4b86ab70a4d593a52a49.png
[20200226102123549.png]: /images/20220523/adfddc8ee9ab4186b7775ae37835f5c7.png
[70 1]: /images/20220523/ee23b03c216c48a89b4dd09c20032492.png
[70 2]: /images/20220523/70060aaaead04342b583f03cd89d1948.png
[70 3]: /images/20220523/c818d314cb8d4584a5d6839588152682.png
[70 4]: /images/20220523/256e7da66fd44c1b9aa8f4f7c9a661a0.png
[70 5]: /images/20220523/68745d87153343eaa024fce132ac9e49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5_size_16_color_FFFFFF_t_70 1]: /images/20220523/27bb5818a32e49518c57e556402f62bf.png