C语言中实际参数和形式参数的设置及传递方式

Posted 2023-04-26

C语言中实际参数（实参）与形式参数（形参）之间的传递方式有传值和传地址两种函数调用方式。

下面通过举例来说明实参和形参的设置方法以及传值与传地址的两种函数调用方式。

值传递方式：

#include<stdio.h>
void fun(int a, int b)  // 此处a， b为形参

    a++;
    b++;

void mian()

    int a=1, b=2;    
    fun(a, b);  // 按传值方式调用函数fun，此处a，b为实参
    printf("%d, %d\\n", a, b);  // 输出a=1， b=2

地址传递方式：

#include<stdio.h>
void fun(int *a, int *b)  

    *a = 4;
    *b = 5;

void mian()

    int a=1, b=2;    
    fun(&a, &b);  // 按传地址方式调用函数fun
    printf("%d, %d\\n", a, b);  // 输出a=4， b=5

参考技术A 如果形式参数是变量级的，实参和形参的传递就是值传递，即实参的数值复制一份传给形参；
如果形式参数是表示地址含义的，如数组、指针等，实参应该是数组名或指针，传递时实参则把地址传递给形参，即形参和实参是对相同地址的数据进行的操作。 参考技术B 分为传参调用和传址调用本回答被提问者采纳

值传递和引用传递-----函数参数传递的两种方式

 

 

回顾：

　　在定义函数时函数括号中的变量名成为形式参数，简称形参或虚拟参数；在主调函数中调用一个函数时，该函数括号中的参数名称为实际参数，简称实参，实参可以是常量、变量或表达式。

 

注意：

　　　　1、C语言中实参和形参之间的额数据传递是单向的“值传递”，单向传递，只能由实参传给形参，反之不能。

　　　　2、被调用函数的形参只有函数被调用时才会临时分配存储单元，一旦调用结束占用的内存便会被释放。

　　　　3、”按值传递“中包括值传递（实实在在的值啊！）和指针传递（指针传递参数本质上是值传递的方式，它所传递的是一个地址值），传递的都是实参的一个拷贝。

 

一、按值传递

　　主调函数向调用函数传递参数实际上只是将实参的拷贝（即临时副本）传递给了被调用函数，并不是实参本身，这样被调函数不能直接修改主调函数中变量的值，而只能修改其私有的临时副本的值。

 

　　1、例子1：值传递（实实在在的值啊）

 1 #include <stdio.h>  
 2 int main()  
 3 {  
 4     int a=2,b=3;  
 5     void swap(int x,int y);  
 6     printf("before:%d,%d\\n",a,b);  
 7     swap(a,b);  
 8     printf("later:%d,%d\\n",a,b);  
 9     return 0;  
10 }  
11   
12 void swap(int x,int y)  
13 {  
14     int tmp;  
15     tmp=x;  
16     x=y;  
17     y=tmp;    
18 }  

　　运行结果：

　　

　　

　　下面的例子体现了不论传递的是值还是指针(指针也是一个值)，传递给被调用函数的都是实参的一个拷贝，直接对拷贝进行操作不会影响实参

 1 #include <stdio.h>  
 2 int main()
 3 {
 4     int a = 2, b = 3;
 5     printf("before:%d,%d\\n", a, b);
 6     printf("---------------------------\\n");
 7     printf("a所在的地址为：%x\\n", &a);
 8     printf("b所在的地址为：%x\\n", &b);
 9     printf("---------------------------\\n");
10     void swap(int* x, int* y);
11     swap(&a, &b);
12     printf("later:%d,%d\\n", a, b);
13     return 0;
14 
15 }
16 
17 void swap(int* x, int* y)
18 {
19     printf("x所在的地址为：%x\\n", &x);
20     printf("y所在的地址为：%x\\n", &y);
21     printf("---------------------------\\n");
22     printf("x存储的值为：%x\\n", x);
23     printf("y存储的值为：%x\\n", y);
24     printf("---------------------------\\n");
25     int *tmp = NULL;
26     tmp = x;
27     x = y;
28     y = tmp;
29     //所以交换x，y只是交换了两者存储的值(值为a,b的地址)，并没有涉及到a,b的值的交换
30     //所以只是操作地址并没有卵用
31     printf("x存储的值为：%x\\n", x);
32     printf("y存储的值为：%x\\n", y);
33     printf("---------------------------\\n");
34 }

　　运行结果：

　　

 

　　但是可以通过地址间接地改变实参的值（请参见例子2）

　　2、例子2：指针传递

#include <stdio.h>  
int main()
{
    int a = 2, b = 3;
    void swap(int* x, int* y);
    printf("before:%d,%d\\n", a, b);
    swap(&a, &b);
    printf("later:%d,%d\\n", a, b);
    return 0;

}

void swap(int* x, int* y)
{
    int tmp;
    //这里使用了‘*’表示操作的是指针x,y所指向变量的内容（即变量a,b的内容）
    tmp = *x;
    *x = *y;
    *y = tmp;
}

　　运行结果：

　　

　　

二、按引用传递

        对引用的操作等于对其指定的对象进行操作，当将实参传递给形参时，形参就指向了实参（形参与实参同义，是它的一个别名）

 1 #include <stdio.h>  
 2 void swap(int& a, int& b)
 3 {
 4     int tmp;
 5     tmp = a;
 6     a = b;
 7     b = tmp;
 8 }
 9 
10 int main()
11 {
12     int i = 3, j = 4;
13     printf("before swap:i=%d,j=%d\\n", i, j);
14     swap(i, j);
15     printf("After  swap:i=%d,j=%d\\n", i, j);
16     return 0;
17 }

　　运行结果：

　　

 

三、补充

　　至于指针/引用传递的格式，可以参考以下的内容：

1 int x=1;
2 
3 int *y=&x; //用于指针传递，y有自己独立的内存地址，存储的内容是x的地址，*y是x的值
4 
5 int &z=x; //用于引用传递，可以理解为z就是x，x就是z，只不过名字不一样

　　最后再啰嗦一个例子：

 1 #include <iostream>
 2 using namespace std;
 3 int change1(char* name){
 4     name = "alter";
 5     return 1;
 6 }
 7 
 8 int change2(char* &name){
 9     name = "alter";
10     return 1;
11 }
12 
13 int main(){
14     char* string ="original!";
15     change1(string);
16     cout << string <<\'\\n\';
17 
18     change2(string);
19     cout << string << \'\\n\';
20 
21 }

　　运行结果：

　　

　　change1是值传递，形参name有自己独立的内存地址，修改后name的内容变成了“alter”的地址（但string的内容还是”original!“）。

　　change2是引用传递，形参name的地址就是string的地址，或者说name就是string。