C语言的指针（基础）

目录

指针是什么？

指针变量

指针和指针类型

指针+-整数

野指针

野指针成因

如何规避野指针

指针运算

指针+-整数

指针-指针

指针的关系运算

指针和数组

二级指针

指针数组

---

指针是什么？

指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址

2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常指的是指针变量

---

指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个 变量就是指针变量

#include <stdio.h>

int main()
{
    int a = 10;//在内存中开辟一块空间
    int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
                //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中
                //p就是一个之指针变量。
    return 0;
}

总结：

指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）

---

 但这样我们就会想到一些问题：

一个小的单元到底是多大？（1个字节）

如何编址？

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电 平（低电压）就是（1或者0）

 那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

...

11111111   11111111   11111111   11111111

这里就有2的32次方个地址

每个地址标识一个字节，那我们就可以给 （2^32Byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB） 4G的空间进行编址

（64位计算机同理计算）

这里我们就明白：

在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节 

那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

指针变量是用来存放地址的，地址是唯一标示一个内存单元的

指针的大小在32位平台是4个字节，在64位平台是8个字节

---

 指针和指针类型

将&num（num的地址）保存到p中

我们知道p就是一个指针变量，那它的类型是怎样的呢？

我们给指针变量相应的类型

char* pc = NULL;
int* pi = NULL;
short* ps = NULL;
long* pl = NULL;
float* pf = NULL;
double* pd = NULL;

char* 类型的指针是为了存放 char 类型变量的地址

short* 类型的指针是为了存放 short 类型变量的地址

int* 类型的指针是为了存放 int 类型变量的地址

以此类推...

指针类型的意义是什么？

指针类型决定了，在解引用指针的时候访问几个字节（也是决定了访问的方式）

---

指针+-整数

#include <stdio.h>
//演示实例
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;
}

这里可以看到，不同的指针类型，加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;
    int i = 0;
    for (i = 0; i <= 11; i++)
    {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
    }
    return 0;
}

3. 指针指向的空间释放

（未来到动态开辟内存的时候在展开了解）

如何规避野指针

1. 指针初始化

2. 小心指针越界

3. 指针指向空间释放，及时置NULL

4. 避免返回局部变量的地址

5. 指针使用之前检查有效性

---

指针运算

指针+-整数

我们这里使用自定义实现strlen函数来举例

int my_strlen(char* str)
{
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}

这里可以看到，str作为字符指针，str++也就是str = str + 1

令指针指向下一个元素（跳过一个指针类型）

需要注意的是：对于不同的指针类型，加减会有不同的效果

例如：

int*类型的指针+1跳过4个字节

char*类型的指针+1跳过1个字节

减法同理

---

指针-指针

（也就是地址减去地址，前提是两个指针指向同一个空间，指针类型一致）

看一个代码（这是实现my——strlen的另一种方式）

int my_strlen(char* s)
{
    char* p = s;
    while (*p != '\0')
        p++;
    return p - s;
}

上面这个代码使用指针变量p来接收s的地址，当p所指向的元素不为\0时，p自增

根据上面说的指针加减，我们可以知道每循环一次p跳过一个字节

当p的元素指向\0时，返回指针p减指针s

由于p指向了该字符串的末尾，也就是该字符串末尾元素的地址

而s指向的是字符串首元素的地址

两指针相减也代表两地址相减，得到的也就是该字符串的元素个数

（指针加整数等于指针，指针减指针等于整数）

---

指针的关系运算

地址与地址之间也可以进行比较

而比较的是地址的高低

看一个代码

#define N_VALUES 5

float values[N_VALUES];
float* vp = &vaules;

for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

定义一个float数据类型，有5个元素的数组vaules， 令vp指针指向该数组

进入循环，首先先将vp重新赋值指向define定义的N_VALUES为下标的数组values处

由于该数组只有5个元素，此时指向values[5]的位置，即为数组外

当vp的地址大于数组首元素地址时，vp自减，同时将其指向的元素重新赋值为0

但是这种方式并不美观，可以换成这种方式表达

for(vp = &values[N_VALUES - 1]; vp >= &values[0]; vp--)
{
    *vp = 0;
}

但是实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行

C语言标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较

---

指针和数组

下面看一个例子

#include <stdio.h>

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

 可以得到以上的答案，可见数组名和数组首元素的地址是一样的

通过这个结论，这样写代码是可行的

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;    //p存放的是数组首元素的地址

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能

例如

#include <stdio.h>

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    int* p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    for (int i = 0; i < sz; i++)
    {
        printf("&arr[%d] = %p   <====> p + %d = %p \ n", i, &arr[i], i, p + i);
    }
    return 0;
}

 可以得到一下的结果：

所以 p+i 其实计算的是数组 arr 下标为i的地址

那我们就可以直接通过指针来访问数组

#include <stdio.h>

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int* p = arr; //指针存放数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

通过比较上面的代码，我们可以发现

                                                     *（p + i）其实与arr[ i ]是等效的  

---

二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

这就是 二级指（存放指针的指针）

举个例子

#include <stdio.h>

int main()
{
	int a = 10;//a要向内存申请4个字节的空间存放10

	int* pa = &a;//pa是指针变量，用来存放a的地址，向内存申请4/8个字节的空间

	*pa = 20;//通过*解引用符号来访问pa里面的数据

	int** ppa = &pa;//ppa也是指针变量，用来存放指针pa的地址，向内存申请4/8个字节的空间

	**ppa = 30;//通过解引用来访问ppa存放的pa的数据，由于pa也是地址，需要再次解引用访问pa的数据
}

 还有三级指针，四级.....

---

指针数组

指针数组是指针还是数组？

是数组，一个存放指针的数组

那指针数组是怎样的？

int* arr3[5];

如何理解？

arr3是一个数组，有五个元素，每个元素是一个整形指针

如何访问里面的元素？

如下

#include <stdio.h>

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	int* pa = &a;
	int* pb = &b;
	int* pc = &c;

	int* arr[3] = { pa, pb, pc };
	for (int i = 0; i < 3; i++)
	{
		printf("%d ", *arr[i]);
	}
}

这样就可以通过遍历指针再解引用访问对于指针的元素

或者还可以这样

#include <stdio.h>

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	int* pa = &a;
	int* pb = &b;
	int* pc = &c;

	int* arr[3] = { pa, pb, pc };

	int** ppa = &arr[0];
	for (int i = 0; i < 3; i++)
	{
		printf("%d ", *( * (ppa + i)));
	}
}

将数组arr的首元素存放在ppa中

（由于arr数组首元素是指针，所以需要用二级指针变量来存放）

在循环内进行二次解引用来访问（上面说过*（p + i）其实与arr[ i ]是等效的）