C语言【初始指针】【指针一】

引言

思绪很久，还是决定写一写指针，指针这块内容很多，也不是那么容易说清楚，这里尽可能写地详细，让大家理解指针。（未完序）

一、内存和地址

在讲指针前，需要有一个对内存和地址的认识，不然后面的指针不是那么容易理解。在我们的内存中：一个字节里存储着 0 或 1 的信息。那计算机是怎么快速找到对应的信息的呢？

回答：在内存中每个字节都有自己对应的地址，计算机通过找到地址，就能访问地址里面的信息。

那么指针，就是一种可以存储地址的数据类型。

二、一级指针

1.存地址：

重点：其实指针是很简单的，只要会使用int ，float， double，long long 等数据类型，那么指针变量，你也一定会使用。

先介绍一下指针变量是怎么创建的：

在对应数据类型的后面加上*，就可以存储该类型的内存地址。

认识个东西： & 取地址操作符，看下面的代码：
	int b = 10;int* a = &b;
这段代码创建了一个变量b，&b，就可以取出b的地址。
int* 就是int类型的指针变量，a 里面存的就是 b 的地址

通过调试来看一下：

可以看到 b 的地址

下面通过监视窗口，看一下a里面存的是什么：

发现就是b的地址。

类似地，如果要存float数据类型的地址，就要创建float类型的指针变量：
	float c = 1.2;float* d = &c;
d中存储的就是 c 的地址。

其他的数据类型一样，包括自定义类型的数据。

可以自己多试试。

2.解读地址对应的内容：

要用到一个东西：解引用操作符：*

使用起来也特别简单：

比如上面代码中，a中存储的是b的地址，*a，就可以找到b对应位置的内容了

来看代码：
#include<stdio.h>int main()
{int b = 10;int* a = &b;int c = *a;  //*a 等价于 bprintf("%d\n", c);*a = 20;   //改变a地址里面的内容，就是把b的内容给改了printf("%d\n", b);return 0;
}
运行结果：

是不是特别简单，认为指针难，是因为你不理解每个符号的内容，这里给拆开来讲，相信你一定明白了

3.指针变量的大小

int在内存中占4个字节，float在内存中占4个字节，double在内存中占8个字节，和int，float，double等类型一样，指针类型在内存中也是占有字节的。

那指针类型在内存中占多少个字节呢？

先给出结论，下面来看代码证明。

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

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

• 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。（和CPU里面的线路有一定的关系）

sizeof操作符同样可以返回指针类型在内存中占多少个字节。

#include<stdio.h>
int main()
{printf("%zd\n", sizeof(char*));printf("%zd\n", sizeof(short*));printf("%zd\n", sizeof(int*));printf("%zd\n", sizeof(double*));return 0;
}

在不同平台下运行这段代码：

在32位平台下：

运行结果：

在64位平台下：

运行结果：

三、指针变量类型的意义

你是不是会有这么个疑问：

指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢？

其实指针类型是有特殊意义的，通过两中方法来理解一下。

1.指针的解引用

下面看两段代码：
//代码1
#include <stdio.h>
int main()
{int n = 0x11223344;int* pi = &n;*pi = 0;return 0;
}
//代码2
#include <stdio.h>
int main()
{int n = 0x11223344;char* pc = (char*)&n;*pc = 0;return 0;
}
代码二中给int*类型，强制转换成了char*类型。最后都解引用后赋值0

通过调试，来看一下两段代码在内存中的存储。

代码一：

代码二：
相信聪明的你一定发现了不同，代码1会将n的4个字节全部改为0，但是代码2只是将n的第一个字节改为0。

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

2.指针+ -整数

有了上面的结论，这个就很容易理解了

来看代码：

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

来看运行结果：

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

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

四、void* 指针

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

来看代码：

#include <stdio.h>
int main()
{int a = 10;int* pa = &a;char* pc = &a;return 0;
}

这段代码在编译的时候肯定是会报警告的。（因为类型不兼容）

#include <stdio.h>
int main()
{int a = 10;void* pa = &a;void* pc = &a;//*pa = 10; 这样写是错误的//*pc = 0;return 0;
}

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

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

五、指针运算

1.指针+-整数

上面的一个代码已经可以看出这个功能了，这里再通过一个案例来理解一下（也算是一个小的练习）

通过地址来访问一个数组。

#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]);for (int i = 0; i < sz; i++){printf("%d ", *(p + i));}return 0;
}

运行结果：

从这个案例中可以看出：*(p + i) 等价于 p[i]。（其实就是这样）

这也可以说明数组名是就是数组首元素的地址。

不过有来个特例需要记一下：

1. &arr，对数组名取地址，得到的是整个数组的地址，而不是首元素的地址。

2. sizeof(arr)，这里面的arr也是整个数组的地址，而不是首元素的地址。

把上面代码改一下来证明一下：

#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]);for (int i = 0; i < sz; i++){//printf("%d ", *(p + i));printf("%d ", p[i]);}return 0;
}

只改了一个地方，就是输出位置。

运行结果：

是不是又增加了新知识，嘿嘿(●ˇ∀ˇ●)

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

运行结果：

3.指针的关系运算

指针之间也是可以比较大小的

来看代码：

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

运行结果：