C语言指针入门学习面面观
这似乎是一个很凝重的话题，但是它真的很有趣。
1.指针是指向某一类型的东西，任何一个整体，只要能称为整体就能拥有它自己的独一无二的指针类型，所以指针的类型其实是近似无穷无尽的
2.函数名在表达式中总是以函数指针的身份呈现，除了取地址运算符以及sizeof
3.C语言最晦涩难明的就是它复杂的声明:void(*signal(intsig,void(*func)(int)))(int),试试着把它改写成容易理解的形式
4.对于指针，尽最大的限度使用const保护它，无论是传递给函数，还是自己使用
先来看看一个特殊的指针，姑且称它为指针，因为它依赖于环境:NULL，是一个神奇的东西。先附上定义，在编译器中会有两种NULL(每种环境都有唯一确定的NULL):
#defineNULL0 #defineNULL((void*)0)
有什么区别吗？看起来没什么区别都是0，只不过一个是常量，一个是地址为0的指针。
当它们都作为指针的值时并不会报错或者警告，即编译器或者说C标准认为这是合法的:
int*temp_int_1=0;//无警告 int*temp_int_2=(void*)0;//无警告 int*temp_int_3=10;//出现警告
为什么？为什么0可以赋值给指针，但是10却不行？他们都是常量。
因为C语言规定当处理上下文的编译器发现常量0出现在指针赋值的语句中，它就作为指针使用，似乎很扯淡，可是却是如此。
回到最开始，对于NULL的两种情况，会有什么区别？拿字符串来说，实际上我是将字符数组看作是C风格字符串。
在C语言中，字符数组是用来存储一连串有意义的字符，默认在这些字符的结尾添加'\0'，好这里又出现了一个0值。
对于某些人，在使用字符数组的时候总是分不清楚NULL与'\0'的区别而误用，在字符数组的末尾使用NULL是绝对错误的！虽然它们的本质都是常量0，但由于位置不同所以含义也不同。
开胃菜已过
对于一个函数，我们进行参数传递，参数有两种形式:形参与实参
intfunction(intvalue)
{
/*...*/
}
//...
function(11);
其中，value是形参，11是实参，我们知道场面上，C语言拥有两种传递方式:按值传递和按址传递，但是你是否有认真研究过？这里给出一个实质，其实C语言只有按值传递，所谓按址传递只不过是按值传递的一种假象。至于原因稍微一想便能明白。
对于形参和实参而言两个关系紧密，可以这么理解总是实参将自己的一份拷贝传递给形参，这样形参便能安全的使用实参的值，但也带给我们一些麻烦，最经典的交换两数
voidswap_v1(int*val_1,int*val_2)
{
inttemp=*val_1;
*val_1=*val_2;
*val_2=*val_1;
}
这就是所谓的按址传递，实际上只是将外部指针(实参)的值做一个拷贝，传递给形参val_1与val_2，实际上我们使用:
#defineSWAP_V2(a,b)(a+=b,b=a-b,a-=b)
#defineSWAP_V3(x,y){x^=y;y^=x;x^=y}
试一试是不是很神奇，而且省去了函数调用的时间，空间开销。上述两种写法的原理实质是一样的。
但是，动动脑筋想一想，这种写法真的没有瑕疵吗？如果输入的两个参数本就指向同一块内存，会发生什么？
...
inttest_1=10,test_2=100;
SWAP_V2(test_1,test_2);
printf("Nowthetest_1is%d,test_2is%d\n",test_1,test_2);
.../*恢复原值*/
SWAP_V2(test_1,test_1);
printf("Nowthetest_1is%d\n",test_1);
会输出什么？:
$:Nowthetest_1is100,test_2is10 $:Nowthetest_1is0
对，输出了0，为什么？稍微动动脑筋就能相通，那么对于后面的SWAP_V3亦是如此，所以在斟酌之下，解决方案应该尽可能短小精悍:
staticinlinevoidswap_final(int*val_1,int*val_2)
{
if(val_1==val_2)
return;
*val_1^=*val_2;
*val_2^=*val_1;
*val_1^=*val_2;
}
#defineSWAP(x,y)\
do{\
if(&x==&y)\
break;\
x^=y;\
y^=x;\
x^=y;\
}while(0)
这便是目前能找到最好的交换函数，我们在此基础上可以考虑的更深远一些，如何让这个交换函数更加通用？即适用范围更大？暂不考虑浮点类型。提示：可用void*
与上面的情况类似，偶尔的不经意就会造成严重的后果:
intcombine_1(int*dest,int*add)
{
*dest+=*add;
*dest+=*add;
return*dest;
}
intcombine_2(int*dest,int*add)
{
*dest=2*(*add);//在不确定优先级时用括号是一个明智的选择
return*dest;
}
上述两个函数的功能一样吗？恩看起来是一样的
inttest_3=10,test_4=100;
combine_1(&test_3,&test_4);
printf("Aftercombine_1,test_3=%d\n",test_3);
.../*恢复原值*/
combine_2(&test_3,&test_4);
printf("Aftercombine_2,test_3=%d\n",test_3);
输出
$:Aftercombine_1,test_3=210 $:Aftercombine_2,test_3=210
如果传入两个同一对象呢？
.../*恢复test_3原值*/
combine_1(&test_3,&test_3);
printf("Aftersecondtimescombine_1,test_3=%d\n",test_3);
...
combine_2(&test_3,&test_3);
printf("Aftersecondtimescombine_2,test_3=%d\n",test_3);
输出
$:Aftersecondtimescombine_1,test_3=30 $:Aftersecondtimescombine_2,test_3=20
知道真相总是令人吃惊，指针也是那么令人又爱又恨。
C99标准之后出现了一个新的关键字，restrict，被用于修饰指针，它并没有太多的显式作用，甚至加与不加，在你自己看来，效果毫无区别。但是反观标准库的代码中，许多地方都使用了该关键字，这是为何
- 首先这个关键字是写给编译器看的
- 其次这个关键字的作用在于辅助编译器更好的优化该程序
- 最后，如果不熟悉，绝对不要乱用这个关键字。
关于数组的那些事
数组和指针一样吗？
不一样
要时刻记住，数组与指针是不同的东西。但是为什么下面代码是正确的？
intarr[10]={10,9,8,7};
int*parr=arr;
我们还是那句话，结合上下文，编译器推出arr处于赋值操作符的右侧，默默的将他转换为对应类型的指针，而我们在使用arr时也总是将其当成是指向该数组内存块首位的指针。
//intfunction2(constinttest_arr[10]
//intfunction2(constinttest_arr[])考虑这三种写法是否一样
intfunction2(constint*test_arr)
{
returnsizeof(test_arr);
}
...
intsize_out=sizeof(arr);
intsize_in=function2(arr);
printf("size_out=%d,size_in=%d\n",size_out,size_in);
输出:
size_out=40,size_in=8
这就是为什么数组与指针不同的原因所在，在外部即定义数组的代码块中，编译器通过上下文发觉此处arr是一个数组，而arr代表的是一个指向10个int类型的数组的指针，只所谓最开始的代码是正确的，只是因为这种用法比较多，就成了标准的一部分。就像世上本没有路，走的多了就成了路。"正确"的该怎么写
int(*p)[10]=&arr;
此时p的类型就是一个指向含有10个元素的数组的指针,此时(*p)[0]产生的效果是arr[0]，也就是parr[0]，但是(*p)呢？这里不记录，结果是会溢出，为什么？
这就是数组与指针的区别与联系，但是既然我们可以使用像parr这样的指针，又为什么要写成int(*p)[10]这样丑陋不堪的模式呢？原因如下:
回到最开始说过的传递方式，按值传递在传递arr时只是纯粹的将其值进行传递，而丢失了上下文的它只是一个普通指针，只不过我们程序员知道它指向了一块有意义的内存的起始位置，我想要将数组的信息一起传递，除了额外增加一个参数用来记录数组的长度以外，也可以使用这个方法，传递一个指向数组的指针这样我们就能只传递一个参数而保留所有信息。但这么做的也有限制:对于不同大小，或者不同存储类型的数组而言，它们的类型也有所不同
intarr_2[5]; int(*p_2)[5]=&arr_2; floatarr_3[5]; float(*p_3)[5]=&arr_3;
如上所示，指向数组的指针必须明确指定数组的大小，数组存储类型，这就让指向数组的指针有了比较大的限制。
这种用法在多维数组中使用的比较多，但总体来说平常用的并不多，就我而言，更倾向于使用一维数组来表示多维数组，实际上诚如前面所述，C语言是一个非常简洁的语言，它没有太多的废话，就本质而言C语言并没有多维数组，因为内存是一种线性存在，即便是多维数组也是实现成一维数组的形式。
就多维数组在这里解释一下。所谓多维数组就是将若干个降一维的数组组合在一起，降一维的数组又由若干个更降一维的数组组合在一起，直到最低的一维数组，举个例子:
intdou_arr[5][3];
就这个二维数组而言，将5个每个为3个int类型的数组组合在一起，要想指向这个数组该怎么做？
int(*p)[3]=&dou_arr[0]; int(*dou_p)[5][3]=&dou_arr; int(*what_p)[3]=dou_arr;
实际上多维数组只是将多个降一维的数组组合在一起，令索引时比较直观而已。当真正理解了内存的使用，反而会觉得多维数组带给自己更多限制对于第三句的解释，当数组名出现在赋值号右侧时，它将是一个指针，类型则是指向该数组元素的类型，而对于一个多维数组来说，其元素类型则是其降一维数组，即指向该降一维数组的指针类型。这个解释有点绕，自己动手写一写就好很多。
对于某种形式下的操作，我们总是自然的将相似的行为结合在一起考虑。考虑如下代码:
int*arr_3[5]={1,2,3,4,5};
int*p_4=arr_3;
printf("%d==%d==%d?\n",arr_3[2],*(p_4+2),*(arr_3+2));
输出:3==3==3?实际上对于数组与指针而言，[]操作在大多数情况下都能有相同的结果，对于指针而言*(p_4+2)相当于p_4[2]，也就是说[]便是指针运算的语法糖，有意思的是2[p_4]也相当于p_4[2]，"Iamastring"[2]=='m'，但这只是娱乐而已，实际中请不要这么做，除非是代码混乱大赛或者某些特殊用途。在此处，应该声明的是这几种写法的执行效率完全一致，并不存在一个指针运算便快于[]运算，这些说法都是上个世纪的说法了，随着时代的发展，我们应该更加注重代码整洁之道
在此处还有一种奇异又实用的技巧，在char数组中使用指针运算进行操作，提取不同类型的数据，或者是在不同类型数组中，使用char*指针抽取其中内容，才是显示指针运算的用途。但在使用不同类型指针操作内存块的时候需要注意，不要操作无意义的区域或者越界操作。
实际上，最简单的安全研究之一，便是利用溢出进行攻击。
Advance:对于一个函数中的某个数组的增长方向，总是向着返回地址的，中间可能隔着许多其他自动变量，我们只需要一直进行溢出试验，直到某一次，该函数无法正常返回了！那就证明我们找到了该函数的返回地址存储地区，这时候我们可以进行一些操作，例如将我们想要的返回地址覆盖掉原先的返回地址，这就是所谓的溢出攻击中的一种。
内存的使用的那些事儿
你一直以为你操作的是真实物理内存，实际上并不是，你操作的只是操作系统为你分配的资格虚拟地址，但这并不意味着我们可以无限使用内存，那内存卖那么贵干嘛，实际上存储数据的还是物理内存，只不过在操作系统这个中介的介入情况下，不同程序窗口(可以是相同程序)可以共享使用同一块内存区域，一旦某个傻大个程序的使用让物理内存不足了，我们就会把某些没用到的数据写到你的硬盘上去，之后再使用时，从硬盘读回。这个特性会导致什么呢？假设你在Windows上使用了多窗口，打开了两个相同的程序:
...
intstay_here;
chartran_to_int[100];
printf("Address:%p\n",&stay_here);
fgets(tran_to_int,sizeof(tran_to_int),stdin);
sscanf(tran_to_int,"%d",&stay_here);
for(;;)
{
printf("%d\n",stay_here);
getchar();
++stay_here;
}
...
对此程序(引用前桥和弥的例子)，每敲击一次回车，值加1。当你同时打开两个该程序时，你会发现，两个程序的stay_here都是在同一个地址，但对它进行分别操作时，产生的结果是独立的！这在某一方面验证了虚拟地址的合理性。虚拟地址的意义就在于，即使一个程序出现了错误，导致所在内存完蛋了，也不会影响到其他进程。对于程序中部的两个读取语句，是一种理解C语言输入流本质的好例子，建议查询用法，这里稍微解释一下:
通俗地说，fgets将输入流中由调用起，stdin输入的东西存入起始地址为tran_to_int的地方，并且最多读取sizeof(tran_to_int)个，并在后方sscanf函数中将刚才读入的数据按照%d的格式存入stay_here，这就是C语言一直在强调的流概念的意义所在，这两个语句组合看起来也就是读取一个数据这么简单，但是我们要知道一个问题，一个关于scanf的问题
scanf("%d",&stay_here);
这个语句将会读取键盘输入，直到回车之前的所有数据，什么意思？就是回车会留在输入流中，被下一个输入读取或者丢弃。这就有可能会影响我们的程序，产生意料之外的结果。而使用上当两句组合则不会。
函数与函数指针的那些事
事实上，函数名出现在赋值符号右边就代表着函数的地址
intfunction(intargc){/*...*/
}
...
int(*p_fun)(int)=function;
int(*p_fuc)(int)=&function;//和上一句意义一致
上述代码即声明并初始化了函数指针，p_fun的类型是指向一个返回值是int类型，参数是int类型的函数的指针
p_fun(11); (*p_fun)(11); function(11);
上述三个代码的意义也相同，同样我们也能使用函数指针数组这个概念
int(*p_func_arr[])(int)={func1,func2,};
其中func1,func2都是返回值为int参数为int的函数，接着我们能像数组索引一样使用这个函数了。
Tips:我们总是忽略函数声明，这并不是什么好事。
在C语言中，因为编译器并不会对有没有函数声明过分深究，甚至还会放纵，当然这并不包含内联函数(inline)，因为它本身就只在本文件可用。
比如，当我们在某个地方调用了一个函数，但是并没有声明它：
CallWithoutDeclare(100);//参数100为int型
那么，C编译器就会推测，这个使用了int型参数的函数，一定是有一个int型的参数列表，一旦函数定义中的参数列表与之不符合，将会导致参数信息传递错误(编译器永远坚信自己是对的！)，我们知道C语言是强类型语言，一旦类型不正确，会导致许多意想不到的结果(往往是Bug)发生。
对函数指针的调用同样如此
C语言中malloc的那些事儿
我们常常见到这种写法:
int*pointer=(int*)malloc(sizeof(int));
这有什么奇怪的吗？看下面这个例子:
int*pointer_2=malloc(sizeof(int));
哪个写法是正确的？两个都正确，这是为什么呢，这又要追求到远古C语言时期，在那个时候，void*这个类型还没有出现的时候，malloc返回的是char*的类型，于是那时的程序员在调用这个函数时总要加上强制类型转换，才能正确使用这个函数，但是在标准C出现之后，这个问题不再拥有，由于任何类型的指针都能与void*互相转换，并且C标准中并不赞同在不必要的地方使用强制类型转换，故而C语言中比较正统的写法是第二种。
题外话:C++中的指针转换需要使用强制类型转换，而不能像第二种例子，但是C++中有一种更好的内存分配方法，所以这个问题也不再是问题。
Tips:
C语言的三个函数malloc,calloc,realloc都是拥有很大风险的函数，在使用的时候务必记得对他们的结果进行校验，最好的办法还是对他们进行再包装，可以选择宏包装，也可以选择函数包装。
realloc函数是最为人诟病的一个函数，因为它的职能过于宽广，既能分配空间，也能释放空间，虽然看起来是一个好函数，但是有可能在不经意间会帮我们做一些意料之外的事情，例如多次释放空间。正确的做法就是，应该使用再包装阉割它的功能，使他只能进行扩展或者缩小堆内存块大小。
指针与结构体
typedefstructtag{
intvalue;
longvari_store[1];
}vari_struct;
乍一看，似乎是一个很中规中矩的结构体
... vari_structvari_1; vari_struct*vari_p_1=&vari_1; vari_struct*vari_p_2=malloc(sizeof(vari_struct))(
似乎都是这么用的，但总有那么一些人想出了一些奇怪的用法
intwhat_spa_want=10; vari_struct*vari_p_3=malloc(sizeof(vari_struct)+sizeof(long)*what_spa_want);
这么做是什么意思呢？这叫做可变长结构体，即便我们超出了结构体范围，只要在分配空间内，就不算越界。what_spa_want解释为你需要多大的空间，即在一个结构体大小之外还需要多少的空间，空间用来存储long类型，由于分配的内存是连续的，故可以直接使用数组vari_store直接索引。而且由于C语言中，编译器并不对数组做越界检查，故对于一个有N个数的数组arr，表达式&arr[N]是被标准允许的行为，但是要记住arr[N]却是非法的。这种用法并非是娱乐，而是成为了标准(C99)的一部分，运用到了实际中
对于内存的理解
在内存分配的过程中，我们使用malloc进行分配，用free进行释放，但这是我们理解中的分配与释放吗？在调用malloc时，该函数或使用brk()或使用nmap()向操作系统申请一片内存，在使用时分配给需要的地方，与之对应的是free，与我们硬盘删除东西一样，实际上:
int*value=malloc(sizeof(int)*5);
...
free(value);
printf("%d\n",value[0]);
代码中，为什么在free之后，我又继续使用这个内存呢？因为free只是将该内存标记上释放的标记，示意分配内存的函数，我可以使用，但并没有破坏当前内存中的内容，直到有操作对它进行写入。这便引申出几个问题:
Bug更加难以发现，让我们假设，如果我们有两个指针p1,p2指向同一个内存，如果我们对其中某一个指针使用了free(p1);操作，却忘记了还有另一个指针指向它，那这就会导致很严重的安全隐患，而且这个隐患十分难以发现，原因在于这个Bug并不会在当时显露出来，而是有可能在未来的某个时刻，不经意的让你的程序崩溃。
有可能会让某些问题更加简化，例如释放一个条条相连的链表域。
总的来说，还是那句话C语言是一把双刃剑。