各类形参（引用，const，指针）

#include <stdlib.h>

#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对象的实参指针”初始化（whl啥意思）

    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;

    system("pause");

    return 0;

}