c语言中char是表示什么意思(char在c语言中的用法)-众学网

指针对于C来说太重要。然而，想要全面理解指针，除了要对C语言有熟练的掌握外，还要有计算机硬件以及操作系统等方方面面的基本知识。所以本文尽可能的通过一篇文章完全讲解指针。

为什么需要指针？

指针解决了一些编程中基本的问题。

第一，指针的使用使得不同区域的代码可以轻易的共享内存数据。当然小伙伴们也可以通过数据的复制达到相同的效果，但是这样往往效率不太好。因为诸如结构体等大型数据，占用的字节数多，复制很消耗性能。但使用指针就可以很好的避免这个问题，因为任何类型的指针占用的字节数都是一样的（根据平台不同，有4字节或者8字节或者其他可能）。

第二，指针使得一些复杂的链接性的数据结构的构建成为可能，比如链表，链式二叉树等等。

第三，有些操作必须使用指针。如操作申请的堆内存。还有：C语言中的一切函数调用中，值传递都是“按值传递”的。如果我们要在函数中修改被传递过来的对象，就必须通过这个对象的指针来完成。

指针是什么？

我们知道：C语言中的数组是指一类类型，数组具体区分为 int 类型数组，double类型数组，char数组等等。同样指针这个概念也泛指一类数据类型，int指针类型，double指针类型，char指针类型等等。

通常，我们用int类型保存一些整型的数据，如 int num = 97 ，我们也会用char来存储字符：char ch = ‘a’。

弄清这个问题我们需要从操作系统的角度去认知内存。

电脑维修师傅眼中的内存是这样的：内存在物理上是由一组DRAM芯片组成的。

在程序员眼中的内存应该是下面这样的。

下面用代码说明

我们可以大致画出变量ch和num在内存模型中的存储。（假设 char占1个字节，int占4字节）

变量和内存

为了简单起见，这里就用上面例子中的 int num = 97 这个局部变量来分析变量在内存中的存储模型。

1、内存的数据

2、内存数据的类型

内存的数据类型决定了这个数据占用的字节数，以及计算机将如何解释这些字节。num的类型是int，因此将被解释为一个整数。

3、内存数据的名称

5、内存数据的生命周期

num是main函数中的局部变量，因此当main函数被启动时，它被分配于栈内存上，当main执行结束时，消亡。

如果一个数据一直占用着他的内存，那么我们就说他是“活着的”，如果他占用的内存被回收了，则这个数据就“消亡了”。C语言中的程序数据会按照他们定义的位置，数据的种类，修饰的关键字等因素，决定他们的生命周期特性。实质上我们程序使用的内存会被逻辑上划分为：栈区，堆区，静态数据区，方法区。不同的区域的数据有不同的生命周期。

无论以后计算机硬件如何发展，内存容量都是有限的，因此清楚理解程序中每一个程序数据的生命周期是非常重要的。

指针变量和指向关系

定义指针变量

C语言中，定义变量时，在变量名前写一个 * 星号，这个变量就变成了对应变量类型的指针变量。必要时要加 ( ) 来避免优先级的问题。

引申：C语言中，定义变量时，在定义的最前面写上 typedef ，那么这个变量名就成了一种类型，即这个类型的同义词。

int a ; //int类型变量 aint *a ; //int* 变量aint 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 = &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 main(void){ int age = 19; int*p_age = &age; *p_age = 20; //通过指针修改指向的内存数据 printf(“age = %d”,*p_age); //通过指针读取指向的内存数据 printf(“age = %d”,age); return 0;}

指针之间的赋值

int*p1=&num;int*p3=p1;//通过指针 p1 、 p3 都可以对内存数据 num 进行读写，如果2个函数分别使用了p1 和p3，那么这2个函数就共享了数据num。

空指针

指向空，或者说不指向任何东西。在C语言中，我们让指针变量赋值为NULL表示一个空指针，而C语言中，NULL实质是 ((void*)0) ，在C 中，NULL实质是0。

下面代码摘自 stdlib.h

#ifdef __cplusplus #define NULL 0#else #define NULL ((void *)0)#endif

坏指针

下面的代码就是错误的示例。

指针的2个重要属性

指针也是一种数据，指针变量也是一种变量，因此指针这种数据也符合前面变量和内存主题中的特性。这里要强调2个属性：指针的类型，指针的值。

int main(void){ int num = 97; int *p1 = &num;char*p2=(char*)(&num);printf(“%d”,*p1); //输出97putchar(*p2);//输出a return 0;}

指针的类型：指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。一般指针变量的类型要和它指向的数据的类型匹配。

void*类型指针

结构体和指针

结构体指针有特殊的语法：-> 符号

如果p是一个结构体指针，则可以使用 p ->【成员】的方法访问结构体的成员

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”,ps->name,ps->age); return 0;}

数组和指针

int main(void){ int arr[3] = {1,2,3}; int *p_first = arr;printf(“%d”,*p_first);//1 return 0;}

2、指向数组元素的指针支持递增递减运算。（实质上所有指针都支持递增递减运算，但只有在数组中使用才是有意义的）

int main(void){ int arr[3] = {1,2,3}; int *p = arr; for(;p!=arr 3;p ){printf(“%d”,*p); } return 0;}

3、p= p 1 意思是，让p指向原来指向的内存块的下一个相邻的相同类型的内存块。

同一个数组中，元素的指针之间可以做减法运算，此时，指针之差等于下标之差。

4、p[n] == *(p n)

p[n][m] == *( *(p n) m )

5、当对数组名使用sizeof时，返回的是整个数组占用的内存字节数。当把数组名赋值给一个指针后，再对指针使用sizeof运算符，返回的是指针的大小。

这就是为什么将一个数组传递给一个函数时，需要另外用一个参数传递数组元素个数的原因了。

int main(void){ int arr[3] = {1,2,3}; int *p = arr;printf(“sizeof(arr)=%d”,sizeof(arr));//sizeof(arr)=12printf(“sizeof(p)=%d”,sizeof(p));//sizeof(p)=4 return 0;}

函数和指针

函数的参数和指针

C语言中，实参传递给形参，是按值传递的，也就是说，函数中的形参是实参的拷贝份，形参和实参只是在值上面一样，而不是同一个内存数据对象。这就意味着：这种数据传递是单向的，即从调用者传递给被调函数，而被调函数无法修改传递的参数达到回传的效果。

void change(int a){ a ; //在函数中改变的只是这个函数的局部变量a，而随着函数执行结束，a被销毁。age还是原来的age，纹丝不动。}int main(void){ int age = 19; change(age);printf(“age=%d”,age);//age=19 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;}

有的时候，我们通过指针传递数据给函数不是为了在函数中改变他指向的对象。相反，我们防止这个目标数据被改变。传递指针只是为了避免拷贝大型数据。

考虑一个结构体类型Student。我们通过show函数输出Student变量的数据。

typedef struct{ char name[31]; int age; float score;}Student;//打印Student变量信息void show(const Student * ps){printf(“name:%s,age:%d,score:%.2f”,ps->name,ps->age,ps->score);}

我们只是在show函数中取读Student变量的信息，而不会去修改它，为了防止意外修改，我们使用了常量指针去约束。另外我们为什么要使用指针而不是直接传递Student变量呢？

从定义的结构看出，Student变量的大小至少是39个字节，那么通过函数直接传递变量，实参赋值数据给形参需要拷贝至少39个字节的数据，极不高效。而传递变量的指针却快很多，因为在同一个平台下，无论什么类型的指针大小都是固定的：X86指针4字节，X64指针8字节，远远比一个Student结构体变量小。

函数的指针

每一个函数本身也是一种程序数据，一个函数包含了多条执行语句，它被编译后，实质上是多条机器指令的合集。在程序载入到内存后，函数的机器指令存放在一个特定的逻辑区域：代码区。既然是存放在内存中，那么函数也是有自己的指针的。

C语言中，函数名作为右值时，就是这个函数的指针。

void echo(const char *msg){ printf(“%s”,msg);}int main(void){ void(*p)(const char*) = echo; //函数指针变量指向echo这个函数 p(“Hello “); //通过函数的指针p调用函数，等价于echo(“Hello “)echo(“World”); return 0;}

const和指针

const到底修饰谁？谁才是不变的？

如果const 后面是一个类型，则跳过最近的原子类型，修饰后面的数据。（原子类型是不可再分割的类型，如int, short , char，以及typedef包装后的类型）

如果const后面就是一个数据，则直接修饰这个数据。

int main(){ int a = 1; int const *p1 = &a; //const后面是*p1，实质是数据a，则修饰*p1，通过p1不能修改a的值 const int *p2 = &a; //const后面是int类型，则跳过int ，修饰*p2，效果同上int*constp3=NULL;//const后面是数据p3。也就是指针p3本身是const.constint *constp4=&a;//通过p4不能改变a的值，同时p4本身也是constintconst *constp5=&a;//效果同上 return 0;} typedefint*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，同上return0;}

深拷贝和浅拷贝

如果2个程序单元（例如2个函数）是通过拷贝他们所共享的数据的指针来工作的，这就是浅拷贝，因为真正要访问的数据并没有被拷贝。如果被访问的数据被拷贝了，在每个单元中都有自己的一份，对目标数据的操作相互不受影响，则叫做深拷贝。