铁律1：指针也是一种数据类型
一、指针
1、指针是一种变量，占有内存空间，用来把保存内存地址。指针的大小在32位平台下是4字节，64位平台下是8字节。
2、*p操作内存
1> *p放在等号左边，相当于对指向的内存空间赋值。
1
2
3
4
5
6
7
8
9
10
11
12
#include"stdio.h"
#include"stdlib.h"
int main() {
int a = 10;
int *p = &a;
*p = 20;
printf("&a : %dn", &a);
printf("p : %dn", p);
printf("a : %dn", a);
system("pause");
return 0;
}输出结果：
画个图：
也就是说：*就相当于一把钥匙，通过一个地址(&a)，修改a变量标示的内存空间。
2>*p放在等号左边，相当于从指向的内存空间中取值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include"stdio.h"
#include"stdlib.h"
int main() {
int a = 10;
int *p = &a;
*p = 20;
int c = *p;
printf("&a : %dn", &a);
printf("p : %dn", p);
printf("a : %dn", a);
printf("c : %dn", c);
system("pause");
return 0;
}输出结果：
也就是说：*就相当于一把钥匙，通过一个地址（&a），从a变量标示的内存空间取出值来。
3、指针变量和它所指向的内存空间变量是两个不同的概念
1>不断地给指针赋值，相当于指针指向不同的内存空间
1
2
3
4
5
6
7
8
9
10
#include"stdio.h"
#include"stdlib.h"
int main() {
int *p = (int *)malloc(10);
printf("p : %dn", p);
p = (int*)malloc(10);
printf("p : %dn", p);
system("pause");
return 0;
}输出结果：
图解：
开始p指向堆上开辟的一段内存空间的首地址3909952，再次对p赋值时，指针p又指向了另一段堆上开辟的内存空间的首地址3909976。也就是说给指针赋值改变的是指针本身4字节空间里存储的内存地址，并不改变指向的内存地址空间。
再举个例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void func1() {
char buf[64] = "abcdefghijklmn";
char *p2 = NULL;
p2 = (char*)malloc(100);
strcpy(p2, "0123456789");
char *p = NULL;
for (int i = 0; i < 10; i++)
{
p = &buf[i];
printf("p: %sn", p);
}
for (int i = 0; i < 10; i++)
{
p = p2 + i;
printf("p: %sn", p);
}
//printf("buf: %s", buf);
}
输出结果：
1
p = &buf[i];这里p不断的指向栈上buf[i]的地址，
1
p = p2 + i;这里p不断指向堆上p2所指向的内存空间
示意图就是这样的：
不断的改变指针p所指向的内存空间。
2>给*p赋值，不会改变指针变量的值，只会改变所指向内存空间的值。
3>若想修改指针指向的内存空间值的时候，必须保证所指向的内存空间是可以被修改的。
1
2
3
4
5
6
7
8
9
10
#include"stdio.h"
#include"stdlib.h"
int main() {
char *p = "123456";
printf("p : %dn", p);
*(p + 2) = 9;
printf("p : %sn", p);
system("pause");
return 0;
}此时指针p试图修改全局区的常量，这是不允许的，就会报错：
4>如果不能正确理解指针变量与指针所指向的内存空间变量是两个完全不同的概念，则很容易造成野指针的问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void func1() {
char *p = NULL;
p = (char*)malloc(100);
strcpy(p, "abcdefg");
printf("p: %sn", p);
printf("p: %dn", p);
if (p != NULL)
{
free(p);
}
if (p != NULL)
{
free(p);
}
}对于这样一个程序：
p通过malloc在堆区开辟了一段100字节的内存空间，然后指针p指向这段内存空间的首地址，通过strcpy修改了所指向的内存空间的值，然后通过free(p)释放了指针p所指向的堆区内存空间，但这时候栈上为指针开辟的4字节中仍然保存着堆区的首地址，再次判断p是否为空，不为空，再次释放已经被释放的堆上的那段空间，就会报错，如下图：
正是因为指针变量与指针所指向的内存空间变量是两个完全不同的概念，释放了指针所指向的内存空间，但指针变量并没有改变，这就造成了野指针的问题，指针p指向了一段已经被释放的垃圾内存首地址。
避免野指针的方法：指针初始化时为NULL，释放所指向的内存空间后再把指针变量的值设置为NULL。
5>向NULL地址拷贝数据
1
2
3
4
5
void func2() {
char* p = NULL;
strcpy(p, "abcdefg");
printf("p: %s", p);
}指针p此时的值为NULL，并没有指向任何内存空间，却通过strcpy向p指向的内存空间中拷贝数据，显然是不允许的，会报错：
4、指针也是一种数据类型
1> 指针做函数参数，形参有多级指针的时候，站在编译器的角度，只需要分配4字节的内存（32位平台下），当我们使用内存的时候，才关心指针所指向的内存是一维的，还是二维的；
2> 指针也是一种数据类型，是指它指向的内存空间的数据类型，指针的数据类型决定了指针的步长
1
int a[10];这就是为什么a + 1与a之间进了4，&a + 1与&a之间进了40的缘故。
二、总结
1、指针指向谁就把谁的首地址赋给指针；
2、指针变量与指针所指向的内存空间变量是两个不同的概念
3、指针也是一种数据类型；
4、理解指针的关键在于内存，没有内存哪来的内存首地址，没有内存首地址哪来的指针。
铁律2：间接复制是指针的最大意义
一、从0级指针到1级指针
1
2
3
4
5
6
7
8
9
10
11
12
13
int main(){
int a = 10;
int *p = NULL;
//直接修改值
a = 20;
printf("a: %dn", a);
//间接修改值
p = &a;
*p = 30;
printf("a: %dn", a);
system("pause");
return 0;
}输出结果：
可以看到a的值不管是直接修改还是通过1级指针都被修改了，如果把间接修改改成函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include"stdio.h"
#include"stdlib.h"
#include"string.h"
void getval(int *p) {
*p = 40;
}
void getval2(int b) {
b = 50;
}
int main(){
int a = 10;
int *p = NULL;
//直接修改值
a = 20;
printf("a: %dn", a);
//间接修改值
p = &a;
*p = 30;
printf("a: %dn", a);
getval(&a);
printf("a: %dn", a);
getval2(a);
printf("a: %dn", a);
system("pause");
return 0;
}输出结果：
1
2
3
void getval2(int b) {
b = 50;
}这里怎么修改b的值都跟main函数的a的值没有关系，这就是之前说到的形参放到函数上和放到函数上没有什么不同，这里放在函数上只不过把b的初始值是main函数中a的值而已。
二、从1级指针到2级指针
1
2
3
4
5
6
7
8
9
10
11
12
13
int main(){
int *p1 = NULL;
int **p2 = NULL;
//直接修改
p1 = (int*)0x11;
printf("p1: %dn", p1);
//间接赋值
p2 = &p1;
*p2 = (int*)100;
printf("p1: %dn", p1);
system("pause");
return 0;
}输出结果：
1级指针p1的值不管是直接修改还是通过2级指针间接修改，都改变了p1变量的值，也就是p1指向的内存首地址，如果改成函数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include"stdio.h"
#include"stdlib.h"
#include"string.h"
void getmem(int **p2) {
*p2 = (int*)200;
}
void getmem2(int *p1) {
p1 = (int*)300;
}
int main(){
int *p1 = NULL;
int **p2 = NULL;
//直接修改
p1 = (int*)0x11;
printf("p1: %dn", p1);
//间接赋值
p2 = &p1;
*p2 = (int*)100;
printf("p1: %dn", p1);
getmem(&p1);
printf("p1: %dn", p1);
getmem(&p1);
printf("p1: %dn", p1);
system("pause");
return 0;
}输出结果：
getmem2函数跟上面的getval2函数是一个道理，getmem2里的p1跟main函数中的p1指针完全没有关系， getmem2里的p1只是改变了自己的内存首地址的指向而已。
三、总结
指针的间接赋值，即函数调用时，行参传给实参，用实参取地址传给形参，在被调用函数里面用指针来改变实参，把运算结果传出来，需要具备三个条件（这里拿一级指针间接赋值0级指针为例）：
1、两个变量
1
2
int a = 10;
int *p;2、建立关联(把实参取地址传给形参)
1
p = &a;3、通过指针修改变量的值（在被调用函数里面，通过形参去间接修改实参的值）
1
*p = 20;根据三个条件的不同位置可以分为三个应用场景：
1、条件1,2,3在同一个函数内
2、条件1,2 在同一个函数内，条件3在另外一个函数内（函数调用）
3、条件1在一个函数内，条件2,3在另外一个函数内，这在C++中用到。
铁律3：强化
指针做参数可以做输入可以做输出
先举个二级指针做输出的例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include"stdio.h"
#include"stdlib.h"
#include"string.h"
void getmem(char** p1/*out*/, int num) {
char* temp1 = (char*)malloc(num);
strcpy(temp1, "123456");
*p1 = temp1;
}
int main(){
char *p = NULL;
getmem(&p, 100);
printf("p : %sn", p);
printf("p : %dn", p);
system("pause");
return 0;
}输出结果：
可以看到main函数中的p通过函数调用的二级指针p1获取了内存首地址。
getmem函数中二级指针p1指向main一级指针p的首地址，利用getmen函数temp1开辟一段堆区空间，通过*p1 = temp1间接修改了p的值，这时就让p也指向了堆区由temp1开辟的那段空间。此时二级指针p1扮演的是输出操作，由被调用函数内空间返回给调用函数。
最后
以上就是粗暴西装最近收集整理的关于指针的全部内容，更多相关指针内容请搜索靠谱客的其他文章。
发表评论 取消回复