原地址:https://www.cnblogs.com/lulipro/p/7460206.html
前言
这不是我第一次写关于C指针的文章了,只是因为指针对于C来说太重要,而且随着自己编程经历越多,对指针的理解越多,因此有了本文。然而,想要全面理解指针,除了要对C语言有熟练的掌握外,还要有计算机硬件以及操作系统等方方面面的基本知识。所以我想通过一篇文章来尽可能的讲解指针,以对得起这个文章的标题吧。
为什么需要指针?
指针解决了一些编程中基本的问题。
指针是什么?
为什么程序中的数据会有自己的地址?
![](https://i-blog.csdnimg.cn/blog_migrate/1619048ea6a846184578acc9ad806dee.png)
而作为一个程序员,我们不需要了解内存的物理结构,操作系统将RAM等硬件和软件结合起来,给程序员提供的一种对内存使用的抽象。,这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作和使用真实存在的物理存储器。所有的虚拟地址形成的集合就是虚拟地址空间。
在程序员眼中的内存应该是下面这样的。
也就是说,内存是一个很大的,线性的字节数组(平坦寻址)。每一个字节都是固定的大小,由8个二进制位组成。最关键的是,每一个字节都有一个唯一的编号,编号从0开始,一直到最后一个字节。如上图中,这是一个256M的内存,他一共有256x1024x1024 = 268435456个字节,那么它的地址范围就是 0 ~268435455 。
由于内存中的每一个字节都有一个唯一的编号,因此,在程序中使用的变量,常量,甚至数函数等数据,当他们被载入到内存中后,都有自己唯一的一个编号,这个编号就是这个数据的地址。指针就是这样形成的。
下面用代码说明
#include <stdio.h> int main(void) { char ch = 'a'; int num = 97; printf("ch 的地址:%p\n",&ch); //ch 的地址:0028FF47 printf("num的地址:%p\n",&num); //num的地址:0028FF40 return 0; }
![](https://i-blog.csdnimg.cn/blog_migrate/412ec0fc001a251f770e5a47b2ccea3e.png)
变量和内存
为了简单起见,这里就用上面例子中的 int num = 97 这个局部变量来分析变量在内存中的存储模型。
![](https://i-blog.csdnimg.cn/blog_migrate/7f19d43a875c7547ab054331c1c762af.png)
指针变量 和 指向关系
用来保存 指针 的变量,就是指针变量。如果指针变量p1保存了变量 num的地址,则就说:p1指向了变量num,也可以说p1指向了num所在的内存块 ,这种指向关系,在图中一般用 箭头表示。
上图中,指针变量p1指向了num所在的内存块 ,即从地址0028FF40开始的4个byte 的内存块。
int a ; //int类型变量 a int *a ; //int* 变量a int arr[3]; //arr是包含3个int元素的数组 int (* arr )[3]; //arr是一个指向包含3个int元素的数组的指针变量 //-----------------各种类型的指针------------------------------ int* p_int; //指向int类型变量的指针 double* p_double; //指向idouble类型变量的指针 struct Student *p_struct; //结构体类型的指针 int(*p_func)(int,int); //指向返回类型为int,有2个int形参的函数的指针 int(*p_arr)[3]; //指向含有3个int元素的数组的指针 int** p_pointer; //指向 一个整形变量指针的指针
int add(int a , int b) { return a + b; } int main(void) { int num = 97; float score = 10.00F; int arr[3] = {1,2,3}; //----------------------- int* p_num = # float* p_score = &score; int (*p_arr)[3] = &arr; int (*fp_add)(int ,int ) = add; //p_add是指向函数add的函数指针 return 0; }
- 数组名的值就是这个数组的第一个元素的地址。
- 函数名的值就是这个函数的地址。
- 字符串字面值常量作为右值时,就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。
int add(int a , int b){ return a + b; } int main(void) { int arr[3] = {1,2,3}; //----------------------- int* p_first = arr; int (*fp_add)(int ,int ) = add; const char* msg = "Hello world"; return 0; }
int* p1 = & num; int* p3 = p1; //通过指针 p1 、 p3 都可以对内存数据 num 进行读写,如果2个函数分别使用了p1 和p3,那么这2个函数就共享了数据num。
#ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif
void opp() { int*p = NULL; *p = 10; //Oops! 不能对NULL解地址 } void foo() { int*p; *p = 10; //Oops! 不能对一个未知的地址解地址 } void bar() { int*p = (int*)1000; *p =10; //Oops! 不能对一个可能不属于本程序的内存的地址的指针解地址 }
指针的2个重要属性
指针也是一种数据,指针变量也是一种变量,因此指针 这种数据也符合前面 变量和内存 主题中的特性。 这里我只想强调2个属性: 指针的类型,指针的值。
int main(void) { int num = 97; int *p1 = # char* p2 = (char*)(&num); printf("%d\n",*p1); //输出 97 putchar(*p2); //输出 a return 0; }
结构体和指针
typedef struct { char name[31]; int age; float score; }Student; int main(void) { Student stu = {"Bob" , 19, 98.0}; Student*ps = &stu; ps->age = 20; ps->score = 99.0; printf("name:%s age:%d\n",ps->name,ps->age); return 0; }
数组和指针
int main(void) { int arr[3] = {1,2,3}; int*p_first = arr; printf("%d\n",*p_first); //1 return 0; }
int main(void) { int arr[3] = {1,2,3}; int*p = arr; for(;p!=arr+3;p++){ printf("%d\n",*p); } return 0; }
int main(void) { int arr[3] = {1,2,3}; int*p = arr; printf("sizeof(arr)=%d\n",sizeof(arr)); //sizeof(arr)=12 printf("sizeof(p)=%d\n",sizeof(p)); //sizeof(p)=4 return 0; }
函数和指针
void change(int a) { a++; //在函数中改变的只是这个函数的局部变量a,而随着函数执行结束,a被销毁。age还是原来的age,纹丝不动。 } int main(void) { int age = 19; change(age); printf("age = %d\n",age); // age = 19 return 0; }
void change(int* pa) { (*pa)++; //因为传递的是age的地址,因此pa指向内存数据age。当在函数中对指针pa解地址时, //会直接去内存中找到age这个数据,然后把它增1。 } int main(void) { int age = 19; change(&age); printf("age = %d\n",age); // age = 20 return 0; }
再来一个老生常谈的,用函数交换2个变量的值的例子:
#include<stdio.h> void swap_bad(int a,int b); void swap_ok(int*pa,int*pb); int main() { int a = 5; int b = 3; swap_bad(a,b); //Can`t swap; swap_ok(&a,&b); //OK return 0; } //错误的写法 void swap_bad(int a,int b) { int t; t=a; a=b; b=t; } //正确的写法:通过指针 void swap_ok(int*pa,int*pb) { int t; t=*pa; *pa=*pb; *pb=t; }
typedef struct { char name[31]; int age; float score; }Student; //打印Student变量信息 void show(const Student * ps) { printf("name:%s , age:%d , score:%.2f\n",ps->name,ps->age,ps->score); }
void echo(const char *msg) { printf("%s",msg); } int main(void) { void(*p)(const char*) = echo; //函数指针变量指向echo这个函数 p("Hello "); //通过函数的指针p调用函数,等价于echo("Hello ") echo("World\n"); return 0; }
const 和 指针
如果const 后面是一个类型,则跳过最近的原子类型,修饰后面的数据。(原子类型是不可再分割的类型,如int, short , char,以及typedef包装后的类型)
int main() { int a = 1; int const *p1 = &a; //const后面是*p1,实质是数据a,则修饰*p1,通过p1不能修改a的值 const int*p2 = &a; //const后面是int类型,则跳过int ,修饰*p2, 效果同上 int* const p3 = NULL; //const后面是数据p3。也就是指针p3本身是const . const int* const p4 = &a; // 通过p4不能改变a 的值,同时p4本身也是 const int const* const p5 = &a; //效果同上 return 0; }
typedef int* pint_t; //将 int* 类型 包装为 pint_t,则pint_t 现在是一个完整的原子类型 int main() { int a = 1; const pint_t p1 = &a; //同样,const跳过类型pint_t,修饰p1,指针p1本身是const pint_t const p2 = &a; //const 直接修饰p,同上 return 0; }
深拷贝和浅拷贝
如果2个程序单元(例如2个函数)是通过拷贝 他们所共享的数据的 指针来工作的,这就是浅拷贝,因为真正要访问的数据并没有被拷贝。如果被访问的数据被拷贝了,在每个单元中都有自己的一份,对目标数据的操作相互 不受影响,则叫做深拷贝。
附加知识
指针和引用这个2个名词的区别。他们本质上来说是同样的东西。指针常用在C语言中,而引用,则用于诸如Java,C#等 在语言层面封装了对指针的直接操作的编程语言中。
![](https://i-blog.csdnimg.cn/blog_migrate/633af8695c98b82496165fafba37ddd5.png)
//测试机器使用的是否为小端模式。是,则返回true,否则返回false
//这个方法判别的依据就是:C语言中一个对象的地址就是这个对象占用的字节中,地址值最小的那个字节的地址。
bool isSmallIndain() { unsigned int val = 'A'; unsigned char* p = (unsigned char*)&val; //C/C++:对于多字节数据,取地址是取的数据对象的第一个字节的地址,也就是数据的低地址 return *p == 'A'; }