形参（const，引用，指针）

#include <iostream>         //这是一个关于引用形参，const形参，指针形参的程序，用于理解不一样形式的区别
using namespace std;


//非引用形参，实参副本，修改形参值不影响实参
//const常量，值不可修改
//非引用非const形参和非引用const形参都可由const或非const实参初始化
int use_ptr1(int val)		        //非引用非const形参
{  
 return ++val;			        //能够修改
}
int use_ptr2(const int val)	        //非引用const形参
{
 return val;				//不可修改
}
//指针形参
int use_ptr3(int *s1)			//指针形参指向非const对象
{					//只能由指向非const对象的实参指针初始化
 return ++(*s1);			//能够修改
}
int use_ptr4(const int *s2)	        //指针形参指向const对象
{					//能够由指向const和非const对象的实参指针初始化
 return *s2;				//不可修改
}




/*********************************/
//引用形参，直接关联到绑定对象，对形参的修改就是对实参的修改
int use_ptr5(int &val)				//非const引用形参
{						//只能与彻底同类型的非const对象关联
 return ++val;					//不容许传递右值或须要类型转换的对象
}
int use_ptr6(const int &val)		        //const引用形参
{						//能够由非const或const对象初始化
 return val;					//也能够传递右值或须要类型转换的对象
}


//传递指针的引用


void ptrswap1(int *&s1,int *&s2)		//指向非const对象的指针的引用
//形参定义的理解：int *&a->a是一个引用，与指向int型对象的指针相关联。也就是说，a是传递进函数swap的任意指针的别名
//使用指向非const对象的指针初始化
{
 int *temp = s2;
 s2 = s1;
 s1 = temp;
}


void ptrswap2(const int *&s1,const int *&s2) //指向const对象的指针的引用
//形参定义的理解：const int *&a->a是一个引用，与指向int型const对象的指针相关联。
//使用指向const对象的指针初始化
{
 const int *temp = s2;
 s2 = s1;
 s1 = temp;
}


/*********************************/
int main()
{
 int v1 = 1;
 const int v2 = 2;
 short v3 = 3;
 cout << v1 << " " << v2 << endl;


 use_ptr1(v1);
 use_ptr1(v2);
 cout << v1 << " " << v2 << endl;


 use_ptr2(v1);
 use_ptr2(v2);
 cout << v1 << " " << v2 << endl;


 use_ptr3(&v1);
 //use_ptr3(&v2);		//error:不能使用指向const对象的指针来初始化指向非const对象的指针
 cout << v1 << " " << v2 << endl; 


 use_ptr4(&v1);
 use_ptr4(&v2);
 cout << v1 << " " << v2 << endl;


 use_ptr5(v1);
 //use_ptr5(v2);		//error:不能使用const对象指初始化非const引用形参
 //use_ptr5(v3);		//error；不能使用不一样类型的对象来初始化形参
 //use_ptr5(0);			//error：不能使用右值来初始化
 //use_ptr5(v1+v2);		//error: 不能使用右值来初始化


 use_ptr6(v1);
 use_ptr6(v2);
 use_ptr6(v3);			  //OK：类型转换
 use_ptr6(0);		          //OK：右值
 use_ptr6(v1+v2);		  //OK：右值


 int a = 1, b = 2;
 int *p1 = &a;
 int *p2 = &b;
 const int *p3 = &a;
 const int *p4 = &b;
 
 ptrswap1(p1, p2);
 //ptrswap1(p3, p4);				//error:指向const对象的指针
 cout << *p1 << " " << *p2 << endl;
 
 //ptrswap2(p1, p2);				//error：指向非const对象的指针
 ptrswap2(p3, p4);
 cout << *p1 << " " << *p2 << endl;
 return 0;
}