深入理解指针（1）

一、指针变量和地址

1、取地址操作符（&）

#include"stdio.h"
int main()
{
    int a = 10;
    &a;//取出a的地址
    printf("%p\n",&a);
    return 0;
}

2、指针变量和解引用操作符（*）

1.指针变量

我们通过取地址操作符（&）拿到地址的数值，这个数值有时候也是要存储起来，方便后期再使用，所以我们把这个放在指针变量中。

#include"stdio.h"
int main()
{
    int a = 10;
    int * pa = &a;//取出a的地址并存储到指针变量pa中
    return 0;
}

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

2.如何拆解指针类型

我们知道pa的类型是int*

1  int a = 10;
2  int * pa = &a;

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

3.解引用操作符

#include"stdio.h"
int main()
{
    int a = 100;
    int* pa = &a;
    *pa = 0;
    return 0;
}

上面代码第6行就使用了解引用操作符，*pa的意思就是通过pa中存放的地址，找到指向的空间，*pa其实就是a变量了；所以*pa=0，这个操作符是把a改成了0；

3、指针变量的大小

假设有32根地址总线，一个地址就是32个bit位，需要4个字节才能储存

假设有64根地址总线，就需要8个字节存储

结论：

• 32位平台下地址是32个bit位，指针变量大小是4个字节
• 64位平台下地址是64个bit位，指针变量大小是8个字节
• 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

二、指针变量类型的意义

1、指针的解引用

指针的类型决定了对指针解引用的时候有多大权限（一次能操作几个字节）。

比如：char*的指针解引用就只能访问一个字节，而int*的指针解引用就能访问四个字节。

2、指针+-整数

char*类型指针变量+1跳过1个字节，int*类型指针变量+1跳过了4个字节。

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

3、void*指针

在指针中有一种特殊的类型是void*类型的，可以理解为无具体类型的指针（或者叫泛指针），这种类型的指针可以用来接受任意类型地址。

void*类型的指针不能直接进行指针的+-整数和解引用运算。

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

一般void*类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程效果。

三、const修饰指针

1、const修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量也可以修改这个变量。

如果我们使用const，则这个变量上加了一些限制，从而不被修改。

上述代码n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就报错，没办法直接修改n。

2、const修饰指针变量

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

1  int * p;//没有const修饰
2  int const * p;//const放在*的左边做修饰
3  int * const p;//const放在*的右边做修饰

结论：

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

四、指针运算

指针的基本运算有三种

• 指针+-整数
• 指针-指针
• 指针的关系运算

1、指针+-整数

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

2、指针-指针

3、指针的关系运算

#include<stdio.h>

int main() 
{
    int arr[5] = { 1, 2, 3, 4, 5 };
    int* p1 = &arr[2]; // 指向数组中的第三个元素  
    int* p2 = &arr[3]; // 指向数组中的第四个元素  
    int* p3 = p1;      // 指向和p1相同的地址  

    // 比较指针是否相等  
    if (p1 == p3) {
        printf("相等\n");
    }

    // 比较指针是否不相等  
    if (p1 != p2) {
        printf("不相等\n");
    }

    // 比较一个指针是否在另一个指针之前  
    if (p1 < p2) {
        printf("yes\n");
    }

    // 比较一个指针是否在另一个指针之后  
    if (p2 > p1) {
        printf("yes\n");
    }

    // 比较一个指针是否不大于另一个指针  
    if (p1 <= p2) {
        printf("yes\n");
    }

    // 比较一个指针是否不小于另一个指针  
    if (p2 >= p1) {
        printf("yes\n");
    }

    return 0;
}

五、野指针

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

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;
}

2、如何规避野指针

1.指针初始化

如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以赋值NULL。

#include"stdio.h"
int main()
{
    int num = 10;
    int* p1 = #
    int* p2 = NULL;
    return 0;
}

2.小心指针越界

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

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

#include"stdio.h"
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int* p = a;
    int i = 0;
    for(i=0;i<10;i++)
    {
        *(p++) = i;
    }
    //此时p已经越界了，可以把p置为NULL
    p = NULL;
    //下次使用时，判断p不为NULL的时候再使用
    
    p = &arr[0];//重新让p获得地址
    if(p != null)//判断
    {
        //
    }
    return 0;
}

六、assert断言

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

1   assert(p != NULL};

接下来是正常运行：

七、指针的使用和传址调用

1、strlen的模拟实现

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

函数原型如下：

1  size_t strlen 9 const char * str );

参考代码如下：

#include<stdio.h>

size_t my_strlen(const char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	printf("%d\n", my_strlen("abcdef"));
	return 0;
}

2、传值调用和传址调用

我们发现并没有实现交换啊，这是因为传值调用是指在函数调用时，将实际参数的值复制一份，然后将复制的值传递给形式参数，形式参数是实际参数的一份临时拷贝。这意味着在函数体内部，对形式参数的操作并不会影响到实际参数的值。这是因为形式参数和实际参数分别占用不同的内存空间，对形式参数的修改不会影响到实际参数。

而传址调用呢：

我们发现这个很顺利的就完成了交换。