C语言函数间参数的传递方式（二）没有返回，仅仅靠形参、实参传递参数的函数

这一篇我们来看看没有返回，只靠形参、实参传递参数的函数，先来学习最简单的一种：

1、传值调用（赋值传递）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void swap(int a,int b)
{
    int temp;
    printf("交换前，a=%d  b=%d \n",a,b);
    temp=a;
    a=b;
    b=temp;
    printf("交换后，a=%d  b=%d \n",a,b);
}
int main()
{
    int x=10,y=20;
    printf("交换前，x=%d  y=%d \n",x,y);
    swap(x,y);
    printf("交换后，x=%d  y=%d \n",x,y);
    return 0;
}

从运行程序结果可以看出：被调函数swap只对形参操作，实参无变化。显然，传值调用属于单向值传递，函数运行结果不影响、不改变调用函数的实参。

看过了最简单的，下面来看看复杂一点儿的————引用调用（指针传递、赋地址传递）。C语言中，这个词也被叫做“指针传递”、“赋地址传递”。在C++语言中，则有另外的含义了。用起来，也会方便许多，但是，C语言不支持。引用调用（指针传递、赋地址传递）分为同级指针传递，和二级指针传递2种方式。同时，根据主调函数是否申请内存，又分两种情况来分析。下面先来看：

2、主调函数申请内存条件下，同级指针传递：

     2.1  主调函数申请内存，同级指针传递（传递变量地址）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void swap(int * a,int *b)
{
    int temp;
    printf("a地址：%p    b地址:%p    \n",a,b);
    printf("交换前，a=%d  b=%d \n",*a,*b);
    temp=*a;
    *a=*b;
    *b=temp;
    printf("交换后，a=%d  b=%d \n",*a,*b);
}
int main()
{
    int x=10,y=20;
    printf("x地址：%p    y地址:%p\n",&x,&y);
    printf("交换前，x=%d  y=%d \n",x,y);
    swap(&x,&y);
    printf("交换后，x=%d  y=%d \n",x,y);
    return 0;
}

本例中，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  主调函数申请内存，同级指针传递（传递堆上、栈上字符串地址）

void func(char* p)
{
    strcpy(p, "Hello,World!");
}
void test01()
{
    //分配到栈上
    char buf[1024] ="I like C语言!";
    printf("栈上初始字符串：%s \n", buf);
    func(buf);
    printf("主调函数申请内存，同级指针传递，栈上字符串返回：%s \n", buf);
}

void printString(char* str)
{
    strcpy(str, "Hello,World!");
    printf("主调函数申请内存，同级指针传递，堆上字符串返回：%s \n", str);
}
void test02()
{
    //分配到堆区
    char* p = malloc(sizeof(char) * 64);
    memset(p, 0, 64);    
    strcpy(p, "I like C语言！");
    printf("堆上初始字符串：%s \n", p);
    printString(p);
    printf("字符串长度=%d \n", strlen(p));
}

int main()
{
    test01();
    test02();
    system("pause");
    return EXIT_SUCCESS;
   }

这里，由于我们可以把字符串名“buf”和指针“p”看作地址，显然，这也是同级指针传递。并且，通过程序运行结果，我们可以得出结论：主调函数申请内存，同级指针传递字符串地址，被调函数能够对堆和栈上字符串进行赋值，修改操作。

 下面再来看一段代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void buildString(char* pp)
{
    char* temp = "被调函数修改字符串";
    pp = temp;
    printf("%s \n", *pp);
}
void test01()
{
    char* p = "主调函数定义初始字符串";
    printf("%s \n", p);
    buildString(p);
    printf("%s \n", p);
}

int main()
{
    test01();
    return 0;
}

上面这段代码无法正常运行，再次证明了一个事实：以指针形式声明的字符串，保存在程序数据区，不能被改动。

通过上面3个例程，我们可以得出结论：主调函数申请内存，同级指针传递地址（无论是变量地址还是堆或者栈的地址）条件下，被调函数能够修改实参的值。当然，程序数据区的字符串依然不能修改！

       2.3  在这里，我们提出一个问题：如果，在主调函数申请内存，二级指针传递地址（无论是变量地址还是堆或者栈的地址，甚至是程序数据区变量、常量地址）条件下，会发生什么那？也许，这将是我们下一篇随笔的命题！

 

3、被调函数申请内存，同级指针传递地址

     3.1  被调函数申请内存，同级指针传递变量地址，这种情况不存在。或者说我不知道如何用C语言来就这种情况编程。

     3.2  被调函数申请内存，同级指针传递字符串地址

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void getString01(char* pp)  //传递数组地址
{
    char sTring[] = "Hello,world!";
    printf("字符串数组地址是：%p \n", sTring);
    pp = sTring;
}
void test01()
{
    char* p = NULL;
    getString01(p);
    printf("返回数组地址得到: %p, p=%s \n\n", p, p);
}

void getString02(char* pp)  //传递指针地址
{
    char* pOint = "Hello,Kitty!";
    printf("字符串指针地址是：%p \n", pOint);
    pp = pOint;
}
void test02()
{
    char* p = NULL;
    getString02(p);
    printf("返回指针地址得到：%p, p= %s \n\n", p, p);
}

void getString03(char* pp)  //传递堆地址
{
    char* hEap = malloc(20 * sizeof(char));
    if (hEap == NULL) return;
    memset(hEap, 0, 20 * sizeof(char));
    strcpy(hEap, "Hello,Miss!");
    pp = hEap;
    printf("堆地址是：        %p \n", pp);
}
void test03()
{
    char* p = NULL;
    getString03(p);
    printf("返回堆地址得到：  %p, p=%s \n", p, p);
}
int main(void)
{
    test01();  //调用函数，得到输出：“传递同级指针得：(null)”
    test02();
    test03();
    system("pause");
    return EXIT_SUCCESS;
}

运行上面例程，结论是： 被调函数无论是在堆上，还是在栈上，还是以指针形式在程序数据区申请内存，其对形参的定义都无法传递给实参。

     3.3  被调函数申请内存，二级指针传递字符串地址

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void getString01(char** pp)  //传递数组地址
{
    char sTring[] = "Hello,world!";
    printf("字符串数组地址是：%p \n", sTring);
    *pp = sTring;
}
void test01()
{
    char* p = NULL;
    getString01(&p);
    printf("返回数组地址得到: %p, p=%s \n\n", p, p);
}

void getString02(char** pp)  //传递指针地址
{
    char* pOint = "Hello,Kitty!";
    printf("字符串指针地址是：%p \n", pOint);
    *pp = pOint;
}
void test02()
{
    char* p = NULL;
    getString02(&p);
    printf("返回指针地址得到：%p, p= %s \n\n", p, p);
}

void getString03(char** pp)  //传递堆地址
{
    char* hEap = malloc(20 * sizeof(char));
    if (hEap == NULL) return;
    memset(hEap, 0, 20 * sizeof(char));
    strcpy(hEap, "Hello,Miss!");
    *pp = hEap;
    printf("堆地址是：        %p \n", pp);
}
void test03()
{
    char* p = NULL;
    getString03(&p);
    printf("返回堆地址得到：  %p, p=%s \n", p, p);
}
int main(void)
{
    test01();  //调用函数，得到输出：“传递同级指针得：(null)”
    test02();
    test03();
    system("pause");
    return EXIT_SUCCESS;
}

运行上面例程，结论是： 被调函数在堆上，或者以指针形式在程序数据区申请内存，其对形参的定义都可以传递给实参。在栈上定义的字符串数组，由于栈上变量的生命周期的原因，无法正确传递给实参。