C@指针&数组 | 易学教程

一、指针数组和数组指针

1、字面意思理解指针数组和数组指针

指针数组的实质就是一个数组，这个数组中存储的内容全部是指针变量
数组指针的实质是一个指针，这个指针指向的是一个数组。
2、分析指针数组和数组指针的表达式
（1）int*p[5]；
int（*p）[5]；
int *（p[5]）；
（2）一般规律：int *p；（p是一个指针）
int p[5] ；（p是一个数组）
总结：我们定义一个符号时，关键在于首先找到定义的符号是谁（第一步找核心）
其次再来看谁跟核心最近，谁跟核心结合（第二部：找结合）
以后继续向外扩展（第三步：继续向外结合直到符号完）
（3）核心结合
- 如何核心和 “ * ”结合，表示核心是指针，
- 如果核心和“[ ]”结合表示核心是数组，
- 如果核心和小括号“（）”结合，表示核心是函数
（4）一般规律来分析3个符号
例子1： int *p[5]; （“[ ]”的优先级比“ * ”优先级高）
p是一个数组，数组有5个元素，数组中的元素都是指针，指针指向的元素类型是int类型，整个符号是一个指针数组。
例子2： int （*p）[5]；
核心是p，p是一个指针，因为p被用括号和星好强制结合起来了。指针指向一个数组，数组有5个元素，数组中存在的元素是int类型；
例子3： int *（p[5]）;
这里加小括号没有意义，没起到左右，没有小括号，也是p与[ ]先结合。
注释：符号的优先级的作用就是决定当两个符号一起作用的时候决定哪个符号先运算，哪个符号后运算；（[ ]；.；->；这几个优先级比较高）

总结： 1、优先级和结合性是分析符号意义的关键
2、学会逐渐剥离分析法
3、基础理论和原则是关键

二、指针带来的一些符号

1、星号 “ * ”
（1）C语言中的星号可以表示乘号，也可以表示指针符号。这两个用法毫无关联。
（2）星号在用于指针相关功能时有2种用法：

第一种：是指针定义时，星号结合前面的类型用于表明要定义的类型

int *p; //*和int结合表明P的类型是int*，也就是说P是指向int类型的指针

//把星号和指针变量放在一起，而不是和int挨着，是为了一行定义多个变量好理解
int  *p5,p6;   //定义的p5是int*指针，p6是int普通变量
int*  p5,p6;   //定义的p5是int*指针，p6是int普通变量
int  *p5,*p6;  //定义了两个int*指针变量p5，p6

第二种：指针解引用，解引用时*p表示p指向的变量本身（表示变量的值）

int a =23;
int b = 0;

int *p;
p=&a;
b=*p;   //b=23
printf("b = %d",b)  //打印输出p=23

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

int a;    //&a就表示a的地址
int *p;
p = &a;  //在编译器编译时遇到&a，就会将变量a的地址赋值给指针变量p；
//因为变量a的地址是编译器给分配的，所以只有编译器知道a的地址，而我们无法直接把a地址的数字赋值给p，只能用符号&a来替代。

3、指针定义并初始化、与指针定义然后赋值的区别
（1）指针定义时可以初始化，指针的初始化其实就是给指针变量初值（跟普通变量的初始化没有任何区别）。
（2）指针变量定义同时初始化的格式是：int a =32；int *p=&a；
不是初始化时指针变量先定义再赋值：int a =32；int *p； p = &a；
*p = &a //错误赋值
4、左值与右值
（1）放在赋值运算符号左边的叫做左值，右边的叫做右值。所以赋值其实就是：左值=右值；
（2）当一个变量作为左值时，编译器认为这个变量符号的真实含义是这个变量所对应的存储空间；当一个变量作为右值时，编译器认为这个变量符号的真实含义是这个变量的值，也就是这个变量所对应的内存空间中存储的那个数。

int a = 3 , b = 5;
a = b;  //当a作为左值时，我们关心的是a所对应的内存空间，而不是其中存储的数
b = a;  //当a作为右值时，我们关心的是a所对应内存空间中存储的数

（3）左值与右值的区别，一个注重内存空间的数值，一个注重内存空间

三、野指针问题

1、神马是野指针？哪里来的，有什么危害？
（1）野指针，就是指针指向的位置是不可知的，（随机的、不明确的、没有明确限制的）
（2）野指针很可能触发运行时段错误
（3）因为指针变量在定义时如果未初始化，值也是随机的。指针变量的值其实就是别的变量（指针所指向的那个变量）的地址，所以意味着这个指针指向了一个地址是不确定的变量，这时候去解引用就是去访问这个地址不确定的变量，所以结果是不可知的。
(4)野指针因为指向地址是不可预知的，所以有三种情况：第一是指向不可访问（操作系统不许访问的敏感地址，比如内核空间）的地址，结果是触发段错误，这种算是最好的结果；第二种是指向一个可用的而且没有什么意义的空间（比如我们曾经使用过但没有用的栈空间或者堆空间）；第三种是指向了一个可用的空间而且这个空间其实是这个程序正在被使用的。
（5）指针变量如果是局部变量，则分配在线上，本身遵从栈的规律（反复使用，使用完不擦除，所以是脏的，本次在栈上分配到的变量的默认值是上次这个栈空间使用时余留下来的值）

int *p；
printf("p =%p.\n ",*p);
*p = 4; //(core dumped)运行时段错误，原因为野指针
return 0;

2、避免野指针的方法
（1）野指针的错误来源就是指针定义了以后没有初始化，也没有赋值（总之就是指针没有明确的指向一个可用的内存空间）然后就去解引用。
（2）根据野指针产生原因，防止产生的方法：在指针的解引用之前一、确保指针指向一个有用的内存空间
（3）常规做法:

定义指针时，同时初始化为null5
在指针解引用之前，先去判断这个指针是不是NULL
指针使用完之后，将其赋值为NULL
在指针使用之前，将其赋值绑定给一个可用地址空间

int a;
int *p=NULL；
p = &a;   //正确的使用指针的方式，是解引用指针前跟一个绝对可用的地址绑定
if(p != NULL);
{
 *P = 4;
}
p = NULL;  //使用完指针变量后，记得将其从新赋值为NULL

四、const关键字与指针

1、const修饰指针的4种形式
(1)const关键字，在C语言中用来修饰变量，表示这个变量是常量。
(2)const修饰指针有4种形式，区分清楚这4种即可全部理解const和指针。
第一种：const int *p;
第二种：int const *p;
第三种：int * const p;
第四种：const int * const p;
(3)关于指针变量的理解，主要涉及到2个变量：第一个是指针变量p本身，第二个是p指向的那个变量(*p)。一个const关键字只能修饰一个变量，所以弄清楚这4个表达式的关键就是搞清楚const放在某个位置是修饰谁的
2、const修饰的变量真的不能改吗？
(1)课堂练习说明：const修饰的变量其实是可以改的（前提是gcc环境下）。
(2)在某些单片机环境下，const修饰的变量是不可以改的。const修饰的变量到底能不能真的被修改，取决于具体的环境，C语言本身并没有完全严格一致的要求。
(3)在gcc中，const是通过编译器在编译的时候执行检查来确保实现的（也就是说const类型的变量不能改是编译错误，不是运行时错误。）所以我们只要想办法骗过编译器，就可以修改const定义的常量，而运行时不会报错。
(4)更深入一层的原因，是因为gcc把const类型的常量也放在了data段，其实和普通的全局变量放在data段是一样实现的，只是通过编译器认定这个变量是const的，运行时并没有标记const标志，所以只要骗过编译器就可以修改了。
3、const的用法
（1）const是在编译器中实现的，编译时检查，并非不能骗过，所以在C语言中使用const

//第一种
const int *p1;   //p本身不是cosnt的，而p指向的变量是const的
//第二种
int const *p2;   //p本身不是cosnt的，而p指向的变量是const的
//第三种
int * const p3;   //p本身是const的，p指向的变量不是const的
//第四种
const int * const P4; //p本身是cosnt的，p指向的变量也是const的

*P1 = 3;  //error：assignment of read-only location ‘*p1’
p1 =&a;   //编译无错误
*P2 = 5;   //编译error
p2 = &a;
*p3 = 5;   //编译无错误
p3 = &a;    //编译error
p4 = &a;   //error
*p4 = 5;    //error
return 0;

五、数组

1、从内存角度理解数组
（1）从内存角度来讲，数组变量就是一次分配多个变量，而且这多个变量在内存中的存储单元是依次相连接的。
（2）分开定义多个变量和一次定义一个数组，如下：

int a,b,c,d;  //分开独立定义4个int型变量
int a[4];     //一次定义一个数组，包含4个int型变量

这两种定义相同点是都定义了4个int型变量，而且这4个变量都是独立的单独使用，
不同点是，单独定义时a，b，c，d在内存中的地址不一定相连，但是定义成数组的时候，数组中的元素地址肯定是相连的。
（3）数组中多个变量虽然必须单独访问，但是因为他们的地址彼此相连，因此很适合用指针来操作数组。
2、从编译器角度来讲
（1）数组变量也是变量，和普通变量及指针没有什么区别，变量的本质就是一个地址，这个地址在编译器中决定具体的数值，具体数值和变量名绑定，变量的类型决定这个地址的连续长度。
（2）变量、变量名、变量类型这三个概念的具体含义。
3、数组中的关键符号（a、a[ ]、&a、&a[ ]）
(1)理解每个符号作为左值和右值的含义
（2）int a[10]，a就是数组名
- a作为左值：表示整个数组的所有空间（104=40个字节）又因为C语言规定数组操作时要独立单个操作，所以a不能作为左值*。a的初始化（int
  a [3] =｛1，2，3｝）例外。
- a作为右值：表示数组的首元素（数组的第一个元素，也就是a[0]）的首地址（首地址就是起始地址，就是4个字节中最开始第一个字节的地址），a作为右值等同于&a[ 0];
  (3) a[0]表示数组的首元素，也就是数组的第0个元素
  - 作为左值时：表示数组第0个元素对应的内存空间（连续4个字节）
  - 作为右值时：表示数组第0个元素的值（也就是数组第0个元素对应内存空间中存储的那个数）
    （4）&a就是数组名a取地址，就是数组地址，&a不能作为左值，(&a实质是一个常量，不是一个变量因此不能赋值)
    注：为什么数组的地址是一个常量？
    因为数组是编译器在内存中自动分配的，当我们每次执行程序时，编译器都会帮我们分配一块内存给数组，只要完成了分配，这个数组的地址就不会变了。本次程序运行直到终止都无法再更改了。
    &a作为右值时表示数组的地址。
    注： &a和a作为右值时的区别：&a是整个数组的首地址，而a是数组首元素的首地址，这两个在数值上都是相等的，但是意义不同。

（5）&a[0]字面意思就是数组第0个元素的首地址。

作为左值时：表示数组首元素对应的内存空间
作为右值时：表示数组首元素的值，做右值时&a[ 0]等同于a（意义和数组完全相同）

六、指针和数组

1、以指针方式来访问数组元素
(1)数组元素使用时不能整体访问，只能单个访问，访问方式有2种：数组形式和指针形式。
（2）数组格式访问数组元素的格式是：数组名[ ] ,(注意下标从0开始)
（3）指针格式访问数组元素是：*（指针+偏移量）
如果指针是数组首元素地址(a或者&a[0])，那么偏移量就是下标；指针也可以不是首元素地址，而是其他哪个元素的地址，这时候偏移量就要考虑重叠了。
（4）数组下标方式和指针方式均可以访问数组元素，两者实际是一样的。在编译器内部都是用指针方式来访问数组元素的，数组下标方式只是编译器给编程者一种壳（语法糖）而已。

int a[5] = {1,2,3,4,5];
printf("a[3] = %d.\",a[3]);
printf("*（a+3）= %d.\n",*(a+3));
// int b = *(a+3);
int *p;
p = a;
printf("*(p+3) = %d.\n",*(p+3));
p = &a[2];
printf("*(p+3) = %d.\n",*(p+1));

2、从内存角度理解指针访问数组
（1）数组的特点：

数组各各元素的地址是依次连接的
数组的类型都是相同的
注：数组中的元素其实就是地址相连，占地大小相同的一串内存空间

3、指针和数组类型匹配问题
（1）“ * ”和“ &a ”是整个数组指针，也就是一个数组指针类型，不是int指针类型，所以不匹配

int *p; int a[5];  p = a;   //类型匹配
int *p; int a[6];  p = &a;  //类型不匹配。p是int

（2）&a、a、&a[0]从数值上来看是完全相等的，但是意义来看就不同了，a和&a[0]是数组首元素首地址，而&a是整个数组的首地址；从类型上来看，a和&a[0]是元素的指针，也就是int 类型；而&a是数组指针，是int （）[5];类型。
4、指针类型决定了指针如何参与运算
(1)指针参与运算时，因为指针变量本身存储的数值是表示地址的，所以运算也是地址的运算。
(2)指针参与运算的特点是，指针变量+1，并不是真的加1，而是加1*sizeof(指针类型)；如果是int *指针，则+1就实际表示地址+4，如果是char *指针，则+1就表示地址+1；如果是double *指针，则+1就表示地址+8.
(2)指针变量+1时实际不是加1而是加1×sizeof(指针类型)，主要原因是希望指针+1后刚好指向下一个元素

七、指针与强制类型转换

1、变量的数据类型的含义
(1)所有的类型的数据存储在内存中，都是按照二进制格式存储的。所以内存中只知道有0和1，不知道是不是int的还是float的还是其他的类型。
（2）int 、char、short等属于整形，他们的存储方式（数据转换成二进制往内存中存放的方式）是相同的，只是内存格子大小不同（所以这几种整形就彼此叫做二进制兼容格式）；而float和double的存储方式彼此不同，和整形更不同
（3）int a = 5；时，编译器给a分配4个字节的存储空间，并且将5按照int类型的存储方式转成二进制存储到a所对应的内存空间中去（a作为左值）；

int a = 5;
printf("a = %d.\n",a);
printf("a = %f.\n",a);
return 0;

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

int a = 5;
int *p1 = &a;
float *p;
p = (float *)p1;
p = &a;
printf("*p = %f.\n",*p);
printf("*p = %f.\n",*p);

*3、指针数据类型转换实例分析1（int * -> char ）
（1）int和char类型都是整形，类型兼容性的。所以互转的时候有时候对有时候错误。
（2）int和char类型的不同在于char只有1个字节，而int有4个字节，所有int的范围比char要大。
在char所表示的范围之内，互转是不会出错的；但是超过char范围后char转换int不会出错，但int转char会出错。

int a[2] = {0x11223344, 0x55667788};
int *p1 = a;
printf("*p1 = 0x%x\n",*p1);
char *p2 = (char *)a;
printf("*p2 = 0x%x\n",*p2);
printf("*p2 = 0x%x\n",*(p2+1));
printf("*p2 = 0x%x\n",*(p2+2));
printf("*p2 = 0x%x\n",*(p2+3));
printf("*p2 = 0x%x\n",*(p2+4));

4、指针数据类型转换实例分析2（int * -> float）*
(1)之前分析过：int和float的解析方式是不兼容的，所以int *转换成float *再去访问绝对会出错

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

（1）sizeof是C语言的一个运算符（主要sizeof不是函数。虽然用法很像函数），sizeof的作用是用来返回里面的变量或者数据类型所占用的内存字节数。
（2）sizeof存在的价值？主要是因为在不同平台下各个数据类型所占内存字节不尽相同（比如int在32位操作系统中为4个字节，在16位操作系统中为2个字节…）所以程序中需要使用sizeof来判断当前变量/数据类型占几个字节。

int main(void)
{
char str[] = "hello";
printf("sizeof(str) = %d.\n",sizeof(str));        //元素所占的字节数=6，多一个\0占一个字节
printf("sizeof(str[0]) = %d.\n",sizeof(str[0]));  //第0个元素，char类型，占一个字节
printf("strlen(str) = %d.\n",strlen(str));   //字符串长度 = 5

char *p = str;
printf("sizeof(str) = %d.\n",sizeof(p));       //指针变量p的长度  相当于sizeof（char *）=4 
printf("sizeof(str[0]) = %d.\n",sizeof(*p));   //指针p指向的变量的值  相当于sizeof（char）=1
printf("strlen(str) = %d.\n",strlen(p));       //相当于strlen（str）=5

int b[100] = {0};
printf("sizeof(b) = %d.\n",sizeof(b));   //100*sizeof(int)
}

1、char str[] = ”hello”; sizeof(str) sizeof(str[0]) strlen(str)
**2、char p=str; sizeof§ sizeof(p) strlen§
(1)32位系统中所有指针的长度都是4，不管是什么类型的指针。
(2)strlen是一个C库函数，用来返回一个字符串的长度（注意，字符串的长度是不计算字符串末尾的’\0’的）。一定要注意strlen接收的参数必须是一个字符串（字符串的特征是以’\0’结尾）
3、int n=10; sizeof(n)
(1)sizeof测试一个变量本身，和sizeof测试这个变量的类型，结果是一样的。
4、int b[100]; sizeof(b)
(1)sizeof(数组名)的时候，数组名不做左值也不做右值，纯粹就是数组名的含义。那么sizeof(数组名)实际返回的是整个数组所占用内存空间（以字节为单位的）。
5、 void fun(int b[100])
{
sizeof(b)
}
(1)函数传参，形参是可以用数组的
(2)函数形参是数组时，实际传递是不是整个数组，而是数组的首元素首地址。也就是说函数传参用数组来传，实际相当于传递的是指针（指针指向数组的首元素首地址）。
6、宏定义
#define dpChar char *
typedef char *tpChar;
dpChar p1, p2; sizeof(p1) sizeof(p2)
tpChar p3, p4; sizeof(p3) sizeof(p4)

9、指针与函数传参

1、普通变量作为函数形参
（1）函数传参时，普通变量作为参数时，形参和实参名字可以相同也可以不同，实际上都是用实参来代替相对应的形参的。
（2）在子函数内部，形参的值等于实参。原因是函数调用时把实参的值赋值给了形参。
（3）这就是书上写的“传值调用”（相当于实参作为右值，形参作为左值）
2、数组作为函数形参
（1）函数名作为形参传参时，实际传递是不是整个数组，而是数组的首元素的首地址（也就是整个数组的首地址。因为传参时传值，所以这两个没有什么区别）。所以在子函数内部，传进来的数组名就等于是一个数组的首元素首地址的指针。所以sizeof得到的都是4
3、指针作为函数形参
和数组作为函数形参是一样的，这就好像指针方式访问数组元素和数组方式访问数值元素的结果一样。
4、结构体变量作为函数形参
(1)结构体变量作为函数形参的时候，实际上和普通变量（类似于int之类的）传参时表现是一模一样的。所以说结构体变量其实也是普通变量而已。
(2)因为结构体一般都很大，所以如果直接用结构体变量进行传参，那么函数调用效率就会很低。（因为在函数传参的时候需要将实参赋值给形参，所以当传参的变量越大调用效率就会越低）。怎么解决？思路只有一个那就是不要传变量了，改传变量的指针（地址）进去。
(3)结构体因为自身太大，所以传参应该用指针来传（但是程序员可以自己决定，你非要传结构体变量过去C语言也是允许的，只是效率低了）；回想一下数组，为什么C语言设计的时候数组传参默认是传的数组首元素首地址而不是整个数组？
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语言本身函数调用时一直是传值的，只不过传的值可以是变量名，也可以是变量的指针。

void swap1(int a,int b )
	{
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
	printf("in swap1,a = %d,b = %d.\n",a,b);
	}
void swap2(int *a,int *b )
	{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
	printf("in swap1,*a = %d,*b = %d.\n",*a,*b);
	}
int main(void)
	{
	 int x =3, y = 5;
	 swap1(x,y);
	 printf("x = %d, y = %d.\n",x,y);
	}

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

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

int main(void)
{
//程序要完成功能是：对一个函数乘以5
//第一种方法：函数传参
int a = 3；
int b;
b = multip5(a);
printf("result = %d.\n",b);
//第二种方法：用全局变量来传参
x = 2;
multip5_2();
printf("y = %d.\n",y)

return 0;
}

2、函数传参中使用const指针
(1)const一般用在函数参数列表中，用法是const int *p;（意义是指针变量p本身可变的，而p所指向的变量是不可变的）。
(2)const用来修饰指针做函数传参，作用就在于声明在函数内部不会改变这个指针所指向的内容，所以给该函数传一个不可改变的指针（char *p = “linux”;这种）不会触发错误；而一个未声明为const的指针的函数，你给他传一个不可更改的指针的时候就要小心了。
3、函数需要向外部返回多个值时怎么办？
(1)一般来说，函数的收入部分就是函数参数，输出部分就是返回值。问题是函数的参数可以有很多个，而返回值只能有1个。这就造成我们无法让一个函数返回多个值。
(2)现实编程中，一个函数需要返回多个值是非常普遍的，因此完全依赖于返回值是不靠谱的，通常的做法是用参数来做返回（在典型的linux风格函数中，返回值是不用来返回结果的，而是用来返回0或者负数用来表示程序执行结果是对还是错，是成功还是失败）。
(3)普遍做法，编程中函数的输入和输出都是靠函数参数的，返回值只是用来表示函数执行的结果是对（成功）还是错（失败）。如果这个参数是用来做输入的，就叫输入型参数；如果这个参数的目的是用来做输出的，就叫输出型参数。
(4)输出型参数就是用来让函数内部把数据输出到函数外部的。
4、总结
看到一个函数的原型后，怎么样一眼看出来哪个参数做输入哪个做输出？函数传参如果传的是普通变量（不是指针）那肯定是输入型参数；如果传指针就有2种可能性了，为了区别，经常的做法是：如果这个参数是做输入的（通常做输入的在函数内部只需要读取这个参数而不会需要更改它）就在指针前面加const来修饰；如果函数形参是指针变量并且还没加const，那么就表示这个参数是用来做输出型参数的。
譬如C库函数中strcpy函数

来源：CSDN

作者：weixin_29547033

链接：https://blog.csdn.net/weixin_29547033/article/details/104229853

标签

sizeof