1.指针到底是什么？

1.1、指针变量和普通变量的区别

首先必须非常明确：指针的实质就是个变量，它跟普通变量没有任何本质区别。指针完整的名字应该叫指针变量，简称为指针。

int main(void)
{
    //a的实质就是一个编译器中的符号，
   //在编译器中a和一个内存空间联系起来，这个内存空间就是a所代表的那个变量
    int a;  // 定义int型变量，名字叫a
    int *p;  // 定义一个指针变量，名字叫p，p指向一个int型变量
    a = 4;  //可以操作；
    p = 4;  // 编译器不允许，因为指针变量虽然实质上也是普通变量，
      //但是它的用途和普通变量不同。指针变量存储的应该是另一个变量的地址，
     //而不是用来随意存一些int类型的数。
    p = (int *)4;  // 我们知道其实就是数字4，但是我们强制类型转换成int *类型的4，
    //相当于我们告诉编译器，这个4其实是个地址（而且是个int类型变量的地址），
    //那么（int *）4就和p类型相匹配了，编译器就过了。 
    return 0;
}

1.2、为什么需要指针?

（1）指针的出现是为了实现间接访问，在汇编中都有间接访问，其实就是CPU的寻址方式中的间接寻址。
（2）间接访问（CPU的间接寻址）是CPU设计时决定的，这个决定了汇编语言必须能够实现间接寻址，又决定了汇编之上的C语言也必须实现间接寻址。
（3）高级语言如JAAV、C#等没有指针，那他们这么实现间接访问？
答案是语言本身帮我们封装好了。

1.3、指针使用三部曲：定义指针变量、关联（绑定）指针变量、解引用

（1）当我们int *p定义一个指针变量p时，因为p是局部变量，所以也遵循C语言局部变量的一般规律（定义局部变量并未初始化，则值是随机的），所以此时p变量中存储的是一个随机数字。
（2）此时如果我们解引用p，则相当于我们访问了这个随机数字为地址的内存空间，那这个空间到底能不能访问不知道（也许行也许不行），所以如果直接定义指针变量未绑定有效地址就去解引用几乎会发生错误。
（3）定义一个指针变量，不经绑定有效的地址就去解引用，就好像一把枪随意开了一枪，没有意义。
（4）指针绑定的意义在于：让指针指向一个可以访问、应该访问的地方，指针的解引用只是为了间接访问目标变量。

int main(void)
{
    // 演示指针的标准使用方式，指针使用分3步：
    // 定义指针变量、给指针变量赋值（绑定指针）、解引用
    int a = 2;
    // 第一步，定义指针变量
    int *p;
    printf("p = %p.\n", p);  // %p和%x打印指针，结果是一样的。
    /*第二步，绑定指针，其实就是给指针变量赋值，也就是让这个指针指向另外一个变量，
    当我们没有绑定指针变量之前，这个指针不能被解引用。*/
    p = &a;  // 实现指针绑定，让p指向变量a
    p = (int *)4;  // 实现指针绑定，让p指向内存地址为4的那个变量
    /*第三步，解引用。如果没有绑定指针到某个变量就去解引用，几乎都会出错*/
    *p = 555;  // 把555放入p指向的变量中

    return 0;
}

2.指针带来的一些符号的理解

我们写的代码是给编译器看的，代码要想达到你想要的结果，就必须要编译器对你的代码的理解和你自己对代码的理解是一样的。编译器理解代码就是理解符号。

2.1、星号*

（1）C语言中的可以表示乘号，也可以表示指针符号。这两个用法是毫无关联的，只是恰好用了同一个符号而已。
（2）星号在用于指针相关功能的时候有2种用法：
第一种是指针定义时，结合前面的类型用于表明要定义的指针类型；
第二种功能是指针解引用，解引用时*p表示p指向的变量本身。

2.2、取地址符&

取地址符使用时直接加在一个变量的前面，然后取地址符和变量加起来构成一个新的符号，这个符号表示变量的地址。

int main(void)
{
    int a;  // &a表示a的地址
    int *p;
    p = &a;
}

解析：编译器看到一个&a，就知道我们是要把变量a的地址赋给指针变量p，因为变量a的地址是编译器分配的，所以只有编译器才知道a的地址。我们没法直接把a的地址的数字赋值给p，只有用符号&a来代替。
理解&a，p这样的符号，关键在于要明白当&和与后面的变量结合起来后，就构成了一个新的符号，这个新的符号具有一定的意义。

2.3、指针定义并初始化、与指针定义然后赋值的区别

（1）指针定义时可以初始化，指针的初始化其实就是给指针变量赋初值，（跟普通变量的初始化没有任何本质区别）。
（2）指针变量定义的同事初始化的格式是：
int a = 32; int *p = &a;
（3）不初始化时指针变量先定义再赋值
int a = 32; int *p; p = &a;

2.4、左值和右值

（1）放在赋值运算符左边就叫做左值，右边就叫做右值。所以赋值操作其实就是：左值=右值；
（2）当一个变量做左值时，编译器认为这个变量符号的真实含义是这个变量所对应的那个内存空间；当一个变量做右值时，编译器认为这个变量符号的真实含义是这个变量的值，也就是这个变量所对应的内存空间中存储的那个数。
（3）左值与右值的区别：就好像是现实中“家”这个字的含义。比如“我回家了”这里的家指的是你家的房子（左值），但是说“家比事业重要”，这时候的家指的是家人（右值），家人就是在家对应的那个房子里面的人。

int main(void)
{
    int a= 3, b = 5；
    a = b; // 当a做左值时，我们关心的是a所对应的内存空间，而不是其中存储的3
    b = a; // 当a做右值时，我们关心的是a岁对应空间中存储的数，也就是5
}

3.野指针

3.1、什么是野指针？有什么危害?

（1）野指针，就是指针指向的位置是不可知的，（随机的、不正确的、没有明确限制的）
（2）野指针很可能出发运行时段错误（Sgmentation fault）
（3）因为指针变量在定义时如果未初始化，值也是随机的。指针变量的值其实就是别的变量（指针所指向的那个变量）的地址，所以意味着这个指针指向了一个地址是不确定的变量，这时候去解引用就是去访问这个地址不确定的变量，所以结果是不可知的。
（4）野指针因为指向地址是不可预知的，所以有3中情况：
①第一种是指向不可访问（操作系统不允许访问的敏感地址，比如内核空间）的地址，结果是触发段错误，这种算是最好的情况了；
②第二种是指向一个可用的，而且没什么特别意义的空间（比如我们曾经使用过的但是已经不用的栈空间或者是堆空间），这时候程序运行不会出错，也不会对当前程序造成损害，这种情况下会掩盖你的程序错误，让你以为程序没问题，其实是有问题的；
③第三种情况就是指向一个可用的空间而且这个空间其实在程序中正在被使用（比如是程序的一个变量x），那么野指针的解引用就会刚好修改这个变量x的值，导致这个变量莫名其妙的被改变，程序出现的利器的错误。一般最终都会导致程序崩溃，或者数据被损害。这种危害是最大的。
（5）指针变量如果是局部变量，则分配在栈上，本身遵从栈的规律（反复使用，使用完不擦除，所以是脏的，本次在栈上分配到的变量默认值是上次这个栈空间被使用时余留下来的），就决定了栈的使用多少会影响这个默认值。因此野指针的值是有一定规律不是完全随机，但是这个值的规律对于我们没有意义。因为不管落在上面野指针3种情况的哪一种，都不是我们想看到的。

3.2、怎么避免野指针？

（1）野指针的错误来源就是指针定义了以后没有初始化，也没有赋值（总之就是指针没有明确指向一个可用的内存空间），然后去解引用。
（2）知道了野指针的产生原因，避免方法就出来了：在指针解引用之前，一定要确保指针指向一个绝对可用的空间。
（3）常规的做法是：
第一点，定义指针时，同时初始化为NULL
第二点，在指针解引用之前，先去判断这个指针是不是为NULL
第三点，指针使用完之后，将其赋值为NULL
第四点，在指针使用之前，将其赋值绑定给一个可用地址空间。
（4）野指针的防治方案4点绝对可行，但是略显麻烦，很多人懒得这么做，那实践中是怎么处理？
在中小型程序中，，自己水平可以把握的情况下，不必严格参照这个标准，但是在大型程序中，或者自己水平感觉不好把握时，建议严格参照这个方法。

3.3、NULL到底是什么？

（1）NULL在C/C++中定义为

#ifdef  __cpluscplus  // C++环境
#define  NULL  0    // C++中NULL就是0
#else
#define  NULL  (void *)0  // 在C中NULL是强制类型转换为void *的0
#endif

（2）在C语言中，int *p；你可以p = (int *)0;但是不可以p = 0；因为类型不相同。
（3）所以NULL的实质其实就是0，然后我们给指针赋初值为NULL，其实就是让指针指向0地址处。为什么指向0地址处？2个原因
第一层原因是0地址处作为一个特殊地址（我们认为指针指向这里就表示指针没有被初始化，就表示是野指针）；
第二层原因是这个0地址在一般的操作系统中都是不可被访问的，如果C语言程序员不按规矩（不检查是否等于NULL就去解引用），写代码直接去解引用就会触发段错误，这种已经是最好的结果了。
（4）一般在判断指针是否是野指针时，都写成
if (NULL != p)，而不是写成if (p != NULL)
原因是：如果NULL写在后面，当中间是==号的时候，有时候容易王家写成一个=号，这时候其实程序已经是错了，但是编译器不会报错。这个错误（对新手）很难检查出来；如果习惯了把NULL写在前面，当错误的把==写成=时，编译器会报错，程序员会发现这个错误。

4.const关键字与指针

4.1、const修饰指针的4种形式

（1）const关键字，在C语言中用来修饰变量，表示这个变量是常量
（2）const修饰指针有4种形式，区分清楚这4中即可全部理解const和指针。（实在难理解就把数据类型去掉来看）
①第一种，p本身不是const的，而p指向的变量是const的
const int *p1;
②第二种，p本身不是const的，而p指向的变量是const的
int const *p2;
③第三种，p本身是const的，p指向的变量不是const的
int * const p3;
④第四种，p本身是const的，p指向的变量也是const的
const int * const p4;
测试：
*p1 = 3;
*p2 = 5;
上面两种都是报指针指向的变量只读（read-only）错误
*p3 = 5; 编译无错误无警告
p3 = &a; 报指针变量只读（read-only）错误
（3）关于指针变量的理解，主要涉及2个变量：
第一个指针变量p本身，第二个是p指向的那个变量（*p）。一个const关键字只能修饰一个变量，所以弄清楚这4个表达式的关键就是搞清楚const放在某个位置是修饰谁的。

4.2、const修饰的变量真的不能改吗？

（1）const修饰的变量其实是可以改的（前提是gcc环境下）
（2）在某些单片机环境下，const修饰的变量是不可以改的。const修饰的变量到底能不能真的被修改，取决于具体的环境，C语言本身并没有完全严格一致的要求。
（3）在gcc中，const是通过编译器在编译时候执行检查来确保实现的（也就是说const类型的变量不能改是编译错误，不是运行时错误），所以我们只要想办法骗过编译器，就可以修改const定义的常量，而运行时就不会报错。
（4）更深入一层的原因，是因为gcc把const类型的常量也放在data段，其实和普通的全局变量放在data段是一样实现的，只是通过编译器认定这个变量是const的，运行时并没有标记const标志，所以只要骗过编译器就可以修改了。

int main()
{
    const  int  a = 5;
    //  a = 6;  //error:只读变量
    int *p;
    p =  (int *)&a;  // 这里报警告可以通过强制类型转换来消除
    *p = 6;
    printf("a = %d.\n", a);  // a = 6，结果证明const类型的变量通过指针修改了
}

4.3、const究竟应该怎么用？

const是在编译器中实现的。编译时检查，并非不能骗过。所以C语言中使用const，就好像是一种道德的约束而非法律约束，所以大家使用const时更多的是传递一种信息，就是告诉编译器，也告诉读程序的人，这个变量是不应该也不必要被修改的。

5.深入学习一下数组

5.1、从内存角度来理解数组

（1）从内存角度讲，数组变量就是一次分配多个变量而且这多个变量在内存中的存储单元是依次相连接的。
（2）我们分开定义多个变量（比如int a，b，c，d）和一次定义数组（int a[4];），这两种定义方法相同点是都定义了4个int型变量，而且这4个变量都是独立的单个使用的；不同点是单独定义时，a，b，c，d在内存中的地址不一定相连，但是定义成数组后，数组中的4个元素地址肯定是依次相连的。
（3）数组中多个变量虽然必须单独访问，但是因为他们的地址彼此相连，因此很适合用指针来操作，因此数组和指针天生就纠结在一起，很适用。

5.2、从编译器角度来理解数组

（1）从编译器角度来讲，数组变量也是变量，和普通变量和指针变量并没有本质不同。变量的本质就是一个地址，这个地址在编译器中决定具体数值，具体数值和变量名绑定，变量类型决定这个地址的延续长度。
（2）搞清楚：变量、变量名、变量类型这三个概念的具体含义，很多问题都清楚了。
int a； char a；

5.3、数组中几个关键符号（a、a[0]、&a、&a[0]）的理解（前提是int a[10]）

（1）这4个符号搞清楚了，数组相关的很多问题都有答案了。理解这些符号的时候要和左值右值结合起来，也就是搞清楚每个符号分别做左值和右值的不同含义。
（2）①a就是数组名。a做左值时表示整个数组的所有空间（10x4=40字节），又因为C语言规定数组操作时要独立单个操作，不能整体操作数组，所以a不能做左值；②a做右值时表示数组首元素（数组的第1个元素，也就是a[0]）的首地址（首地址就是起始地址，就是4个字节中最开始第一个字节的地址）。a做右值时等同于&a[0]。
（3）①a[0]表示数组的首元素，也就是数组的第0个元素。做左值时表示数组第0个元素对应的内存空间（连续4个字节）；②做右值时表示数组第0个元素的值（也就是数组第0个元素对应的内存空间中存储的那个数）。
（4）①&a就是数组名a取地址，字面意思来看就是数组的地址。&a不能做左值（&a实质就是一个常量，不是变量，因此不能赋值，所以自然不能做左值）。②&a，做右值时表示整个数组的首地址。
解释：为什么数组的地址是常量？
因为数组是编译器在内存中自动分配的，当我们每次执行程序时，运行时都会帮我们分配一块内存给这个数组，只要完成了分配，这个数组的地址就定好了，本次程序运行时直到终止都无法再改了。那么我们在程序中只能通过&a来获取这个分配的地址，却不能去用赋值运算符修改它。
注意：&a和a做右值时的区别:
&a是整个数组的首地址，而a是数组首元素的首地址。这两个在数字上是相同的，但是意义不相同，比如说0x12345678这个地址既是整个数组的首地址，又是数组首元素的首地址，但是两个值的类型是不一样的，不分清楚使用会报警告。意义不相同会导致他们在参与运算的时候有不同的表现。
（5）总结：
①&a[0]字面意思是数组第0个元素的首地址（[]的优先级高于&，所以a先和[]结合后再取地址），是常量，不能做左值。做右值时表示数组首元素首地址的值。做右值时&a[0]等同于a。
②a和&a[0]做右值时意义和数值完全相同，可以互相替代。
③&a是常量，不能做左值
④a做左值代表整个数组所有空间，C语言规定操作数组时要独立单个操作，不能整体操作数组，所以a不能做左值。

6.指针与数组的天生姻缘

6.1、以指针方式来访问数组元素

（1）数组元素使用时不能整体访问，只能单个访问，访问方式有2种：数组形式和指针形式。
（2）数组格式访问数组元素是：
数组名[下标]; （下标从0开始）
（3）指针格式访问数组元素是：
*(指针+偏移量)；
如果指针是数组首元素首地址（a或&a[0]），那么偏移量就是下标；指针也可以不是首元素地址，可以是其他哪个元素的地址，这时候偏移量就要考虑叠加了。

int main(void)
{
    int a[5]  =  {1, 2, 3, 4, 5};
    printf("a[3] = %d.\n", a[3]);
    printf("*(a+3) = %d.\n", *(a+3));
    /*等效于
    int b = *(a+3);
    printf("*(a+3) = %d.\n", b);
    */
    int *p;
    p = a; // a做右值时表示数组首元素首地址，等同于&a[0]
    printf("*(p+3) = %d.\n", *(p+3));  // a、&a[0]、p它们的地址值和含义是相同的
    p = &a[2];
    printf("*(p+1) = %d.\n", *(p+1));
    printf("*(p-1) = %d.\n", *(p-1));
    return 0;
}

（4）数组下标方式和指针方式均可以访问数组元素，两者的实质其实是一样的。在编译器内部都是用指针方式来访问数组元素的，数组下标方式只是编译器提供给编程者一种壳（语法糖）而已。所以用指针方式来访问数组才是本质的做法。

6.2、从内存角度理解指针访问数组的实质

（1）数组的特点就是：数组中各个元素的地址是依次相连的，而且数组还有一个很大的特点（其实也是数组的一个限制）就是数组各元素的类型必须相同。类型相同就决定了每个数组元素占几个字节是相同的（比如int数组每个元素都占4个字节，没有例外）。
（2）数组中的元素其实就是地址相连接，占地大小相同的一串内存地址。这两个特点就决定了只要知道数组中一个元素的地址，就可以很容易推算出其他元素的地址。

6.3、指针与数组类型的匹配问题

（1）int *p; int a[5]; p = a; // 类型匹配
（2）int *p; int a[5]; p = &a; // 类型不匹配
p是int *类型，&a是整个数组的指针，也就是一个数组指针类型，不是int指针类型，所以不匹配。
（3）&a、a、&a[0]从数值上来看是完全相等的，但是意义来看就不同了。从意义来看，a和&a[0]是数组首元素首地址，而&a是整个数组的首地址；从类型来看，a和&a[0]是元素的指针，也就是int 类型；而&a是数组指针，是int () [5]类型。

6.4、总结：指针类型决定了指针如何参与运算

（1）指针参与运算时，因为指针变量本身存储的数值是表示地址的，所以运算也是地址的运算。
（2）指针参与运算的特点是，指针变量+1，并不是真的加1，而是加1*sizeof(指针类型)；如果是int *类型，则+1就实际表示地址+4；如果是char *指针，则+1就是表示地址+1；如果是double 指针，则+1就是表示地址+8。
（3）指针变量+1时实际不是加1而是加1sizeof(指针类型)，主要原因是希望指针+1后刚好指向下一个元素（而不希望错位）。

7.不同数据类型的存储问题

7.1、各数据类型存存储

（1）所有类型的数据存储在内存中都是按照二进制格式存储的。所以内存中只知道0和1，不知道是int的、还是float的还是其他类型的。
（2）int、char、short等属于整型，他们的存储方式（数转换成二进制数往内存中方的方式）是相同的，只是内存格子大小不同（所以这几种整型就彼此叫做二进制兼容格式，而float和double的存储方式彼此不同，和整型更不同）。
（3）int a = 5;时，编译器给a分配4字节空间，并且将5按照int类型的存储方式转换成二进制存到a所对应的内存空间中去（a做左值的）；我们printf去打印a的时候（a做右值），printf内部的vsprintf函数会按照格式化字符串（就是printf传参的第一个字符串参数中的%d之类的东西）所代表的的类型去解析a所对应的内存空间，解析出的值用来输出。也就是说，存进去时是按照这个变量本身的数据类型来存储的（比如本例中a为int所以按照int格式来存储）；但是取出来时是按照printf中%d之类的格式化字符串的格式来提取的。此时，虽然a所代表的内存空间中10101序列并没有变（内存是没被修改的），但是怎么理解（怎么把这些10101转成数字）就不一定了。
比如我们 用%d来解析，那么还是按照int格式解析则值自然是5；但是如果按照%f来解析，则printf就以为a对应的内存空间中存储的是一个float类型的数，会按照float类型来解析，值自然是很奇怪的一串数字了。
总结：
C语言中的数据类型的本质，就是决定了这个数在内存中怎么存储的问题，也就是决定了这个数是如何转换成二进制的问题。一定要记住的一点是：内存只是存储1010的序列，而不管这些1010怎么解析。所以要求我们平时数据类型不能瞎胡乱搞（比如按照int类型存却按照float类型取一定会出错）。
分析几个题目：
①按照int类型存却按照float类型取——一定会出错；
②按照int类型存却按照char类型取——有可能出错也有可能不出错；
③按照short类型存却按照int类型取——有可能出错也有可能不出错；
④按照float类型存却按照double类型取——一定会出错；

7.2、指针的数据类型的含义

（1）指针的本质是：变量，指针就是指针变量。
（2）一个指针涉及2个变量：一个是指针变量本身，一个是指针变量指向的那个变量。
（3）int *p;定义指针变量时，p（指针变量本身）是int 类型，p（指针指向的那个变量）是int类型的。
（4）int *类型说白了就是指针类型，只要是指针类型就都是占4字节，解析方式都是按照地址的方式来解析的（意思是里面存的是32个二进制加起来表示一个内存地址）。结论就是：所有的指针类型（不管是int *还是char *还是double *）的解析方式都是相同的，都是地址，是地址就占4个字节。
（5）对于指针所指向的那个变量来说，指针的类型就很重要了。指针所指向的那个变量的类型（它所对应的内存空间的解析方法）要取决于指针类型。比如指针是int *的，那么指针所指向的变量就是int类型的。

7.3、指针数据类型转换实例分析1

int * ——> char *
（1）int和char类型都是整型，类型是兼容的。所以互相转的时候有时错有时对；
（2）int和char的不同在于char只有1个字节而int有4个字节，所以int的范围比char大。在char所表示的范围之内int和char是可以相互转换不会出错；但是超过了char的范围后char转换int不会错（向大方向转换就不会错，就好比拿小瓶子的水往大瓶子倒不会漏掉一样），而从int到char转就会出错（就好像拿大瓶子的水往小瓶子倒一样）。

7.4、指针数据类型转换实例分析2

int * ——> float *
int和float的解析方式是不兼容的，所以int * 转成float *再去访问绝对会出错。

8.指针、数组与sizeof运算符

sizeof关键字作用：返回一个对象或者类型所占的内存字节数。

8.1、char str[] = "hello";

sizeof(str) —— 6 // 最后还有结束符'\0'，所以6
sizeof(str[0]) —— 1 // 字符数组第0个元素为char类型的'h'，所以1
strlen(str) —— 5 // 计算字符串长度函数，不包括'\0'，所以5

8.2、char *p = str;

sizeof(p) —— 4 （同sizeof(char )） // 指针类型都是4
sizeof(*p) —— 1 (同sizeof(char)) // p指向字符数组首元素首地址，p指首元素的内容，即'h'字符，它占1个字节，所以1
strlen(p) —— 5 (同strlen(str)) // p指向字符数组首元素首地址，将首地址存的内容放入strlen函数作为起始点计算，直到遇到'\0'，结束返回长度，所以5。若p指向str[2]，则将字符数组的第2个元素的地址存的内容放入strlen函数开始计算，直到遇到'\0'结束返回长度，所以3。
（1）32位系统中所有指针的长度都是4，不管是什么类型的指针。
（2）strlen是一个C库函数，用来返回一个字符串长度（注意，字符串的长度是不计算字符串末尾的'\0'的，一定要注意strlen接收的参数必须是一个字符串），字符串的特征是以'\0'结尾。
（3）注意区别：sizeof(p)和sizeof(*p)和sizeof(str)和sizeof(*str)
前提：char str[] = "hello"; char *p = str; 结果分别为4、1、6、1
①sizeof(p)，p指向数组首元素首地址，这里计算的是p指针本身，所以4。
②sizeof(*p)，p指向数组首元素首地址，这里计算的是p指针指向的地址所在的元素，即'h'字符，所以1。
③sizeof(str)，str数组名表示数组首元素首地址，这里计算的是str整个数组本身，所以6。
④sizeof(*str)，str数组名表示数组首元素首地址，这里计算的是str代表的地址所在的元素，即'h'，所以1。

数组与指针的sizeof

8.3、int b[100] = {10}; sizeof(b)

结果100sizeof(int) = 1004 = 400
sizeof(数组名)的时候，数组名不做左值也不做右值，纯粹就是数组名的含义。那么sizeof(数组名)实际返回的是整个数组所占的内存空间。（也可解释上图）

8.4、效果相同的函数（注意形参）

void func(int a[])
{
    printf("数组的大小=%d.\n", sizeof(a));
}
void func1(int *a)
{
    printf("数组的大小=%d.\n", sizeof(a));
    int a[56];
    int b = sizeof(a)/sizeof(a[0]); 
    printf("b = %d.\n", b);  // 结果等于数组的元素个数
}

（1）函数传参，形参是可以用数组的
（2）函数形参是数组时，实际传递不是整个数组，而是数组的首元素首地址。也就是说函数传参用数组来传，实际相当于传递的是指针（指针指向数组的首元素首地址）。

8.5、宏定义和指针

#define dpChar char *
typedef char * tpChar
int main(void)
{
    dpChar p1, p2;  // 展开:char *p1, p2; 相当于char *p1; char p2;
    tpChar p3, p4;  // 等价于char *p3; char *p4;
}

指针是4，字符是1
sizeof(p1) —— 4
sizeof(p2) —— 1
sizeof(p3) —— 4
sizeof(p4) —— 4

9.指针与函数传参

9.1、普通变量作为函数形参

void func1(int b)
{
    printf("b = %d.\n", b);
    printf("in func1, &b = %p.\n", &b);
}

int main(void)
{
    int a[5];
    int a = 4;
    printf("a &b = %p.\n", &a);
    func1(a);
    return 0;
}

（1）函数传参时，普通变量作为参数时，形参和实参名字可以相同也可以不同，实际上都是实参来代替相对应的形参。
（2）在子函数内部，形参的值等于实参。原因是函数调用时把实参的值赋给了形参。
（3）这就是很多书上写的“传值调用”。&a和&b不同，说明a和b不是同一个变量（在内存中a和b是独立的2个内存空间），但是a和b是有关联的，实际上b是a赋值得到的。

9.2、数组作为函数形参

void func2(int a[])
{
    printf("sizeof(a) = %d.\n", sizeof(a));
    printf("in func2, a = %p.\n", a);
}

（1）函数名作为形参传参时，实际传递的不是整个数组，而是数组的首元素首地址。所以在子函数内部，掺进来的数组名就是一个指向数组首元素首地址的指针，所以sizeof(a)得到的是4。
（2）在函数内部传参得到的数组首元素首地址和外面得到的数组首元素首地址的值是相同的。很多人把这种特性叫做“传址调用”（所谓的传址调用就是调用子函数时传了地址，也就是指针），此时可以通过传进去的地址来访问实参。
（3）数组作为函数传参时，[]里的数字是可有可无的。为什么？
因为数组名做形参传递的实际只是个指针，根本没有数组长度这个信息

9.3、指针作为函数形参

只有一句话：和数组作为形参一样的，这就好像指针方式访问数组元素和数组方式访问数组元素的结果一样。

9.4、结构体作为函数形参

struct A
{
   char a;
   int b;
};
void func4(struc A a1)
{
   printf("sizeof(a1) = %d.\n", sizeof(a1));
   printf("&a1 = %p.\n", &a1);
   printf("a1.b = %%d.\n", a1.b);
}

int main(void)
{
   struct A a = {
           .a = 4,
           .b = 555,
   };
   printf("sizeof(a) = %d.\n", sizeof(a));
   printf("&a = %p.\n", &a);
   printf("a.b = %%d.\n", a.b);
   func4(a);
   return 0;
}

（1）结构体变量作为函数形参的时候，实际上和普通变量（类似于int之类的）传参时表现是一摸一样的。所以说结构体变量其实也是普通变量而已。
（2）因为结构体一般都很大，所以如果直接用结构体变量进行传参，那么函数调用效率会很低。怎么解决？
思路只有一个，那就是不要传变量了，改传变量的指针（地址）进去。
（3）结构体因为自身太大，所以传参应该用指针来传（但是程序员可以自己决定，你非要传结构体变量过去C语言也是允许的，只是效率低了）；回想一下数组，为什么C语言设计的时候数组传参默认是传的数组首元素首地址而不是整个数组？

9.5、传值调用与传址调用

（1）传值调用描述的是这样一种现象：x和y作为实参，自己并没有真身进去swap1函数内部，而是拷贝了一份自己的副本（副本具有和自己一样的值，但是是不同的变量）进入子函数swap1，然后我们在子函数swap1中交换的实际是副本而不是x，y真身。所以在swap1内部确实交换了，但是到外部的x和y根本没有受影响。
（2）在swap2中x和y真的被改变了（但是x和y真身还是没有进入swap2函数内，而是swap2函数内部跑出来把外面的x和y改变了）。实际上实参x和y永远无法真身进入子函数内部（进去的只能是一份拷贝），但是在swap2我们把x和y的地址传进去给子函数了，于是乎子函数内可以通过指针解引用方式从函数内部访问到外部的x和y的真身，从而改变x和y。
（3）结论：C语言本身函数调用时一直是传值的，只不过传的值可以是变量名，也可以是变量的指针。

10.输入型参数与输出型参数

10.1、函数为什么需要形参与返回值

（1）函数名是一个符号，表示整个函数代码段的首地址，实质是一个指针常量，所以在程序中使用到函数名时都是当地址用的，用来调用这个函数的。
（2）函数体是函数的关键，由一堆{}括起来，包含很多句代码，函数体就是函数实际做的工作。
（3）形参列表和返回值。形参是函数的输入部分，返回值是函数的输出部分。对函数最好的理解就是函数看成是一个加工机器（程序其实就是数据加工器），形参列表就是这个机器的原材料输入端，而返回值就是机器的成品输出端。
（4）其实如果没有形参列表和返回值，函数也能对数据进行加工，用全局变量即可。用全局变量来传参和函数参数列表返回值来传参各有特点，在实践中都有使用，因为这样可以实现模块化编程，而C语言中也是尽量减少使用全局变量。
（5）全局变量传参最大的好处就是省略了函数传参的开销，所以效率要高一些，但是实战中用的最多的还是形参传参。如果参数很多传参开销很大，通常的做法就是把很多参数打包成一个结构体，然后传结构体变量的指针进去。

10.2、函数产餐中使用const指针

（1）const一般用在函数参数列表中，用法是const int *p; （意义是指针变量p本身可变的，而p所指向的变量是不可变的）。
（2）const用来修饰指针做函数传参，作用就在于声明在函数内部不会改变这个指针所指向的内容，所以给函数传一个不可改变的指针（char *p = “linux”）不会触发错误，而一个未声明为const的指针的函数，你给他传一个不可改变的指针的时候就要小心了，可能会报错。也就是未限定const而传了一个不可改变的是会有报错风险的。

10.3、函数需要向外部返回多个值时怎们办？

（1）一般来说，函数的输入部分就是函数参数，输出部分就是返回值。问题是函数的参数可以有很多个，而返回值只有1个。这就造成了我们无法让一个函数返回多个值。
（2）现实编程中，一个函数需要返回多个值是非常普遍的，因此完全依赖于返回值是不靠谱的，通常的做法是用参数来做返回（在典型的Linux风格函数中，返回值是不用来返回结果的，而是用来返回0或者负数表示程序执行结果是对还是错，是成功还是失败）。
（3）普遍的做法是，编程中函数的输入和输出都是靠函数参数的，返回值只是用来表示函数执行的结果是对（成功）还是错（失败）。如果这个参数是用来做输入的，就叫做输入型参数；如果是这个参数的目的是用来做输出的，就叫做输出型参数。
（4）输出型参数就是用来让函数内部把数据输出到函数外部的。

10.4、总结

（1）看到一个函数的原型后，怎样一眼看出来哪个参数是输入哪个是输出？
函数传参如果传的是普通变量（不是指针），那肯定是输入型参数；如果传指针就有2种可能性了，为了区别，经常的做法就是：如果这个参数是做输入的（通常做输入的在函数内部只需要读取这个参数而不需要改变它，一般右值）就在指针前面加const来修饰；如果函数形参是指针变量并且没加const，那么就表示这个参数是用来做输出型参数的。
（2）比如C库函数中的strcpy
char *strcpy(char *dest, const char *src)
dest是可改变的，输出型参数
src是不可改变的，输入型参数