关于变量、1/2级指针等形式的形参传递

在学习数据结构（二叉树的二叉链表）时遇到的一些问题，关于变量、一级指针、二级指针等形式的形参传递，这里做一简要总结。

其实说了那么多，最主要的只是想强调例11和例17，其中最直接的目的就是为了说明例17。但为了把问题说清楚，这里还是一步一步按照调试的思路写了下来。

后来总结了一下，主要有以下几点：

1. 若在main()中定义int类型变量val，则可以定义形参为一级指针形式的函数(如fun(int *dat))，通过调用函数fun(&val)来改变变量val的值。

2. 若在main()中定义int类型的一级指针变量*val，则可以在main()中初始化该指针，使其指向确定的int类型的变量或内存，例如"int a, *val = &a;"或者"int *val = (int *)malloc(sizeof(int));"都是可以的，在这之后便可以在函数fun(int *dat)中来操作(赋值)该指针变量了，调用形式为fun(val)。

(此时没有必要在fun中调用malloc函数使指针变量val指向新的内存，因为这根本就办不到，此时在fun中的malloc函数只会改变形参dat中的内容，而不会改变val中的内容。)

3. 若在main()中定义int类型的一级指针变量*val，但不想在main()中初始化该指针，而是想在其他的函数中初始化该指针，则应当定义形参为二级指针形式的函数(如fun(int **dat))，通过在fun函数中来初始化该指针变量(在fun中通过malloc函数初始化该指针变量)，调用形式为fun(&val)，在初始化完之后便可以操作(赋值)该变量了。

>>>1

void main()
{
int tmp;
printf("%d\n",tmp);
}

上述程序编译时会有警告，说是tmp没有被初始化。运行该程序后，不输出任何东西，且会弹出如下对话框。



>>>2

若在上述程序的printf("%d\n",tmp)前加一条语句：printf("%d\n",&tmp)，即如下，

void main()
{
int tmp;
printf("%d\n",&tmp);
printf("%d\n",tmp);
}

这时编译便不会报错，也不会有警告，运行时也不会弹出任何对话框，且会有输出，输出如下。



（对于1、2这两处，难道不奇怪吗？）

若将int tmp放在main()函数外部定义（全局变量），则情况又不同了。

>>>3

int tmp;
void main()
{
printf("%d\n",tmp);
}

对于上述程序，编译时无错无警告，运行也正常，运行结果如下。



>>>4

int tmp;
void main()
{
printf("%d\n",&tmp);
printf("%d\n",tmp);
}

对于上述程序，编译无错无警告，运行同样正常，运行结果如下。



（对比1、2、3、4，难道不神奇吗？）

>>>5

void main()
{
int *ptr;
printf("%d\n",ptr);
}

上述程序，编译时无错但有警告，警告指针ptr没有被初始化。运行不会输出任何东西，且会弹出如下对话框。



若将上述程序改为如下所示，则编译无错有警告，警告内容同上，运行也不会输出任何东西，且会弹出如上的对话框。

void main()
{
int *ptr;
printf("%d\n",*ptr);
}

>>>6

然而若将程序改为：

void main()
{
int *ptr;
printf("%d\n",&ptr);
printf("%d\n",ptr);
printf("%d\n",*ptr);
}

则编译无错无警告。运行时会有输出，但也会弹出对话框，如下所示。



显然这两个输出结果是main函数中的前两条语句的执行结果，当执行到第三条语句的时候，会弹出图中的对话框。

>>>7

若定义的是全局变量指针，如下，

int *ptr;
void main()
{
printf("%d\n",*ptr);
}

则编译无错无警告。但运行时不输出任何东西，且会弹出如下对话框。



然而若将上述程序改为：

int *ptr;
void main()
{
printf("%d\n",&ptr);
printf("%d\n",ptr);
printf("%d\n",*ptr);
}

则编译也无错无警告。运行时会有输出，但还会弹出对话框，如下图所示。



>>>8

void Test(int *n)
{
n = NULL;
n = (int *)malloc(sizeof(int));
*n = 100;
}
void main()
{
int *ptr;
Test(ptr);
printf("%d\n",&ptr);
printf("%d\n",ptr);
printf("%d\n",*ptr);
}

对于上述程序，编译无错有警告，警告指针变量ptr没有被初始化。运行时不输出任何结果，但会弹出如下图的对话框。



>>>9

void main()
{
int a;
int *ptr = &a;
printf("a = %d\n",a);
printf("&a = %d\n",&a);
printf("&ptr = %d\n",&ptr);
printf("ptr = %d\n",ptr);
printf("*ptr = %d\n",*ptr);
}

对于上述程序，编译时无错也无警告，运行有结果输出，且这次不会弹出对话框。



>>>10

若将第9个程序改为如下，则编译无错也无警告。

void Test(int *n)
{
printf("n = %d\n",n);
n = NULL;
n = (int *)malloc(sizeof(int));
printf("n = %d\n",n);
*n = 100;
}
void main()
{
int a;
int *ptr = &a;
Test(ptr);
printf("a = %d\n",a);
printf("&a = %d\n",&a);
printf("&ptr = %d\n",&ptr);
printf("ptr = %d\n",ptr);
printf("*ptr = %d\n",*ptr);
}

该程序运行结果如下。



若将该程序中Test()函数改变成如下形式，

void Test(int *n)
{
printf("n = %d\n",n);
//n = NULL;
//n = (int *)malloc(sizeof(int));
//printf("n = %d\n",n);
*n = 100;
}

则上述程序运行结果就不一样了，如下所示。



这说明Test(ptr)函数的确可以得到指针变量ptr中的内容(即变量a的地址)， 并见其传递给形参n。此时这个形参所指地址即是ptr所指地址，在函数Test()中可以向该形参所指地址赋值，但并不能改变该形参所指地址。而行参本身只是一个中间变量，它可以接收Test(ptr)函数传递过来的地址，在函数Test()中它也可以接受函数malloc()重新分配的内存的地址，显然Test(ptr)传递进来的地址和在Test()中malloc()分配的地址是两个不同的地址。

>>>11

综上所述，若在main()函数只定义指针变量，并不对其初始化(即不使其指向确定的存储空间)，而是想在函数Test()中对对该指针变量进行初始化，则应该将Test()函数的形参定义为二级指针，如下所示。若想在脑海中快速想象通过二级指针传递参数的指向问题，估计还得需要时间去悟吧，不过自己也能够在纸上借助画图来分析。

void Test(int **n)
{
printf("\n通过调用Test(&ptr)函数传递地址给形参n：\n");
//printf("**n = %d\n",**n);		//调用该语句时，运行时会弹出内存不能被读的对话框。
printf("*n = %d\n",*n);
printf("n = %d\n",n);
printf("&n = %d\n",&n);

*n = NULL;
*n = (int *)malloc(sizeof(int));

printf("\n在Test()函数中，通过malloc()函数分配地址给形参n：\n");
printf("**n = %d\n",**n);
printf("*n = %d\n",*n);
printf("n = %d\n",n);
printf("&n = %d\n",&n);

**n = 100;
}
void main()
{
int *ptr;
printf("指针变量ptr初始化之前\n");
printf("&ptr = %d\n",&ptr);
printf("ptr = %d\n",ptr);
Test(&ptr);
printf("\n指针变量ptr初始化之后\n");
printf("&ptr = %d\n",&ptr);
printf("ptr = %d\n",ptr);
printf("*ptr = %d\n",*ptr);
}

上述程序编译无错无警告，执行结果如下。



>>>12

void TestInt(int *n)
{
printf("&n = %d\n",&n);
printf("*n = %d\n",*n);
printf("n = %d\n",n);
*n = 100;
}
void main()
{
int a;
printf("%d\n",&a);
printf("%d\n",a);
TestInt(&a);
printf("%d\n",&a);
printf("%d\n",a);
}

上述程序编译无错无警告，运行结果如下。



上述程序是在main中定义变量a，但不对其赋初值，而是在函数TestInt()中对其赋初值。

>>>13

若12中的TestInt()函数的形参不是一级指针，而是二级指针，即将程序改成如下形式。这里的函数TestInt1()实际上类似例11中的Test()函数的转型。

例11中的Test()函数是调用main()中定义的指针，而TestInt1则是调用main()中定义的变量。

void TestInt1(int **n)
{
printf("&n = %d\n",&n);
//printf("*n = %d\n",**n);	//这条语句编译时不会有错，但运行时会提示有内存不能被读。
printf("*n = %d\n",*n);
printf("n = %d\n",n);
*n = 100;
printf("&n = %d\n",&n);
//printf("*n = %d\n",**n);	//这条语句编译时不会有错，但运行时会提示有内存不能被读。
printf("*n = %d\n",*n);
printf("n = %d\n",n);
}
void main()
{
int a;
printf("%d\n",&a);
printf("%d\n",a);
TestInt1(&a);
printf("%d\n",&a);
printf("%d\n",a);
}

上述程序编译无错但有3个警告，如下图所示。实际上不能够通过TestInt1(&a)这样来执行的，这里只是为了学习而实验的。



上述程序运行结果如下。



说明：虽然这时候函数也能够给变量a赋初值，但实际应用中最好不要这样用，因为TestInt1(int **n)的形参是二级指针，而TestInt1(&a)得到的实参&a是一级指针。

>>>14

typedef struct Node
{
int data;
struct Node *ptr;
}Sample,*SamplePtr;
void TestStruct(SamplePtr p)
{
p->data = 100;
p->ptr = (SamplePtr)malloc(sizeof(Sample));
}
void main()
{

Sample a;
TestStruct(&a);
printf("%d\n",a.data);
printf("%d\n",a.ptr);
}

上述程序编译无错无警告，运行结果如下。



>>>15

void TestStruct1(SamplePtr p)
{
//p = (SamplePtr)malloc(sizeof(Sample));
//p->data = 100;
//p->ptr = (SamplePtr)malloc(sizeof(Sample));
}
void main()
{
Sample *a;
TestStruct1(a);
//printf("%d\n",a->data);
//printf("%d\n",a->ptr);
}

上述程序编译有一个警告无错误，警告是说指针变量a没有被初始化，其运行结果无输出，且会弹出对话框，如下所示。



该程序啥也没干，说明指针变量a此时根本就不能够被函数TestStruct1()调用。

若在main中对变量a初始化（程序如下），使其指向正确的地址，则编译就无警告了，且运行也正确了。

void TestStruct1(SamplePtr p)
{
//p = (SamplePtr)malloc(sizeof(Sample));
//p->data = 100;
//p->ptr = (SamplePtr)malloc(sizeof(Sample));
}
void main()
{
Sample b, *a = &b;
//或者不定义变量b，而是通过函数malloc()为指针a赋初始值，即a = (SamplePtr)malloc(sizeof(Sample));
TestStruct1(a);
//printf("%d\n",a->data);
//printf("%d\n",a->ptr);
}

>>>16

在例15的基础上，将程序改为如下形式就对了。

typedef struct Node
{
int data;
struct Node *ptr;
}Sample,*SamplePtr;
void TestStruct1(SamplePtr p)
{
//p = (SamplePtr)malloc(sizeof(Sample));
p->data = 100;
p->ptr = (SamplePtr)malloc(sizeof(Sample));
}
void main()
{
Sample b, *a = &b;
TestStruct1(a);
printf("%d\n",a->data);
printf("%d\n",a->ptr);
printf("%d\n",b.data);
printf("%d\n",b.ptr);
}

上述程序编译无错无警告，运行结果如下。



说明：此时TestStruct1()函数中的malloc函数中的第一条语句“p = (SamplePtr)malloc(sizeof(Sample));”始终是被注释着的，因为如果在main中定了Sample类型的变量或者Sample类型的一级指针变量(定义成指针时当然要对其初始化，使其指向确定的地址，当然该地址要正确，像NULL这样的肯定不行)，此时变量有(或指向)确定的存储空间，在TestStruct1()函数中重新为其分配新的地址是不行的，语句“p = (SamplePtr)malloc(sizeof(Sample));”改变的只是形参p的内容，这个道理与例10相同
。

>>>17

若现在非要在main()中定义一级指针变量，而在函数中初始化该指针，则应当将函数的形参定义为二级指针。

typedef struct Node
{
int data;
struct Node *ptr;
}Sample,*SamplePtr;
void TestStruct1(SamplePtr *p)
{
*p = (SamplePtr)malloc(sizeof(Sample));
(*p)->data = 100;
(*p)->ptr = (SamplePtr)malloc(sizeof(Sample));
}
void main()
{
Sample *a;
TestStruct1(&a);
printf("%d\n",a->data);
printf("%d\n",a->ptr);
}

上述程序编译无错无警告，运行结果如下。