这一篇我们来看看没有返回，只靠形参、实参传递参数的函数，先来学习最简单的一种：
1、传值调用（赋值传递）
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 void swap(int a,int b) 6 { 7 int temp; 8 printf("交换前，a=%d b=%d ",a,b); 9 temp=a; 10 a=b; 11 b=temp; 12 printf("交换后，a=%d b=%d ",a,b); 13 } 14 int main() 15 { 16 int x=10,y=20; 17 printf("交换前，x=%d y=%d ",x,y); 18 swap(x,y); 19 printf("交换后，x=%d y=%d ",x,y); 20 return 0; 21 }
从运行程序结果可以看出：被调函数swap只对形参操作，实参无变化。显然，传值调用属于单向值传递，函数运行结果不影响、不改变调用函数的实参。
看过了最简单的，下面来看看复杂一点儿的————引用调用（指针传递、赋地址传递）。C语言中，这个词也被叫做“指针传递”、“赋地址传递”。在C++语言中，则有另外的含义了。用起来，也会方便许多，但是，C语言不支持。引用调用（指针传递、赋地址传递）分为同级指针传递，和二级指针传递2种方式。同时，根据主调函数是否申请内存，又分两种情况来分析。下面先来看：
2、主调函数申请内存条件下，同级指针传递：
2.1 主调函数申请内存，同级指针传递（传递变量地址）
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 void swap(int * a,int *b) 6 { 7 int temp; 8 printf("a地址：%p b地址:%p ",a,b); 9 printf("交换前，a=%d b=%d ",*a,*b); 10 temp=*a; 11 *a=*b; 12 *b=temp; 13 printf("交换后，a=%d b=%d ",*a,*b); 14 } 15 int main() 16 { 17 int x=10,y=20; 18 printf("x地址：%p y地址:%p ",&x,&y); 19 printf("交换前，x=%d y=%d ",x,y); 20 swap(&x,&y); 21 printf("交换后，x=%d y=%d ",x,y); 22 return 0; 23 }
本例中，main主函数申请了2个变量——x和y，并把它们的地址——&x和&y传递给被调函数swap，被调函数的形参定义了2个指针变量int *a,int *b来接收。由于a，b，&x，&y都是地址，相当于a=&x,b=&y。
如果把&x和&y也看成指针，则有*a=*(&x)=x，*b=*(&y)=y。显然，对其解引用后，所得值为变量的值，而不是地址。所以称之为同级指针传递（因为a，b和&x，&y都是只需一次解引用操作即可求得变量的值，我认为称之为“一级指针传递”更为贴切）。
从程序运行结果来看，被调函数修改了实参的值。所以，我们能得出结论：主调函数申请内存，同级指针传递实参变量地址，被调函数能够修改实参的值。
下面我们来看看堆和栈上字符串地址的传递：
2.2 主调函数申请内存，同级指针传递（传递堆上、栈上字符串地址）
1 void func(char* p) 2 { 3 strcpy(p, "Hello,World!"); 4 } 5 void test01() 6 { 7 //分配到栈上 8 char buf[1024] ="I like C语言!"; 9 printf("栈上初始字符串：%s ", buf); 10 func(buf); 11 printf("主调函数申请内存，同级指针传递，栈上字符串返回：%s ", buf); 12 } 13 14 void printString(char* str) 15 { 16 strcpy(str, "Hello,World!"); 17 printf("主调函数申请内存，同级指针传递，堆上字符串返回：%s ", str); 18 } 19 void test02() 20 { 21 //分配到堆区 22 char* p = malloc(sizeof(char) * 64); 23 memset(p, 0, 64); 24 strcpy(p, "I like C语言！"); 25 printf("堆上初始字符串：%s ", p); 26 printString(p); 27 printf("字符串长度=%d ", strlen(p)); 28 } 29 30 int main() 31 { 32 test01(); 33 test02(); 34 system("pause"); 35 return EXIT_SUCCESS;
}
这里，由于我们可以把字符串名“buf”和指针“p”看作地址，显然，这也是同级指针传递。并且，通过程序运行结果，我们可以得出结论：主调函数申请内存，同级指针传递字符串地址，被调函数能够对堆和栈上字符串进行赋值，修改操作。
下面再来看一段代码：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 void buildString(char* pp) 6 { 7 char* temp = "被调函数修改字符串"; 8 pp = temp; 9 printf("%s ", *pp); 10 } 11 void test01() 12 { 13 char* p = "主调函数定义初始字符串"; 14 printf("%s ", p); 15 buildString(p); 16 printf("%s ", p); 17 } 18 19 int main() 20 { 21 test01(); 22 return 0; 23 }
上面这段代码无法正常运行，再次证明了一个事实：以指针形式声明的字符串，保存在程序数据区，不能被改动。
通过上面3个例程，我们可以得出结论：主调函数申请内存，同级指针传递地址（无论是变量地址还是堆或者栈的地址）条件下，被调函数能够修改实参的值。当然，程序数据区的字符串依然不能修改！
2.3 在这里，我们提出一个问题：如果，在主调函数申请内存，二级指针传递地址（无论是变量地址还是堆或者栈的地址，甚至是程序数据区变量、常量地址）条件下，会发生什么那？也许，这将是我们下一篇随笔的命题！
3、被调函数申请内存，同级指针传递地址
3.1 被调函数申请内存，同级指针传递变量地址，这种情况不存在。或者说我不知道如何用C语言来就这种情况编程。
3.2 被调函数申请内存，同级指针传递字符串地址
1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 6 void getString01(char* pp) //传递数组地址 7 { 8 char sTring[] = "Hello,world!"; 9 printf("字符串数组地址是：%p ", sTring); 10 pp = sTring; 11 } 12 void test01() 13 { 14 char* p = NULL; 15 getString01(p); 16 printf("返回数组地址得到: %p, p=%s ", p, p); 17 } 18 19 void getString02(char* pp) //传递指针地址 20 { 21 char* pOint = "Hello,Kitty!"; 22 printf("字符串指针地址是：%p ", pOint); 23 pp = pOint; 24 } 25 void test02() 26 { 27 char* p = NULL; 28 getString02(p); 29 printf("返回指针地址得到：%p, p= %s ", p, p); 30 } 31 32 void getString03(char* pp) //传递堆地址 33 { 34 char* hEap = malloc(20 * sizeof(char)); 35 if (hEap == NULL) return; 36 memset(hEap, 0, 20 * sizeof(char)); 37 strcpy(hEap, "Hello,Miss!"); 38 pp = hEap; 39 printf("堆地址是： %p ", pp); 40 } 41 void test03() 42 { 43 char* p = NULL; 44 getString03(p); 45 printf("返回堆地址得到： %p, p=%s ", p, p); 46 } 47 int main(void) 48 { 49 test01(); //调用函数，得到输出：“传递同级指针得：(null)” 50 test02(); 51 test03(); 52 system("pause"); 53 return EXIT_SUCCESS; 54 }
运行上面例程，结论是： 被调函数无论是在堆上，还是在栈上，还是以指针形式在程序数据区申请内存，其对形参的定义都无法传递给实参。
3.3 被调函数申请内存，二级指针传递字符串地址
1 #define _CRT_SECURE_NO_WARNINGS 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 6 void getString01(char** pp) //传递数组地址 7 { 8 char sTring[] = "Hello,world!"; 9 printf("字符串数组地址是：%p ", sTring); 10 *pp = sTring; 11 } 12 void test01() 13 { 14 char* p = NULL; 15 getString01(&p); 16 printf("返回数组地址得到: %p, p=%s ", p, p); 17 } 18 19 void getString02(char** pp) //传递指针地址 20 { 21 char* pOint = "Hello,Kitty!"; 22 printf("字符串指针地址是：%p ", pOint); 23 *pp = pOint; 24 } 25 void test02() 26 { 27 char* p = NULL; 28 getString02(&p); 29 printf("返回指针地址得到：%p, p= %s ", p, p); 30 } 31 32 void getString03(char** pp) //传递堆地址 33 { 34 char* hEap = malloc(20 * sizeof(char)); 35 if (hEap == NULL) return; 36 memset(hEap, 0, 20 * sizeof(char)); 37 strcpy(hEap, "Hello,Miss!"); 38 *pp = hEap; 39 printf("堆地址是： %p ", pp); 40 } 41 void test03() 42 { 43 char* p = NULL; 44 getString03(&p); 45 printf("返回堆地址得到： %p, p=%s ", p, p); 46 } 47 int main(void) 48 { 49 test01(); //调用函数，得到输出：“传递同级指针得：(null)” 50 test02(); 51 test03(); 52 system("pause"); 53 return EXIT_SUCCESS; 54 }
运行上面例程，结论是： 被调函数在堆上，或者以指针形式在程序数据区申请内存，其对形参的定义都可以传递给实参。在栈上定义的字符串数组，由于栈上变量的生命周期的原因，无法正确传递给实参。