1、值传参，对形参的任何操作都不会对实参产生影响
1.1：值传参方法
//值传参
void NoChangeValue(int v) {
	printf("值传参修改前的值 = %d\n", v);
	v = 10;
	printf("值传参修改后的值 = %d\n", v);
}

1.2：主方法
void main() {
	int n = 1;
	printf("\n----------------------NoChangeValue------------------------------------\n\n");
	printf("调用前的值是 = %d\n", n);
	printf("\n------------start---------\n\n");
	NoChangeValue(n);
	printf("\n------------end-----------\n\n");
	printf("调用后的值 = %d,还是原值\n", n);
}

1.3：运行结果
1.4：解释
当主程序调用一个方法时，会产生一个栈帧。在栈帧中，包含方法的形参、方法的局部变量。执行方法时，会将实参的值赋值给栈帧中的形参。因此：对形参的操作不会影响到实参。
2、值的引用传参，对形参的任何操作都会对实参产生影响
2.1：引用传参方法
void ChangeValue(int &v) {
	printf("值传参修改前的值 = %d\n", v);
	v = 10;
	printf("值传参修改后的值 = %d\n", v);
}

2.2：主方法
void main(){
	int n = 2;
	int* p = &n;
	printf("\n----------------------ChangeValue------------------------------------\n\n");
	printf("调用前的值是 = %d\n", n);
	printf("\n------------start---------\n\n");
	ChangeValue(n);
	printf("\n------------end-----------\n\n");
	printf("调用后的值是 = %d，不再是原值\n", n);
}

2.3：运行结果
2.4：解释
引用相当于是外部变量的别名，实际操作的就是该变量，即在函数内对该变量进行修改的话，在外部该变量也会相应被修改。
3、指针传参第一种，直接改变指向的值
3.1：指针传参方法
void ChangePtrValue(int* p){
	printf("分配内存前p的地址 = %d \t 分配内存前p指向的地址 = %d \t 分配内存前p指向地址上的数值 = %d\t\n", &p,p,*p);
	*p = 3;//直接改变指向的值
	printf("分配内存后p的地址 = %d \t 分配内存后p指向的地址 = %d \t 分配内存后p指向地址上的数值 = %d\t\n", &p,p,*p);
}

3.2：主方法
void main(){
	int n = 2;
	int* p = &n;
	printf("----------------------ChangePtrValue------------------------------------\n\n");
	printf("方法调用前p的地址 = %d \t 方法调用前p指向的地址 = %d \t 方法调用前p指向地址上的数值 = %d\t\n", &p,p,*p);
	printf("\n------------start---------\n\n");
	ChangePtrValue(p);
	printf("\n------------end-----------\n\n");
	printf("方法调用后p的地址 = %d \t 方法调用后p指向的地址 = %d \t 方法调用后p指向地址上的数值 = %d\t\n", &p,p,*p);
}

3.3：运行结果

3.4：解释
第一种是直接把值存放到指针存放的地址空间中，即：*p=10
4、指针传参第二种，通过改变指针指向的地址空间，来间接的改变指针指向的值（其实并不可以改变）
4.1：指针传参方法
//不可改变指针所指向的地址
void NoChangePtrAddress(int* p) {
	printf("分配内存前p的地址 = %d \t 分配内存前p指向的地址 = %d \t 分配内存前p指向地址上的数值 = %d\t\n", &p,p,*p);
	int n = 3;
	p = &n;
	printf("分配内存后p的地址 = %d \t 分配内存后p指向的地址 = %d \t 分配内存后p指向地址上的数值 = %d\t\n", &p,p,*p);
}

4.2：主方法
void main(){
	int n = 2;
	int* p = &n;
	printf("----------------------NoChangePtrAddress------------------------------------\n\n");
	printf("方法调用前p的地址 = %d \t 方法调用前p指向的地址 = %d \t 方法调用前p指向地址上的数值 = %d\t\n", &p,p,*p);
	printf("\n------------start---------\n\n");
	NoChangePtrAddress(p);
	printf("\n------------end-----------\n\n");
	printf("方法调用后p的地址 = %d \t 方法调用后p指向的地址 = %d \t 方法调用后p指向地址上的数值 = %d\t\n", &p,p,*p);
}

4.3：运行结果
4.4：解释
第二种是在方法中通过将变量的地址存放到形参指针中，使形参指针指向另一个地址空间，间接的修改形参指针指向的值。在方法调用过程生成的栈帧中，该指针是局部的，是因为它只是实参指针的一个拷贝，对局部变量 的修改并不会改变实际指针。因此：不会像指针传参第一种一样。
5、指针引用传参第一类，仅会改变指针指向的地址（即改变指针的内容），而使得指针指向的值出现非法现象
5.1：指针传参方法
//可改变指针所指向的地址
void ChangePtrAddress(int* &p) {
	printf("分配内存前p的地址 = %d \t 分配内存前p指向的地址 = %d \t 分配内存前p指向地址上的数值 = %d\t\n", &p,p,*p);
	int n = 3;
	p = &n;//改变指针指向的地址空间
	printf("分配内存后p的地址 = %d \t 分配内存后p指向的地址 = %d \t 分配内存后p指向地址上的数值 = %d\t\n", &p,p,*p);
}

5.2：主方法
void main(){
	int n = 2;
	int* p = &n;
	printf("----------------------NoChangePtrAddress------------------------------------\n\n");
	printf("方法调用前p的地址 = %d \t 方法调用前p指向的地址 = %d \t 方法调用前p指向地址上的数值 = %d\t\n", &p,p,*p);
	printf("\n------------start---------\n\n");
	NoChangePtrAddress(p);
	printf("\n------------end-----------\n\n");
	printf("方法调用后p的地址 = %d \t 方法调用后p指向的地址 = %d \t 方法调用后p指向地址上的数值 = %d\t\n", &p,p,*p);
}

5.3：运行结果
5.4：解释
之所有会出现非法，是因为int n = 3；p = &n；n是一个局部变量，当方法调用结束时，会对该空间进行释放，因此出现不符合实际的情况。而指针指向的地址发生改变（虽然该地址不存在），这是因为在引用传参中，对形参的操作就是对实参的操作。
6、指针引用传参第二类，如同指针传参第一种，直接改变指向的值(即使用*p=10;)。再在此不在多讲。
7、结论
若要改变值实参，通过值引用传参、或通过指向其地址的指针来进行指针传参。

若要改变指针中的内容（即指针指向的地址），使用指针引用传参第一类。

若要改变指针指向地址空间的内容，使用指针引用传参第二类或指针传参第一类。

                    

                    

                    
                    
                    
一个人学Java太孤独，
小伙伴陪你一起学哦
也可以加小刀微信，进群一起学习
best396975802
结合视频所述,引用传参和值传参最大的区别就是,在方法内,如果对传入的参数修改会影响到外面的,就是引用传参,如果影不到外面的,就是值传参
小刀更想和大家聊的是下面这些
方法中代码层级的划分
在现在开发中,在一个方法中可能要很写多行,各种if-else判断,然后拿到返回值后再进行判断等等,
其实我们可以把项目做一个划分:
-  卫语句
所谓卫语句,即起到保卫作用的代码,用以检验入参,返回值,一旦发现不满足要求的,就退出逻辑
if(null == param){
  return BaseResponse.fail("param is null");
}
- 定义最终的返回值
然后定义最终的返回值,在下面的方法中,一步一步的对这个返回值进行设值,直至最后可以返回,如下所示
AccountDTO dto = new AccountDTO();
String name = "程序员学习大本营";
//以前的写法
dto.setName(name);
//可以尝试的写法
richName(dto,name);




public void richName(AccountDTO dto , String name){
  if(null == name){
    throw new BusinessException("name is null");
  }
  dto.setName(name);
}
- 最后的返回
返回开心就好了,, return dto; 
创作不易，喜欢的话，
扫一下下面的二维码，
给小刀在酷暑带来一丝丝清凉吧
或者点个在看表示你对公众号的支持吧
谢谢你哟~
END
小哥哥小姐姐，
点个在看再走吧~（づ￣3￣）づ╭❤～
                

      在C++中，引用的表示方法与指针相似，只是用&代替了*。引用（reference）是c++对c语言的重要扩充。引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。引用的声明方法：类型标识符 &引用名=目标变量名； 
       引用作为变量的别名，在一些场合可以代替指针；
       引用相对指针来说有更好的可读性和实用性；
        引用本质是对象的一个常指针
void function(int &a)
{
  a=100;
}
//引用转化为指针的函数
void function(int * const a)
{
    *a=100;
}

1. 单独定义引用时，必须要初始化；
int &a;//错误; 引用变量 "a" 需要初始值设定
2. 改变引用变量的值，同时也会改变原变量
int a = 0;
int &b = a;
b = 100;
cout << a;//输出：100
3.函数返回“非静态”栈变量的引用，栈空间会被回收，不能作为其它变量的初始值
int getVal1()//返回值本身
{
	int a = 100;
	return a;
}
int& getVal2()//返回引用
{
	int a = 100;
	return a;
}
int* getVal3()//返回指针
{
	int a = 100;
	return &a;
}

int main()
{
    int a1 = getVal1();
    int a2 = getVal2();//使用int去接收,打印：100
    int &a22 = getVal2();//使用引用接收，打印：随机地址值
    int *a3 = getVal3();//同a22  
    return 0;
}

4.函数返回“静态”栈变量引用，输出正常；因为static修饰的变量，存放在静态存储区，具备持久性；
int getVal1()//返回值本身
{
	static int a = 100;//static 修饰的局部变量；注意：Java不支持这种写法；
	return a;
}
int& getVal2()//返回引用
{
	static int a = 100;
	return a;
}
int* getVal3()//返回指针
{
	static int a = 100;
	return &a;
}

int main()
{
    int a1 = getVal1();
    int a2 = getVal2();//使用int去接收,打印：100
    int &a22 = getVal2();//使用引用接收，打印：100
    int *a3 = getVal3();//同a22  
    return 0;
}

5.基本数据类型传参
//交换了拷贝的值，不能交换实参本身的值; 与Java中效果一样
void swap0(int a, int b)
{
	int c = a;
	a = b;
	b = c;
}
void swap(int& a, int & b)
{
	int c = a;
	a = b;
	b = c;
}
void swap(int* a, int * b)
{
	int c = *a;//注意： 不能定义为 int *c=a;去交换
	*a = *b;
	*b = c;
}

int main()
{
	int a = 1, b = 2;
	printf("swap1交换前,a:%d,b:%d\n", a, b);
	swap1(a,b);
	printf("swap1交换之后,a:%d,b:%d\n",a,b);

	printf("swap2交换前,a:%d,b:%d\n", a, b);
	swap2(a, b);
	printf("swap2交换之后,a:%d,b:%d\n", a, b);

	printf("swap3交换前,a:%d,b:%d\n", a, b);
	swap3(&a, &b);
	printf("swap3交换之后,a:%d,b:%d\n", a, b);
}
//输出
swap1交换前,a:1,b:2
swap1交换之后,a:1,b:2
swap2交换前,a:1,b:2
swap2交换之后,a:2,b:1
swap3交换前,a:2,b:1
swap3交换之后,a:1,b:2

6. 复杂数据类型传参
在Java中：
    static class Person{
        private int age;
        public Person(){}
        public Person(int age){
            this.age=age;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
    public static void edit1(Person p){
        p.setAge(100);
    }
    public static void main(String args[]){
        Person p1=new Person(11);
        System.out.println("edit之前,p1:"+p1.getAge());
        edit1(p1);
        System.out.println("edit之后,p1:"+p1.getAge());
    }
输出：

=>对象的形参与实参指向同一块内存；

在C++中：
#include <iostream>
using namespace std;

class Person {
private:
	int age;
public:
	int getAge() {
		return age;
	}
	void setAge(int age) {
		this->age = age;
	}
	Person() {}
	Person(int age) {
		this->age = age;
	}
};
void edit1(Person p) {
	p.setAge(100);
}
void edit2(Person &p) {
	p.setAge(100);
}
void edit3(Person *p) {
	p->setAge(100);
}
int main()
{

	Person p1(11);
	printf("edit1之前,p1:%d\n", p1.getAge());
	edit1(p1);
	printf("edit1之后,p1:%d\n", p1.getAge());

	p1.setAge(11);
	printf("edit2之前,p1:%d\n", p1.getAge());
	edit2(p1);
	printf("edit2之后,p1:%d\n", p1.getAge());

	p1.setAge(11);
	printf("edit3之前,p1:%d\n", p1.getAge());
	edit3(&p1);
	printf("edit3之后,p1:%d\n", p1.getAge());



	system("pause");
	return 0;
}
输出：


可以看出edit1,类似Java的写法，在Java中可以更改p1对象的值，在c++中无效；
原因：
*  C++中声明对象 Person p; 会申请一块新内存，去初始化Person对象；
* Java中声明对象 Person p; 只声明不赋值，则只会在内存的栈区创建对象的引用，并没有在堆区申请对象的空间；
=> C++中的引用传递类似Java中的复杂对象的传递方式；

package com.fcy;
/**
 * 
 * @Description: 方法传参
 */
public class TestCon {
	public static void swap(MyTest a, MyTest b) {
		int tmp = a.getNum();
		a.setNum(b.getNum());
		b.setNum(tmp);
	}

	public static void main(String[] args) {
		MyTest a = new MyTest(3);
		MyTest b = new MyTest(5);
		TestCon.swap(a, b);
		System.out.println(a.getNum() + " " + b.getNum());
	}
}

class MyTest {
	int Num;
	
	public MyTest(int Num){
		this.Num = Num;
	}
		
	public int getNum() {
		return Num;
	}

	public void setNum(int tmp) {
		Num = tmp;
	}
}