【嵌入式C语言】还没搞懂C语言指针？一文详解C指针

hello 你好呀!,我是aoz,今天我们来一起研究c指针这个东西

我相信这个概念你一定不陌生,但是实际要使用的时候总是一脸懵逼,我是谁,我在哪

今天我们用一篇文章来讲清楚,指针都涉及那些东西,我们应该学会那些东西,帮助你真正的了解C语言中的指针这个重要概念.

进入正题之前,我需要你记住一个概念"一切皆内存",虽然现在可能还不是太懂这句玄乎的话,不过后面我们将一点点解开谜团

废话不多说,我们进入正题 有需要的同学可以自行跳转哟~

1. 为什么需要指针？

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

第一，指针的使用使得不同区域的代码可以轻易的共享内存数据。

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

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

第三， 有些操作必须使用指针。如操作申请的堆内存。

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

👆👆👆 这三点就是指针存在的意义,最后一条则是实际使用的一点心得(仅对新手有用)

2. 指针的样子

我相信在你之前看到的很多书里面都会对指针进行这样的分类

其中整型指针指向一个整型,float指针指向一个float型,我相信大部分的老师就是这么教的(我老师就是这么讲的)

这种说法是完全正确的,但是是不好理解的,如果这么理解指针,你只会越理解越蒙,因为后面任何一个关于指针的操作你都需要重新从指针的层面来理解,倒不妨我们从内存的角度来看指针这个东西.毕竟一切皆内存嘛

内存是啥?

操作系统将RAM等硬件和软件结合起来，给程序员提供的一种对内存使用的抽象。
这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作和使用真实存在的物理存储器。
所有的虚拟地址形成的集合就是虚拟地址空间。

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

也就是说，内存是一个很大的，线性的字节数组（平坦寻址）。每一个字节都是固定的大小，由8个二进制位组成。

最关键的是，每一个字节都有一个唯一的编号,编号从0开始，一直到最后一个字节。

👆👆👆上面一堆废话就是告诉你内存是啥

换言之,就是告诉你,内存就是一个个的小盒子,每个小盒子能装0和1

如果你能理解到这里,那么你离胜利就不远了,下面这就话也很重要,

内存中的数据是没有意义的,取决于它的解读方式
我带大家来试试,如果你是个初学者,这将颠覆之前的理解,如果你是老手,那么当我没说😂😂😂

这些数据在内存中没有意义,实际的意义看我们的解析方式,比如
我们的地址是

	unsigned char * a = 0x00; //定义了一个指向0x00的指针

此时对 a 进行解引用,得到的数值是多少? 应该是0x01;

	unsigned int * a = 0x00; //定义了一个指向0x00的指针

此时对 a 进行解引用,得到的数值是多少? 应该是0x01040911;

指针后面的值用来确定这个指针指向了哪个位置,指针前面的类型并不是指针本身的类型,而是标识了当你拿到这个指针应该怎么处理后面的数据,也就是计算机将如何解释这些内存

如果你没有理解上面这段话可以参考电脑中的文件,

你新建了一个记事本 123.txt ,此时如果我们修改文件名,取消.txt ,修改文件为 123 ,此时 123就是指针,文件内容就是内存,当失去了.txt这个指针类型.

当没有.txt这个后缀时,计算机就不知道用什么软件来打开它了,这个打开方式和指针的类型很相似

恭喜你,如果你理解了上面的内容,C指针你已经明白了90%.后面的内容就是介绍指针使用的方法和技巧了,不存在理解的内容了.

==========================================================================================================================

3. 内存与变量

下面我们来详细聊聊内存与变量的关系,回顾一下上面讲到的知识.

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

已知：num的类型是int，占用了4个字节的内存空间，其值是97，地址是0028FF40。我们从以下几个方面去分析。

1、内存的数据

内存的数据就是变量的值对应的二进制，一切都是二进制。

97的二进制是 : 00000000 00000000 00000000 0110000 , 但使用的小端模式存储时，低位数据存放在低地址，所以图中画的时候是倒过来的。

2、内存数据的类型

内存的数据类型决定了这个数据占用的字节数，以及计算机将如何解释这些字节。

num的类型是int，因此将被解释为 一个整数。

3、内存数据的名称

内存的名称就是变量名。实质上，内存数据都是以地址来标识的，根本没有内存的名称这个说法，这只是高级语言提供的抽象机制 ，方便我们操作内存数据。

而且在C语言中，并不是所有的内存数据都有名称，例如使用malloc申请的堆内存就没有。

4、内存数据的地址

如果一个类型占用的字节数大于1，则其变量的地址就是地址值最小的那个字节的地址。

因此num的地址是 0028FF40。内存的地址用于标识这个内存块。

5、内存数据的生命周期

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

如果一个数据一直占用着他的内存，那么我们就说他是“活着的”，如果他占用的内存被回收了，则这个数据就“消亡了”。

C语言中的程序数据会按照他们定义的位置，数据的种类，修饰的关键字等因素，决定他们的生命周期特性。

实质上我们程序使用的内存会被逻辑上划分为：栈区，堆区，静态数据区，方法区。

不同的区域的数据有不同的生命周期。

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

4. 指针变量和指向关系

用来保存指针的变量，就是指针变量。

如果指针变量p1保存了变量 num的地址，则就说：p1指向了变量num，也可以说p1指向了num所在的内存块 ，这种指向关系，在图中一般用 箭头表示。

上图中，指针变量p1指向了num所在的内存块 ，即从地址0028FF40开始的4个byte 的内存块。

5. 定义指针变量

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

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

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; //指向 一个整形变量指针的指针

6. 指针的2个重要属性

指针也是一种数据，指针变量也是一种变量，因此指针 这种数据也符合前面变量和内存主题中的特性。

这里要强调2个属性：指针的类型，指针的值。

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

指针的值：很好理解，如上面的num 变量 ，其地址的值就是0028FF40 ，因此 p1的值就是0028FF40。

数据的地址用于在内存中定位和标识这个数据，因为任何2个内存不重叠的不同数据的地址都是不同的。

指针的类型：指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。

一般指针变量的类型要和它指向的数据的类型匹配。

由于num的地址是0028FF40，因此 p1 和 p2 的值都是0028FF40

*p1 : 将从地址0028FF40 开始解析，因为p1是int类型指针，int占4字节，因此向后连续取4个字节，并将这4个字节的二进制数据解析为一个整数 97。

*p2 : 将从地址0028FF40 开始解析，因为p2是char类型指针，char占1字节，因此向后连续取1个字节，并将这1个字节的二进制数据解析为一个字符，即’a’。

同样的地址，因为指针的类型不同，对它指向的内存的解释就不同，得到的就是不同的数据。

7. 取地址

既然有了指针变量，那就得让他保存其它变量的地址，使用& 运算符取得一个变量的地址。

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

8. 解引用

我们需要一个数据的指针变量干什么？

当然使用通过它来操作（读/写）它指向的数据啦。

对一个指针解地址，就可以取到这个内存数据，解地址的写法，就是在指针的前面加一个*号。

解指针的实质是：从指针指向的内存块中取出这个内存数据。

int main(void)
{    
    int age = 19;    
    int*p_age = &age;    
    *p_age  = 20;  //通过指针修改指向的内存数据
    printf("age = %d",*p_age);   //通过指针读取指向的内存数据    
    printf("age = %d",age);
    return 0;
}

9. 指针之间的赋值

指针赋值和int变量赋值一样，就是将地址的值拷贝给另外一个。

指针之间的赋值是一种浅拷贝，是在多个编程单元之间共享内存数据的高效的方法。

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

10. 空指针（NULL指针）

NULL是C语言标准定义的一个值，这个值其实就是0，只不过为了使得看起来更加具有意义，才定义了这样的一个宏，中文的意思是空，表明不指向任何东西。你懂得。不过在此不讨论空和零的区别。

在C语言中，我们让指针变量赋值为NULL表示一个空指针，而C语言中，NULL实质是((void*)0)，就像前面说的指针可以理解成特殊的int，它总是有值的，p=NULL，其实就是p的值等于0。对于不多数机器而言，0地址是不能直接访问的，设置为0，就表示该指针哪里都没指向。而在C++中，NULL实质是0。

换种说法：任何程序数据都不会存储在地址为0的内存块中，它是被操作系统预留的内存块。

下面代码摘自 stdlib.h

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

当然，就机器内部而言，NULL指针的实际值可能与此不同，这种情况下，编译器将负责零值和内部值之间的翻译转换。

NULL指针的概念非常有用，它给了你一种方法，表示某个特定的指针目前并未指向任何东西。例如，一个用于在某个数组中查找某个特定值的函数可能返回一个指向查找到的数组元素的指针。如果没找到，则返回一个NULL指针。

在内存的动态分配上，NULL的意义非同凡响，我们使用它来避免内存被多次释放，造成经常性的段错误（segmentation fault）。一般，**在free或者delete掉动态分配的内存后，都应该立即把指针置空，避免出现所以的悬挂指针，致使出现各种内存错误！**例如：

free函数是不会也不可能把p置空的。像下面这样的代码就会出现内存段错误：

因为，第一次free操作之后，p指向的内存已经释放了，但是p的值还没有变化，free函数改不了这个值，再free一次的时候，p指向的内存区域已经被释放了，这个地址已经变成了非法地址，这个操作将导致段错误的发生（此时，p指向的区域刚好又被分配出去了，但是这种概率非常低，而且对这样一块内存区域进行操作是非常危险的！）

但是下面这段代码就不会出现这样的问题：

因为p的值编程了NULL，free函数检测到p为NULL，会直接返回，而不会发生错误。

**这里顺便告诉大家一个内存释放的小窍门，可以有效的避免因为忘记对指针进行置空而出现各种内存问题。****这个方法就是自定义一个内存释放函数，但是传入的参数不知指针，而是指针的地址，在这个函数里面置空，如下：

结果：

​

my_free调用了之后，p的值就变成了0（NULL），调用多少次free都不会报错了！

**另外一个方式也非常有效，那就是定义FREE宏，在宏里面对他进行置空。**例如

执行结果同上面一样，不会报段错误：

​

（关于内存的动态分配，这是个比较复杂的话题，有机会再专门开辟一章给各位讲述一下吧，写个帖子还是很花费时间和精力的，呵呵，写过的童鞋应该都很清楚，所以顺便插一句，转帖可以，请注明出处，毕竟，大家都是本着共享的精神来讨论问题的，写的好坏都没有向你所要什么，请尊重每个人的劳动成果。）

指向空，或者说不指向任何东西。

11. 坏指针

指针变量的值是NULL，或者未知的地址值，或者是当前应用程序不可访问的地址值，这样的指针就是坏指针。

不能对他们做解指针操作，否则程序会出现运行时错误，导致程序意外终止。

任何一个指针变量在做解地址操作前，都必须保证它指向的是有效的，可用的内存块，否则就会出错。

坏指针是造成C语言Bug的最频繁的原因之一。

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

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!   不能对一个可能不属于本程序的内存的地址的指针解地址
}

12. void*类型指针

由于void是空类型，因此void*类型的指针只保存了指针的值，而丢失了类型信息，我们不知道他指向的数据是什么类型的，只指定这个数据在内存中的起始地址。

如果想要完整的提取指向的数据，程序员就必须对这个指针做出正确的类型转换，然后再解指针。因为，编译器不允许直接对void*类型的指针做解指针操作。

虽然从字面上看，void的意思是空，但是void指针的意思，可不是空指针的意思，空指针指的是上面所说的NULL指针。

void指针实际上的意思是指向任意类型的指针。任意类型的指针都可以直接赋给void指针，而不需要进行强制转换。

例如：

Type a, *p=&a;（Type等于char, int, struct, int *…）void *pv;
pv=p;

就像前面说的，void指针的好处，就在于，任意的指针都可以直接赋值给它，这在某些场合非常有用，因此有些操作对于任意指针都是相同的。void指针最常用于内存管理。最典型的，也是大家最熟知的，就是标准库的free函数。它的原型如下：

​

void free(void*ptr);

​

free函数的参数可以是任意指针，没有谁见过free参数里面的指针需要强壮为void*的吧？

malloc, calloc,realloc这些函数的返回值也是void指针，因为内存分配，实际上只需要知道分配的大小，然后返回新分配内存的地址就可以了，指针的值就是地址，返回的不管是何种指针，其实结果都是一样的，因为所有的指针长度其实都是32位的（32位机器），它的值就是内存的地址，指针类型只是给编译器看的，目的是让编译器在编译的时候能够正确的设置指针的值（参见指针运算章节）。如果malloc函数设置成下面这样的原型，完全没有问题。

char*malloc(size_t sz);

实际上设置成

Type* malloc(size_t sz);

也是完全正确的，使用void指针的原因，实际上就像前面说的，void指针意思是任意指针，这样设计更加严谨一些，也更符合我们的直观理解。如果对前面我说的指针概念理解的童鞋，肯定明白这一点。

13. 结构体和指针

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

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

14. 数组和指针

1、数组名作为右值的时候，就是第一个元素的地址。

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)=12    
    printf("sizeof(p)=%d",sizeof(p));   //sizeof(p)=4
    return 0;
}

15. 函数和指针

函数的参数和指针

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

有时候我们可以使用函数的返回值来回传数据，在简单的情况下是可以的。

但是如果返回值有其它用途（例如返回函数的执行状态量），或者要回传的数据不止一个，返回值就解决不了了。

传递变量的指针可以轻松解决上述问题。

void change(int* pa)
{    
    (*pa)++;   //因为传递的是age的地址，因此pa指向内存数据age。当在函数中对指针pa解地址时，               
               //会直接去内存中找到age这个数据，然后把它增1。
}
                     
int main(void)
{    
    int age = 19;    
    change(&age);    
    printf("age = %d",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;
}

有的时候，我们通过指针传递数据给函数不是为了在函数中改变他指向的对象。

相反，我们防止这个目标数据被改变。

传递指针只是为了避免拷贝大型数据。

考虑一个结构体类型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结构体变量小。

函数的指针

跟普通的变量一样，每一个函数都是有其地址的，我们通过跳转到这个地址执行代码来进行函数调用，只是，跟取普通数据不同的在于，函数有参数和返回值，在进行函数调用的时候，首先需要将参数压入栈中，调用完成后又需要将参数压入栈中。既然函数也是通过地址来进行访问的，那它也可以使用指针来指向，事实上，每一个函数名都是一个指针，不过它是指针常量和指针常量，它的值是不能改的，指向的值也不能改。

（关于常量指针和指针常量什么的，有时间在专门开辟一章来说明const这个东东吧，也是很有讲头的一个东东。。。）

函数指针一般用来干什么呢？**函数指针最常用的场合就是回调函数。**回调函数，顾名思义，就是某个函数会在适当的时候被别人调用。当期望你调用的函数能够使用你的某些方式去操作的时候，回调函数就很有用，比如，你期望某个排序函数在比较的时候，能够使用你定义的比较方法去比较。

有过较深入的C编程经验的人应该都接触过。C的标准库中就有使用，例如在strlib.h头文件的qsort函数，它的原型为：

void qsort(void*__base, size_t __nmemb, size_t __size, int(*_compar)(const void *, const void*));

其中int(*_compar)(const void *, const void *)就是回调函数，这个函数用于qsort函数用于数据的比较。下面，我会举一个例子，来描述qsort函数的工作原理。

一般，我们使用下面这样的方式来定义函数指针：

typedef int(*compare)(const void *x, const void *y);

这个时候，compare就是参数为const void *, const void *类型，返回值是int类型的函数。例如：

用typedef来定义的好处，就是可以使用一个简短的名称来表示一种类型，而不需要总是使用很长的代码来，这样不仅使得代码更加简洁易读，更是避免了代码敲写容易出错的问题。强烈推荐各位在定义结构体，指针（尤其是函数指针）等比较复杂的结构时，使用typedef来定义。

每一个函数本身也是一种程序数据，一个函数包含了多条执行语句，它被编译后，实质上是多条机器指令的合集。

在程序载入到内存后，函数的机器指令存放在一个特定的逻辑区域：代码区。

既然是存放在内存中，那么函数也是有自己的指针的。

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

16. 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* 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;
}

17. 深拷贝和浅拷贝

如果2个程序单元（例如2个函数）是通过拷贝他们所共享的数据的指针来工作的，这就是浅拷贝，因为真正要访问的数据并没有被拷贝。

如果被访问的数据被拷贝了，在每个单元中都有自己的一份，对目标数据的操作相互不受影响，则叫做深拷贝。

18. 附加知识

指针和引用这个2个名词的区别。他们本质上来说是同样的东西。

指针常用在C语言中，而引用，则用于诸如Java，C#等 在语言层面封装了对指针的直接操作的编程语言中。

大端模式和小端模式

1）Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。个人PC常用，Intel X86处理器是小端模式。

2. Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

采用大端方式进行数据存放符合人类的正常思维，而采用小端方式进行数据存放利于计算机处理。

有些机器同时支持大端和小端模式,通过配置来设定实际的端模式。

假如 short类型占用2个字节，且存储的地址为0x30。

short a = 1;

如下图：

//测试机器使用的是否为小端模式。是，则返回true，否则返回false
//这个方法判别的依据就是：C语言中一个对象的地址就是这个对象占用的字节中，地址值最小的那个字节的地址。

bool isSmallIndain()
{      
    unsigned int val = 'A';      
    unsigned char* p = (unsigned char*)&val;  
    //C/C++：对于多字节数据，取地址是取的数据对象的第一个字节的地址，也就是数据的低地址
    return *p == 'A';
}

—END—