public class Testcon {
  private int num;
     public Testcon(int num){
      this.num=num;
     }
     public int getNum(){
      return num;
     }
     public void setNum(int temp){
      this.num=temp;
     }
     //交換類
     public static void swap(Testcon a,Testcon b){
      int temp=a.getNum();
       a.setNum(b.getNum());
          b.setNum(temp);
     }
    
     public static void main(String[] args){
      Testcon a=new Testcon(25);
      Testcon b=new Testcon(50);
         System.out.println(“交换前a,b的值为：”+a.getNum()+","+b.getNum());
         swap(a,b);
         System.out.println(“交换后a,b的值为：”+a.getNum()+","+b.getNum());
       }
 }

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、结论
 
若要改变值实参，通过值引用传参、或通过指向其地址的指针来进行指针传参。
 若要改变指针中的内容（即指针指向的地址），使用指针引用传参第一类。
 若要改变指针指向地址空间的内容，使用指针引用传参第二类或指针传参第一类。
 
注：本人在二叉树初始化时，由于没有使用指针的引用传参，出现二叉树初始化失败，指针返回的结果老是为NULL。

      在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中的复杂对象的传递方式；

方法调用传参按照数据类型分为两种：
 数据类型分为两大类：
 基本数据类型和引用数据类型（类，接口，数组）
 一、基本数据类型传参
 例：
 
public class Test {
    public static void main(String[] args) {
        //交换两个变量的值
        int num0 = 10;
        int num1 = 20;
        System.out.println("num0=" + num0 + "\tnum1=" + num1);
        change(num0, num1);
        System.out.println("num0=" + num0 + "\tnum1=" + num1);
    }

    static void change(int a, int b) {
        System.out.println("a=" + a + "\tb=" + b);
        int temp = a;
        a = b;
        b = temp;
        System.out.println("a=" + a + "\tb=" + b);
    }
}
 

 内存分析：
 任何一个方法当被调用时，会生成一个对应方法的栈帧，每个方法的栈帧中保存的是方法内的局部变量的内容。当方法结束时，对应的栈帧被移除。
 小结：开辟对应的方法的栈帧，给所有的形式参数开辟内存，将实参的值赋值给形式参数。
 即给形参分配内存，并将实参的值赋给形参。（简言之，基本数据类型传参，传递的是实参的值，并将实参的值夫给形参。做的是值传递，即pass by value）;
 二、引用数据类型传参（引用数据类型作为方法的参数）
 与基本数据类型相同，都会给形参开辟内存，但是不同的是实参传递给形参的是实参的引用，而不是实参的值。
 例：
 
public class Test {
    public static void main(String[] args) {
        //交换两个变量的值
        int []arr={1,2};
        System.out.println("num0="+arr[0]+"\tnum1="+arr[1]);
        change(arr);
        System.out.println("num0="+arr[0]+"\tnum1="+arr[1]);
    }
    static void change(int[] arr) {
        int temp = arr[0];
        arr[0]=arr[1];
        arr[1]=temp;
    }
}
 

 内存分析：
 
 小结：传引用（pass by reference）