EP8:有关指针(c语言学习笔记:指针简介,指针运算,野指针)

1. 内存和地址

先例举生活中的一个例子:

去图书馆找书,我们肯定要根据图书的编号才可以找到书.

此处书的编号可以为任意实数.

当我们有了图书的编号,我们可以根据总表迅速找到我们想要的书.

这个内存单元相当于放书的格子.

每一个内存单元相当于一个内存编号,cpu可以快速找到一个内存空间.

c语言中,这个书的编号就相当于地址,也可以叫做指针.

2. 指针变量和地址

2.1 指针变量和解引用操作符

2.1.1 指针变量

int main()

{

     int a = 10;

     int* pa = &a;//取出a的地址并存储到指针变量pa

}

    return 0;

指针变量也是⼀种变量，这种变量就是用来存放地址的，存放在指针变量中的值都会理解为地址。

2.1.2 如何拆解指针类型

 我们看到pa的类型是 int* ，我们该如何理解指针的类型呢？

int a = 10;

int * pa = &a;

这里pa左边写的是 int* ， * 是在说明pa是指针变量，而前面的 int 是在说明pa指向的是整型(int) 类型的对象 

2.1.3 解引用操作符

我们将地址保存起来，未来是要使使的，那怎么使用呢？

在现实生活中，我们使用地址要找到一个房间，在房间里可以拿去或者存放物品。

C语言中其实也是一样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针） 指向的对象，这里必须学习一个操作符叫解引用操作符(*)。

int main()

{

     int a=100;

     int *pa = &a;

     *pa=4;

      return 0;
}

2.2 指针变量的大小

前⾯的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后 是1或者0，那我们把32根地址线产生的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4 个字节才能存储。

如果指针变量是⽤来存放地址的，那么指针变的大小就得是4个字节的空间才可以。

同理64位机器，假设有64根地址线，一个地址就是64个二进制位组成的二进制序列，存储起来就需要 8个字节的空间，指针变的大小就是8个字节。

结论：

• 32位平台下地址是32个bit位，指针变量大小是4个字节

• 64位平台下地址是64个bit位，指针变量大小是8个字节

• 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

3. 指针变量的意义

3.1 指针的解引用

指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。 比如： char* 的指针解引用就只能访问⼀个字节,而int* 的指针的解引用就能访问四个字节。

3.2 指针+-整数

先来看一段代码

int main()
{
    int n = 10;
    char* pc = (char*)&n;
    int* pi = &n;

    printf("%p\n", &n);
    printf("%p\n", pc);
    printf("%p\n", pc + 1);
    printf("%p\n", pi);
    printf("%p\n", pi + 1);
    return 0;
}

运行结果如下

结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。 

 3.3 void*指针

在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为无具体类型的指针（或者叫泛型指 针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行针的+-整数和解引用的运算。

int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	return 0;
}

在上面的代码中，将⼀个int类型的变量的地址赋值给⼀个char*类型的指针变量。编译器给出了⼀个警告(如下图），是因为类型不兼容。而使用void*类型就不会有这样的问题。

使用void*类型的指针接收地址： 

int main()
{
    int a = 10;
    void* pa = &a;
    void* pc = &a;

    *pa = 10;
    *pc = 0;
    return 0;
}

里我们可以看到， void* 类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。 

那么 void* 类型的指针到底有什么用呢？ ⼀般 void* 类型的指针是使⽤在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以 实现泛型编程的效果。 

4. const修饰指针 

4.1 const修饰变量

变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。 但是如果我们希望⼀个变量加上⼀些限制，不能被修改，怎么做呢？这就是const的作用

4.1.1 const修饰指针常量

先来看一段代码

int main()
{
    const int a = 10;//a不可以被修改,但它的本质还是变量;
    int* pa = &a;      //这是改变a的方法,通过改变指向a的内存的指针pa来改变a的值(将a的地址通过a交给pa
    *pa = 0;
 }

再来看一段代码

int main()
{
    const int a = 10;    //此时a不可呗修改
    const int* pa = &a;//此时指向a的内存指针pa也不可以被修改
    *pa = 0;

//const将二者完全锁死,一个都不好改了.
 }
 

总结:可以把const当成一个锁,把它放在谁的前面谁就被锁住了

4.1.2 const修饰指针

const可以放在解引用操作符"  *  "的左边或右边,它们各自有什么意义呢.

int*const p=&a;//此时const限制的是p这块空间

const int*p=&a;//此时限制的是p所指向的这块空间

 总结:

总而言之就是左定值,右定向.

• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本身的内容可变。

• const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指 向的内容，可以通过指针改变。

注意:指针p指向a的空间a本身也是有空间的,里面存储的是它的地址

5.指针运算

5.1 指针+-整数

因为数组在内存中是连续存放的，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = &arr[0];
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (i = 0; i < sz; i++)
    {
        printf("%d ", *(p + i));//p+i 这⾥就是指针+整数
    }
    return 0;
}
 

5.2 指针-指针

#include <stdio.h>
int my_strlen(char* s)
{
    char* p = s;
    while (*p != '\0')
        p++;
    return p - s;
}
int main()
{
    printf("%d\n", my_strlen("abc"));
    return 0;
}

5.3 指针的关系运算

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = &arr[0];
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    while (p < arr + sz) //指针的大小比较
    {
        printf("%d ", *p);
        p++;
    }
    return 0;
} 

6. 野指针

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

6.1 野指针成因

1. 指针未初始化

2. 指针越界访问

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

3. 指针指向的空间释放

#include <stdio.h>
int* test()
{
    int n = 100;
    return &n;
}
int main()
{
    int* p = test();
    printf("%d\n", *p);
    return 0;
} 

6.2 如何规避野指针

6.2.1 指针初始化

6.2.2 小心指针越界

一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

6.2.4 避免返回局部变量的地址

7. assert断言

assert.h 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。

assert(p != NULL);

 assert相当于一个宏.

int main()
{
    int a = 10;
    int* p = &a;
    p = NULL;
    if (p != NULL)
    {

    }
    return 0;
}

 这里的if语句可以换成assert(p!=NULL)

assert(p!=NULL);在这个语句中,如果判定为真,那么这个语句便不会其任何作用

如果这个语句判定为假,那么程序运行起来以后便会报错,具体到文件路径及其代码行数.

程序员编写代码时,要判断一个代码是否有问题,便会在调试(debug)的时候用上这个语句.