C语言深入了解指针（1）-- 指针变量和地址（指针），指针变量类型的意义，const 修饰指针，指针运算，野指针，assert 断言，传址调用

在计算机中把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。其中，每个内存单元，相当于⼀个学⽣宿舍，⼀个字节空间⾥⾯能放8个⽐特位，就好⽐同学们住的⼋⼈间，每个⼈是⼀个⽐特位。每个内存单元也都有⼀个编号（即为地址）（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。C语⾔中给地址起新的名字叫：指针。内存单元的编号 == 地址 == 指针。

计算机中内存大概如下图：

2.指针变量和地址

2.1 取地址操作符（&）

在C语⾔中创建变量其实就是向内存申请空间，⽐如：

⽐如，上述的代码就是创建了整型变量a，内存中申请4个字节，⽤于存放整数10，其中每个字节都有地址。上图中4个字节的地址分别是：

通过取地址操作符（&）可以获取变量a的地址：

通过上述第五行的取地址操作，获得变量a的地址为0x006FFD70。虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可⾏的。

**2.2 指针变量和解引⽤操作符（*）**

2.2.1 指针变量

我们通过取地址操作符(&)拿到的地址是⼀个数值，⽐如：0x006FFD70，这个数值有时候也是需要存储起来，⽅便后期再使⽤的，那我们把这样的地址值存放在哪⾥呢？答案是：指针变量。指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址。注：我们在学习或工作上口头通常说的指针实际上就是指的指针变量。

2.2.2 如何拆解指针类型

这⾥pa左边写的是 int* ， * 是在说明pa是指针变量，⽽前⾯的 int 是在说明pa指向的是整型(int)类型的对象。

2.2.3 解引⽤操作符

我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。

#include <stdio.h>

int main()
{
    int a = 100;
    int* pa = &a;
    *pa = 0; //对指针pa进行解引用*pa == a ,修改a变量的值
    return 0;
}

2.3 指针变量的⼤⼩

结论：

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

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

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

3.指针变量类型的意义

3.1 指针的解引⽤

代码1:

//代码1
#include <stdio.h>

int main()
{
    int n = 0x11223344;
    int* pi = &n;
    *pi = 0;
    return 0;
}

代码2：

//代码2
#include <stdio.h>

int main()
{
    int n = 0x11223344;
    char *pc = (char*)&n; //将int*类型的指针变量强行转换为char*类型的指针变量
    printf("%d ", *pc); // 这里打印出来的值为 68
    // 因为在该主机上 0x11223344 是按照小端存储的，也就是说，0x11223344 需要四个字节存储
    // 该变量的起始地址（低地址）存放的是
    // 低权值位也就是 0x44，0x44 的十进制为 68
    return 0;
}

上述两段代码通过调试可以得到，代码1会将n的4个字节全部改为0，代码2只是将n的第一个字节改为0.

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

3.2 指针+-整数

char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可以-1。

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

**3.3 void* 指针**

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

**3.3.1 void* 指针的作用**

⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得⼀个函数来处理多种类型的数据。

4.const 修饰指针

4.1 const修饰变量

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

注：C语言中const修饰的n还是变量叫做常变量，依然具有变量的属性，C++中const修改的n就是常量。

#include <stdio.h>

int main()
{
    int m = 0;
    m = 20; //m是可以修改的
    const int n = 0;
    n = 20; //n是不能被修改的
    return 0;
}

但是如果我们绕过n，使⽤n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

#include <stdio.h>

int main()
{
    const int n = 0;
    printf("n = %d\n", n);
    int* p = &n;
    *p = 20;
    printf("n = %d\n", n);
    return 0;
}

输出结果：

4.2 const修饰指针变量

⼀般来讲const修饰指针变量，可以放在*的左边，也可以放在*的右边，意义是不⼀样的。

结论：const修饰指针变量的时候：

• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。（指针原本指向m这个变量，则不能修改m这个变量的值。const放在*左边‘*也叫做解引用符号’，相当于修饰了解引用之后的变量，故修饰m或者叫做*m。但是指针可以修改指向变量n）

• const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。（指针原本指向m这个变量，m这个变量的内容能修改，但是指针不可以改变指向n变量）

5.指针运算

指针的基本运算有三种，分别是：（1）指针+-整数（2）指针 - 指针（3）指针的关系运算

5.1 指针+- 整数

#include <stdio.h>
//指针+- 整数
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0]; //将数组首元素的地址给p
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; i++)
    {
        printf("%d ", *(p+i));//p+i 这⾥就是指针+整数
    }
    return 0;
}

上述代码是通过指针的方式对数组进行遍历，打印arr数组.

5.2 指针-指针

类比于日期：

日期 +/- 天数 = 日期指针 +/- 整数 = 指针

日期 - 日期 = 天数指针 - 指针 = 指针和指针之间元素的个数(非字节个数)

日期 + 日期 这个运算不可行 指针 + 指针 不可行

#include <stdio.h>

//指针-指针
//模拟strlen--计算字符串中字符的个数

int my_strlen(const char* s)
{
    const 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.指针未初始化：

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

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 指针初始化

如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错。

初始化如下：

#include <stdio.h>
int main()
{
    int num = 10; 
    int*p1 = &num; //直接赋值已有的变量地址
    int*p2 = NULL; //赋值NULL
 
    return 0;
}

6.2.2 ⼩⼼指针越界

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

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

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使⽤指针之前可以判断指针是否为NULL。

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

参考野指针成因的第三个例子。

7. assert 断⾔

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

上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。（如果assert()中的参数为true则程序继续运行）.

assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零），assert() 就会报错，在标准错误流 stderr 中写⼊⼀条错误信息，显⽰没有通过的表达式，以及包含这个表达式的⽂件名和⾏号。

assert() 的使⽤对程序员是⾮常友好的，使⽤ assert() 有⼏个好处：它不仅能⾃动标识⽂件和出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断⾔，就在 #include <assert.h> 语句的前⾯，定义⼀个宏 NDEBUG 。

assert() 的缺点是，因为引⼊了额外的检查，增加了程序的运⾏时间。

⼀般我们可以在 Debug 中使⽤，在 Release 版本中选择禁⽤ assert 就⾏，在 VS 这样的集成开发环境中，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在 Release 版本不影响⽤⼾使⽤时程序的效率。

8. 传址调用

8.1 strlen的模拟实现

库函数strlen的功能是求字符串⻓度，统计的是字符串中 \0 之前的字符的个数。

参数str接收⼀个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回⻓度。如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停⽌。

int my_strlen(const char * str)
{
    int count = 0;
    assert(str); //判断传过来的是否为有效指针
    while(*str) //循环计数
    {
        count++;
        str++;
    }
    return count;  
}

int main()
{
    int len = my_strlen("abcdef");
    printf("%d\n", len);
    return 0;
}

8.2 传值调用和传址调用

学习指针的⽬的是使⽤指针解决问题，那什么问题，⾮指针不可呢？

例如：写⼀个函数，交换两个整型变量的值

void Swap1(int x, int y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

上述代码无法解决交换的问题。函数中的x, y会重新申请新的地址来存储主函数传过来的值，交换x, y的值是交换新申请地址中的值，当函数结束时，新申请的地址被销毁，里面的没有返回主函数中，这种叫传值调用。

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参。

可以使⽤指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数⾥边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。

#include <stdio.h>
void Swap2(int*px, int*py)
{
    int tmp = 0;
    tmp = *px;
    *px = *py;
    *py = tmp;
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("交换前：a=%d b=%d\n", a, b);
    Swap2(&a, &b);
    printf("交换后：a=%d b=%d\n", a, b);
    return 0;
}