c语言我们都知道形参不能改变实参，实参能改变形参，我们能保证自己很熟悉这个概念吗，能不能保证自己每次都不犯错，掉坑里。

#include <iostream.h>

#include <string.h>

void fun( char *s)

{

char a[10];

strcpy ( a, “AAAAAA” );

cout<<“形参未改变，实参传递给实参的值：”<<s<<endl;

s=a;

cout<<"形参改变后字符串后的值：        "<<s<<endl;

}

main( )

{

char *p= “BBBBBB” ;

fun( p );

cout<<"实参在形参被改变后的值：        "<<p<<endl;

}

这是我自己写的实参改变形参的一段代码，末尾我会附上运行截图

在谈论这个问题前先明确几个概念
形参是什么？

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
实参是什么？

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使实参获得确定值。
要实现调用函数，形参传递到实参要注意的事项有哪些？
实参的类型，数量定义的顺序都是不能改变的，这样才能调用，不然会出现不匹配错误，比如定义一个函数

void  ss(int a,char c) //a和c就是形参

我们在调用的时候就要提前定义实参，严格按照  整形，字符型的顺序才能调用

int f;

char v;

ss(f,v)；//f和v就是实参

参数的传递方向是单向的，只能从实参传到形参（不要妄想形参反客为主改变实参，那是不可能的，之后用代码进一步证明）
附上我写的字符串复制的例子，感兴趣的话可以自己实践一下，也可以复制我的操作一下
简单解释一下我的这个指针指向的例子

实参p是字符型指针，赋给初始值为BBBBBB，然后利用函数，形参为字符型指针s，形参改变实参的证明就是我们没给s赋初值但是初始值为实参的值，这里输出BBBBBB，所以实参改变了形参；
s初始值和实参一样为BBBBBB，我们这里继续改变形参的值，改为AAAAAA，输出，发现形参s改变成AAAAAA；
我们都知道C语言是从上到下按顺序执行的，我们在main函数调用函数后来看一下有没有通过改变形参的值改变了实参，输出实参p,实际上没有改变，实参p的值依然是BBBBBB,所以实参并没有受到改变；
本人很菜，有什么不完全或者有误的地方请指出，有问题请留言或者私聊我，写作不易，有帮助的话请留下一个赞，谢谢。

附上我的运行截图帮助理解：

class Student{
	int a = 1;

	@Override
	public String toString() {
		return "Student [a=" + a + "]";
	}

	public Student(int a) {
		this.a = a;
	}
	
}

public class Java_Test {
	private int a = 1;
	private Integer b = 200;
	private Double d = 20.2;
	private Boolean bool = true;
	private Student s = new Student(1);
	//传入的是:基本类型
	public void show(int n ) {
		System.out.println("基本类型修改前:"+n);
		n = 3;
		System.out.println("基本类型修改后:"+n);
	}
	
	//传入的是:包装类Integer
	public void show(Integer n ) {
		System.out.println("包装类修改前:"+n);
		n = 300;
		System.out.println("包装类修改后:"+n);
	}
	//传入的是:包装类Double
	public void show(Double n ) {
		System.out.println("包装类修改前:"+n);
		n = 30.3;
		System.out.println("包装类修改后:"+n);
	}
	//传入的是:包装类Boolean
	public void show(Boolean n ) {
		System.out.println("包装类修改前:"+n);
		n = false;
		System.out.println("包装类修改后:"+n);
	}
	
	//传入的是:对象
	public void show(Student s ) {
		System.out.println("对象修改前:"+s.a);
		s.a = 3;
		System.out.println("对象修改后:"+s.a);
	}
	
	
	public void test() {
		//基本类型int
		System.out.println("传入一个基本类型数字:"+a);
		show(a);
		System.out.println("基本类型最终值:"+a);
		System.out.println("------------------");
		
		//包装类Integer
		System.out.println("传入一个包装类数字:"+b);
		show(b);
		System.out.println("包装类最终值:"+b);
		System.out.println("------------------");
		
		//包装类Double
		System.out.println("传入一个包装类数字:"+d);
		show(d);
		System.out.println("包装类最终值:"+d);
		System.out.println("------------------");
		
		//包装类Boolean
		System.out.println("传入一个包装类数字:"+bool);
		show(bool);
		System.out.println("包装类最终值:"+bool);
		System.out.println("------------------");
		
		//对象Student
		System.out.println("传入一个对象数字:"+s);
		show(s);
		System.out.println("包装类最终值:"+s);
		
	}
	
	
	public static void main(String[] args) {
		new Java_Test().test();
	}
}
是因为赋的那个值不超范围是方法区中的缓冲的值？
当然不是，是因为所有的包装类都是final修饰的，都是不可变类。

当函数需要用形参改变实参时，简单的传值不能解觉问题。这时就需要使用指针解决问题。
例：int a=10;b=20;要求写一个函数将a，b的值互换。

错误代码：

1.
//交换失败,原因a,b仅仅只是赋值,main中的a和Swap中的a不是同一个变量
void Swap_err(int a,int b)
{
 int tmp = a;
 a = b;
 b = tmp;
}



//交换失败,只是交换形参的指向(交换钥匙),没有解引用
void Swap_err2(int *p1,int *p2)
{
 int *tmp = p1;
 p1 = p2;
 p2 = tmp;
}



void Swap_err3(int *p1,int *p2)
{
 int *tmp;//野指针,悬挂指针,tmp是个局部变量,默认值为随机值
 *tmp = *p1;//*tmp崩溃,野指针不能访问
 *p1 = *p2;
 *p2 = *tmp;
}
正确代码：
void Swap(int *p1, int *p2)
{
 int tmp = *p1;
 *p1 = *p2;
 *p2 = tmp;
}
int main()
{
 int a = 10;
 int b = 20;
 printf("%d,%d\n", a, b);
 Swap(&a, &b);
 printf("%d,%d\n", a, b);
 return 0;
}
运行结果：

版权声明！原创！转载请附上原文出处链接！
先上百度知道里一位大佬的简洁明了的回答！！！！


1、形参在函数定义中，函数体内使用，调用结束即刻释放； 函数体外不能使用。
2、实参在主调函数中，被调函数中不能使用。
3、一般调用时，只能实参传给形参，不能形参传给实参。
4、实参形参在数量上，类型上，顺序上应严格一致， 否则会发生“类型不匹配”的错误。
5、若函数参数是指针时,函数体内可改变实参的值
：传给函数的是实参的地址，在函数体内使用的也是实参的地址，即实参本身。
6、若函数参数不是指针时，调用函数不能改变实参的值