附加

[如果函数的参数是一个指针，不要指望用该指针去申请动态内存]
   
原来问题出在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语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡]

taylor：要正确的理解这句话，以前我的理解是不要返回在栈上分配的指针变量，这种理解是错误的。

正确的理解应该是：指针变量指向的内容在栈上是不行的，因为函数结束的时候，内容被销毁了。指针变量大部分时候都在栈上分配，但是里面的内容有的是在栈上分配的。例如：

    char *GetString(void)
    {
        char p[] = ｛1,2,3,4,5｝;
        return p; // 编译器将提出警告,因为函数结束的时候，数组里面的内容销毁了，p指向了一个随即的地址。如果将p改为在堆上分配就正确了。
    }

这里区分一下静态内存，栈内存和动态分配的内存(堆内存)的区别:
（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，它返回的始终是同一个“只读”的内存块。

总结：无论是值传递还是指针传递，传递的都是实参的值的一份拷贝副本，

如果是基本数据，拷贝的是数据的值，如果是指针，拷贝的是实参的值（值是一个地址）。

如果想改变实参的值，变量必须是指针。因而也就有上面例子中说的二级指针问题，其实很好理解。

如果把一个变量彻底的分析：

一个变量在内存中有2个部分的内容：

1，变量的地址

2，变量的值

一：对于普通变量如：int a = 3；

a的地址为0x11，值为3

如果传递a

add（3）

int add（int x）｛

  x = x+1；

｝

那么函数调用的时候，其实传递的是a的值3。

二：对于对象或者指针变量（其实对象就是一个引用或者指针），如：

char *str = “123”；

test（str）；

void test（char *a）

｛

a = “abc”；

｝

str的地址为0x11，其实也就是str的值为0x11，0x11地址里面的内容为“123”，str自身的内存为0x123，

参数拷贝的时候，其实是把str的值0x11拷贝一份给char＊a，也就是a的值为0x11，但是a本身的地址为0x126，

其实拷贝的也是str的值，只不过str的值是一个地址而已，str的内容为"123"。注意区别与平常所说的取值，

例如：char ＊ch = “xx”；ch表示地址，＊ch表示取值。平常说的ch地址不是我这里说的ch变量在内存中的地址，而是ch变量指向的地址，也就是ch变量在内存中的地址里面存放的值，这个值是一个地址。

因此所有的拷贝都是值拷贝，其实没有什么指针拷贝之类的，只不过值为指针而且，拷贝的是实参的值，而不是实参的地址。

其实以变量的属性来说，每个变量的地址在内存中都是唯一的，比如0x2000之类的，没有说变量的地址是可以拷贝的，因为每个变量的地址都是唯一的。

只有变量的值可以是重复的，可以拷贝的。但是值可以是地址。

所以函数参数传递，传递的都是实参变量的值。

"之所以产生所谓的引用传递，是因为所有对象变量的值只能是一个地址，不可能是一个基本的数据，例如4。所以传递对象就是传递一个地址，不可能说传递一个数值4之类的。  其实引用传递，就是传递的变量的值（这个值是一个地址）。"这句话只对Java中的对象有效，如果是c或者c++中，参数是结构体，或者对象本身的时候，是不同的，

比如在C语言中，函数的参数是结构体的话，如果传过去是结构体，是不能改变结构体里面的内容的值的，拷贝的是实参的值，也就是另一个结构体。

如果要改变结构的值，必须要传结构体的指针才能够改变。

c++˙中如果传的不是对象指针，而是对象本身，那么也是不能够改变对象的内容的，这是为什么呢？

因为操作的时候是操作的实参对象的一个副本，通过这个副本是无法访问实参对象的地址内容的，因此修改也只是修改了这个副本的内容，实参对象并没有被修改，只有当传入的是实参对象的地址的时候，操作的就是这个地址的副本，然后通过这个地址的副本是能过访问到实参对象的。