一、C语言函数的值传递

C语言的值传递，顾名思义就是使用常量、数组等作为函数的参数，定义一个函数后，其在被主函数调用的过程中，实际是将实参的值复制到形参相应的存储单元中，即形参和实参分别占用不同的存储单元。

值传递的特点：

值传递的最大的特点就是单向传递，即主调函数被调用时给形参分配存储单元，把实参的值传递给形参，在调用结束后，形参的存储单元被释放，而形参值的任何变化都不会影响到实参的值，实参的存储单元仍保留并维持数值不变。
如下代码所示，定义了一个函数swap()用于交换两个参数的值，在被主函数调用的过程中，a和b的值相当于被拷贝了一份过去swap函数，无论在swap()函数中完成了什么操作，都是不会影响到主函数中定义的两个变量a、b存储的值的。

#incldue <stdio.h>
void swap(int x,int y)
{
	int temp;
	temp = x;
	x = y;
	y = temp;
}
int main(int argc, char *argv[])
{
	int a = 12,b = 24;
    swap(a,b); // 值传递
    printf("a = %d b = %d",a,b);
	return 0;
}

程序运行后的结果如下：

C:\Users\11197\Desktop\main>swap
a = 12 b = 24

二、C语言函数的地址传递

大家呢都知道，在C语言中，数组名就代表着数组存储空间的首地址，所谓的地址传递，就是函数的参数是数组名或者指针，传递的是数组的首地址或指针的值，而形参接收到的是地址，即指向实参的存储单元，形参和实参占用相同的存储单元，即形参和实参是相同的。

地址传递的特点：

形参并不存在存储空间，编译系统不为形参数组分配内存。因此在数组名或指针作函数参数时所进行的传送只是地址传送，形参在取得该地址之后，与实参共同拥有一段内存空间，形参的变化也就是实参的变化。

实例代码如下，函数swap()传入的是两个地址，在主函数调用的过程中，将变量a、b的地址传入了swap()函数中，在swap()函数中，通过指针解引用等操作完成了两个地址的存储值的值交换。

#include <stdio.h>
void swap(int* x,int* y)
{
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
}
int main(int argc, char *argv[])
{
	int a = 12,b = 24;
	swap(&a,&b); //地址传递
	printf("a = %d b = %d\n",a,b);
	return 0;
}

函数运行结果如下：

C:\Users\11197\Desktop\main>dizhi
a = 24 b = 12

可以看到，通过地址传递的方式，成功的交换了变量a、b中存储的值。

三、局部变量作为函数返回值

局部变量是不会进行存储的？所以函数void *fun(void)调用结束的时候，buf[]被释放了，没法返回一个地址。

#include <stdio.h>

char *fun(void)
{
	 char buf[] = "helo world!";
	return buf;

}

int main()
{
	char *p;
	
	p=fun();
	printf("the p is %s\n",p);
	return 0;
}

可以看到程序运行的结果如下：

C:\Users\11197\Desktop\main>jububianliang
the p is Pi

接下来在函数中的bud前面加上static看看效果，加上这个值相当于将buf[]存储在不易被改变的静态区

#include <stdio.h>

char *fun(void)
{
	static char buf[] = "helo world!";//这里有没有static会影响输出结果，加上static相当于数据存储在数据区
	
	return buf;

}

int main()
{
	char *p;
	
	p=fun();
	printf("the p is %s\n",p);
	return 0;
}

我们来看运行输出的效果：

C:\Users\11197\Desktop\main>jububianliang
the p is helo world!

将函数void *fun(void)改变为只单单返回一个“hello world!”也可以看到相同的效果：

#include <stdio.h>

char *fun(void)
{
	return "hello world!";
}

int main()
{
	char *p;
	
	p=fun();
	printf("the p is %s\n",p);
	return 0;
}

运行效果如下：

C:\Users\11197\Desktop\main>jububianliang
the p is helo world!

C语言函数传递方式

值传递

定义

• 所谓的值传递，顾名思义就是使用变量、常量、数组等作为函数的参数。实际是将实参的值复制到形参相应的存储单元中，即形参和实参分别占用不同的存储单元。

特点

• 值传递的特点是单向传递，即主调函数被调用时给形参分配存储单元，把实参的值传递给形参，在调用结束后，形参的存储单元被释放，而形参值的任何变化都不会影响到实参的值，实参的存储单元仍保留并维持数值不变。

示意图

其实值传递过程中由隐含的一步，如下代码所示：

	int x = a;
	int y = b; 

所以swap1函数交换的是x和y，而原来的a和b从未改变。

代码演示

void swap1(int x,int y)
{
	int temp;
	temp = x;
	x = y;
	y = temp;
	printf("x = %d,y = %d\n",x,y);	
}
int main(int argc, char *argv[]) 
{
	int a = 12,b = 24;
    swap1(a,b); // 值传递 
    printf("a = %d b = %d",a,b);
}

运行结果

地址传递

说明

• 大家都知道，在C语言中，数组名就代表数组的首地址。所谓的地址传递，指的就是函数的参数是数组名或者指针。传递的是数组的首地址或指针的值，而形参接收到的是地址，即指向实参的存储单元，形参和实参占用相同的存储单元，即形参和实参是相同的。

特点

• 形参并不存在存储空间，编译系统不为形参数组分配内存。因此在数组名或指针作函数参数时所进行的传送只是地址传送，形参在取得该地址之后，与实参共同拥有一段内存空间，形参的变化也就是实参的变化。

示意图

注意：这里也有一个隐含动作，如下代码所示：

	x = &a;
	y = &b;

分别将a的地址，b的地址赋值给x和y，这样swap2函数操作的数其实就是a和b。

代码演示

void swap2(int* x,int* y)
{
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
	printf("x = %d y = %d\n",*x,*y);
}
int main(int argc, char *argv[]) 
{
	int a = 12,b = 24;
	swap2(&a,&b); //地址传递
	printf("a = %d b = %d",a,b); 
}

运行结果

以上就是C语言值传递和地址传递的区别了，相信大家应该很清楚了吧！

1.概念解释

1.1值传递：

形参是实参的拷贝，在外部某个函数中改变形参的值并不会影响主函数内的数据。从被调用函数的角度来说，值**传递是单向的（实参->形参），参数的值只能传入，不能传出**，当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。但是当数据量很大，某个函数只用其中的一部分的时候是不可取的，因为它会把整份数据都拷贝过来。

1.2指针传递：

形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作，函数传递的时候只传入一个指针占用四个字节的空间。但是在函数中数据外部数据也会发生改变。

2.代码案例

#include<iostream>
using namespace std;

//定义结构体与创建结构体变量
struct Student
{
	string name;
	int age;
};

// 采用值传递的方式改变结构体变量与输出
void printStudent1(Student p) {
	p.age = 18;
	cout << "采用值传递的方式：" << " 姓名：" << p.name << " 年龄: " << p.age << endl;
}
// 采用地址的方式改变结构体变量与输出
void printStudent2(Student *p) {
	p->age = 18;
	cout << "采用地址传递的方式：" << " 姓名：" << p->name << " 年龄: " << p->age << endl;
}
int main()
{
	Student s = { "张三",15 };
	printStudent1(s);
	cout << "源结构体的变量：" << " 姓名：" << s.name << " 年龄: " << s.age << endl;
	printStudent2(&s);
	cout << "源结构体的变量：" << " 姓名：" << s.name << " 年龄: " << s.age << endl;
	system("pause");
	return 0;
}

结果如下：
可以理解为值传递的时候函数把源数据传递给了新变量，而函数中的更改都是对新变量的操作
指针传递是在函数中传递了指向源数据的指针，函数中的数据都是对源数据的操作

如果指针传递的时候防止误修改可使用const修饰

void printStudent2( const Student *p) {
	p->age = 18;
	cout << "采用地址传递的方式：" << " 姓名：" << p->name << " 年龄: " << p->age << endl;
}

这时候如果在程序中修改程序会报错