1、指针作为函数参数传递
这几天在学习C过程中，在使用指针作为函数参数传递的时候出现了问题，根本不知道从何得解:源代码如下:
createNode(BinNode *tree,char *p)
{
tree = (BinNode *) malloc(sizeof(BinNode));
tree->data = *p;
}
该代码段的意图是通过一个函数创建一个二叉树的节点，然而在，调用该函数后，试图访问该节点结构体的成员时候，却发生了内存访问错误，到底问题出在哪儿呢？
一直不明白指针作为函数参数传值的机制，翻开林锐的《高质量C/C++编程指南》，找到了答案。
[如果函数的参数是一个指针，不要指望用该指针去申请动态内存]
原来问题出在C编译器原理上:编译器总是要为函数的每个参数制作临时副本，指针参数tree的副本是
_tree，编译器使 _tree = tree。如果函数体内的程序修改了_tree的内容，就导致参数tree的内容作相应的修改。这就是指针可以用作输出参数的原因。
即上面的函数代码经过编译后成为：
createNode(BinNode *tree,char *p)
{
BinNode *_tree;
_tree = tree;
_tree = (BinNode *) malloc(sizeof(BinNode));
_tree->data = *p;
}
如果没有
_tree = (BinNode *) malloc(sizeof(BinNode));
这个语句，在函数体内修改了_tree的内容，将会导致参数tree的内容作相应的修改，因为它们指向相同的内存地址。而
_tree = (BinNode *) malloc(sizeof(BinNode));
这个句，系统重新分配内存给_tree指针，_tree指针指向了系统分配的新地址，函数体内修改的只是_tree的内容，对原tree所指的地址的内容没有任何影响。因此，函数的参数是一个指针时，不要在函数体内部改变指针所指的地址，那样毫无作用，需要修改的只能是指针所指向的内容。即应当把指针当作常量。
如果非要使用函数指针来申请内存空间，那么需要使用指向指针的指针
createNode(BinNode **tree,char *p)
{
*tree = (BinNode *) malloc(sizeof(BinNode));
}
上面的是林锐的说法，目前来说不知道怎么去理解，不过可以有另外的方案，通过函数返回值传递动态内存:
BinNode *createNode()
{
BinNode *tree;
tree = (BinNode *) malloc(sizeof(BinNode));
return tree;
}
这个倒还说得过去，因为函数返回的是一个地址的值，该地址就是申请的内存块首地址。但是，这个容易和另外的一个忠告相混绕
[不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡]
（注意：实际上没有混淆，因为这里tree是在“堆内”分配的内存，而非在“栈”上。）
所谓一份拷贝,就是在函数调用时,将参数入栈,我们对形参的任何修改都是修改到
栈上的个拷贝,并不影响我们的实际参数.
任何编程语言的参数传递实际上都是在做传值调用.
所谓的传指针,就是把指针指向者的地址(一个值)传进函数.
也就是那个地址被压栈.
然后我们再通过这个地址进行操作,因为实参和形参同样都是一个地址的值.
所以改变形参指向者的状态时,实参指针也能看到这种变化.
这里区分一下静态内存，栈内存和动态分配的内存(堆内存)的区别:
（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
（2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
（3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
因此，试图返回一个栈上分配的内存将会引发未知错误
char *GetString(void)
{
char p[] = "hello world";
return p; //
编译器将提出警告
}
p是在栈上分配的内存，函数结束后将会自动释放，p指向的内存区域内容不是"hello world",而是未知的内容。
如果是返回静态存储的内存呢:
char *GetString(void)
{
char *p = "hello world";
return p;
}
这里“hello world”是常量字符串，位于静态存储区，它在程序生命期内恒定不变。无论什么时候调用GetString，它返回的始终是同一个“只读”的内存块。
[参考：林锐《高质量C/C++编程指南》]
[cpp]view plaincopyprint?
1.
<SPAN style="FONT-SIZE: 18px">#include<iostream>//指向指针的指针
2.
using namespace std;
3.
void GetMemory(char * &p,int num){
4.
p=(char *)malloc(sizeof(char)*num);
5.
}
6.
void main(void){
7.
char *str=NULL;
8.
GetMemory(str,100);
9.
strcpy(str,"hello");
10.
cout<<str<<endl;
11.
free(str);
12.
}</SPAN>
[cpp]view plaincopyprint?
1.
<SPAN style="FONT-SIZE: 18px">#include<iostream>//指向指针的指针
2.
using namespace std;
3.
void GetMemory(char * &p,int num){
4.
p=(char *)malloc(sizeof(char)*num);
5.
}
6.
void main(void){
7.
char *str=NULL;
8.
GetMemory(str,100);
9.
strcpy(str,"hello");
10.
cout<<str<<endl;
11.
free(str);
12.
}</SPAN>
#include<iostream>//指向指针的指针
using namespace std;
void GetMemory(char * &p,int num){
p=(char *)malloc(sizeof(char)*num);
}
void main(void){
char *str=NULL;
GetMemory(str,100);
strcpy(str,"hello");
cout<<str<<endl;
free(str);
}
或者：
#include<iostream>
[cpp]view plaincopyprint?
1.
<SPAN style="FONT-SIZE: 18px">using namespace std;
2.
void GetMemory(char * *p,int num){
3.
*p=(char *)malloc(sizeof(char)*num);
4.
}
5.
void main(void){
6.
char *str=NULL;
7.
GetMemory(&str,100);
8.
strcpy(str,"hello");
9.
cout<<str<<endl;
10.
free(str);
11.
}</SPAN>
[cpp]view plaincopyprint?
1.
<SPAN style="FONT-SIZE: 18px">using namespace std;
2.
void GetMemory(char * *p,int num){
3.
*p=(char *)malloc(sizeof(char)*num);
4.
}
5.
void main(void){
6.
char *str=NULL;
7.
GetMemory(&str,100);
8.
strcpy(str,"hello");
9.
cout<<str<<endl;
10.
free(str);
11.
}</SPAN>
using namespace std;
void GetMemory(char * *p,int num){
*p=(char *)malloc(sizeof(char)*num);
}
void main(void){
char *str=NULL;
GetMemory(&str,100);
strcpy(str,"hello");
cout<<str<<endl;
free(str);
}
以上都是正确的下面的例子是错误的：
[cpp]view plaincopyprint?
1.
<SPAN style="FONT-SIZE: 18px">#include<iostream>
2.
using namespace std;
3.
void GetMemory(char *p,int num){
4.
p=(char *)malloc(sizeof(char)*num);
5.
}
6.
void main(void){
7.
char *str=NULL;
8.
GetMemory(str,100);
9.
strcpy(str,"hello");
10.
cout<<str<<endl;
11.
free(str);
12.
}</SPAN>
[cpp]view plaincopyprint?
1.
<SPAN style="FONT-SIZE: 18px">#include<iostream>
2.
using namespace std;
3.
void GetMemory(char *p,int num){
4.
p=(char *)malloc(sizeof(char)*num);
5.
}
6.
void main(void){
7.
char *str=NULL;
8.
GetMemory(str,100);
9.
strcpy(str,"hello");
10.
cout<<str<<endl;
11.
free(str);
12.
}</SPAN> #include<iostream>using namespace std;void GetMemory(char *p,int num){
p=(char *)malloc(sizeof(char)*num);
}
void main(void){
char *str=NULL;
GetMemory(str,100);
strcpy(str,"hello");
cout<<str<<endl;
free(str);
}
试图用指针申请动态内存，错误的原因上面已经给出了详细的说明。总而言之，指针作为参数时，不能在函数体中改变指针的内存地址，要不然，实参的拷贝（压入栈中）改变了，而实参没有改变，造成内存泄露并且还达不到预期的效果。上面正确的2个例子都是通过另一种方法绕开了这个问题，改变指针的内容，例如：用了指向指针的指针，给指针的内容改变了，使其变为新分配内存的首地址，从而达到了效果。
2、字符串和指针
字符串是一种特殊的数组，它的结尾元素为：’/0’
还要注意：当：char s[]=”abc”, char *p=s时：
S++是错误的，而p++是正确的。这一点与数组与指针的区别类似。
下面的定义是错误的：
Char s[6];
S=”abcde”; /*此步不对，但是可以用strcpy赋值*/
Strcpy(s,”abcde”);
注意：char s[]=”abc”与char s[]={‘a’,’b’,’c’}的区别
Sizeof strlen的区别：
头文件和库文件的区别
运行c语言的环境：？
早起听到窗外传来兰花草，不禁想起大学单片机课上做的电子音乐盒，思绪一下回到了大学时代…不经意间感到我已经不再年轻了。。。。
C库：通常的C语言程序都需要C库的支持
编译时需要C库，运行时还需要c库
C库通常与编译器配套
库函数在C库中实现
有些库函数需要调用操作系统所提供的系统调用，有些则由C库独立实现
C库通常是和编译器一起发布的
GLibc ——与Gcc配套的GNU C库
怎样寻找Glibc在linux系统中的位置，目录。
如何区分变量、函数的声明和定义：
声明没有地址，在编译器和连接器的角度来讲，声明是一个符号。而定义了一个变量、函数，就会给这个变量、函数分配地址
3、
3.1、指针作为函数的参数
参数的传递是值的传递，单向的（从实参到形参）。形参得到实参的值（一个地址），函数中可以通过形参调用该地址，从而可以改变该地址对应变量的值。但如果形参本身改变了，其值不会传给实参。
3.2、指针和数组
3.2．1、通过指针访问一维数组
定义数组 int a[5]
（1）a表示数组在内存中的首地址，也就是数组汇总第一个元素的地址，其值由系统在编译时确定，程序运行期间不能改变。
（2）数组的访问：a[0], a[1], a[2], a[3], a[4]
或者是*(a+0)、*(a+1)、*(a+2)、 *(a+3)、 *(a+4)
（3）数组中的元素的地址表示为：&a[0]
、&a[1]、 &a[2]、 &a[3]、 &a[4]；或者是：a、a+1、a+2、a+3、a+4。
（4）定义指针int *s，令s=a，相当于：s=&a[0]，我们就可以用指针s来访问数组了。
Eg: int a[3]={1,2,3};int *s=a;
正确的表达式有：s，*s，s++，*s++，*(s++),(*s)++;而a++、
*a++、*(a++)都是错误的，编译时提示：自增操作数必须是左值;
#include <stdio.h>
int main()
{
int a[3]={1,2,3};
int *s;
s=a;
*s++;
printf("%d\n",*s);
s++;
printf("%d\n",*s);
*(a++);
printf("%d\n",*a);
return 0;
}