引用

//变量 具有 名称，空间 两个属性

//而引用只有名称，没有空间性

//引用 仅仅是 变量的别名

//引用没有自己的独立空间 他是和他所引用的变量 共享空间的

//对引用的操作 就是对 所引用的变量操作

//引用必须 在定义时 必须初始化,初始化后 该引用不能 再指向其他变量

//引用一般用于形参列表中，可以操作传入的形参本体。

 

void swap(int& a, int& b);

int& index(int dex);

int& sum(int a, int b);

 

int array_test[] = {1,2,3,4};

 

int main(void)

{

int i = 100;

int& refval = i;

 

std::cout<<"i--->"<<i<<"\t"<<"address--->"<<&i<<std::endl;  

std::cout<<"refval--->"<<refval<<"\t"<<"address--->"<<&refval<<std::endl;

 

refval = 200; // == i= 200的表达式

 

std::cout<<"i--->"<<i<<"\t"<<"address--->"<<&i<<std::endl;

std::cout<<"refval--->"<<refval<<"\t"<<"address--->"<<&refval<<std::endl;

/*

结果：

i--->100        address--->003CFCDC

refval--->100   address--->003CFCDC

i--->200        address--->003CFCDC

refval--->200   address--->003CFCDC

*/

//上述代码 表示 初始化后，对引用的操作 就是所引用的变量的值，地址是不变

 

//const 引用 可以指向 const 变量 和 非const变量 但是 value 都不可以更改

//非const 引用 不可以指向 const变量

 

const int n = 100;

int    n1   = 200; 

const int& reN = n;

const int& reF = n1;

//int & reNn    = n;   error C2440: “初始化”: 无法从“const int”转换为“int &”

//reN = 1;  error C3892: “reN”: 不能给常量赋值

//reF = 2;  error C3892: “reF”: 不能给常量赋值

 

 

/*

当使用const 引用 进行不同类型赋值时 会出现警告 

{

这时 在赋值的时候 const 引用(会产生一个临时变量)是指向一个临时变量的

如 51行 的操作  拆分开：

int temp = d_n;

int& refv = temp;

}

非const 引用 不能进行不同类型之间的引用

*/

double d_n = 3.14;

const int& refv = d_n;  //warning C4244: “初始化”: 从“double”转换到“const int”，可能丢失数据

//int& re_fv = d_n;    //error C2440: “初始化”: 无法从“double”转换为“int &”

 

/*

参数传递：

1. 值传递 ：   不可以改变实参的值  --实参初始化形参时要分配空间，是一个拷贝

2. 引用传递：  可以改变实参的值    --实参初始化形参时不分配空间，引用和指向的变量共享空间

3. 指针传递：  可以改变实参的值 

{

指针传递 实质也是值传递 也要分配空间 我们只能修改 指针指向的值 而不能修改 指针本身

如果要修改 指针本身 要用 指针的指针（**） 或者 用 指针的引用（*&）

}

 

{

当引用做为 形参的时候， 在函数调用时候 进行初始化的

这时 引用的形参 指向实参  他们共享空间，所以 对引用的操作就是实参的操作

}

*/

int num = 1;

int numm = 2;

swap(num, numm);

std::cout<<num<<"\t"<<numm<<std::endl;  // 2  1

 

 

/*

引用作用为返回值的 主要目的 是为了将函数放在 赋值运算符左边

注意：不能返回局部变量的 引用

*/

index(1) = 100; // 引用在返回时进行初始化array_test,等价于 array_test[1] = 100 修改了 全局数组的值 所以输出 100

std::cout<<"array_test[1]---------->"<<array_test[1]<<std::endl; //array_test[1]---------->100

 

/*

返回局部变量引用，存有很大的不确定性 所以不能返回局部变量引用

 

*/

 

int nn = sum(1, 2);

int& pn = sum(5, 6);

 

std::cout<<"pn------------>"<<pn<<std::endl;

std::cout<<"nn------------>"<<nn<<std::endl;

std::cout<<"pn------------>"<<pn<<std::endl;

std::cout<<"nn------------>"<<nn<<std::endl;

/*

pn------------>11

nn------------>3

pn------------>256733284

nn------------>3

上述结果 发现 对普通变量 返回值是没错的 

但是使用引用就有会问题  这是因为 引用本身没有自己的空间

当局部变量引用返回时 局部变量已经不存在了，

但是空间 没有被使用，当空间被使用后，引用就无法找到正确的值了 所以不能返回 局部变量的引用
局部指针亦如此 如下 

   */

int* fun(void);

 

int main(void)

{

int* p = fun();

std::cout<<p<<"-------"<<*p<<std::endl;

 

int* pp = fun();

std::cout<<p<<"-------"<<*p<<std::endl;

std::cout<<pp<<"-------"<<*pp<<std::endl;
 /*
0038FD20-------1

0038FD20-------1

0038FD20-------261145568

*/ 

 

return 0;

}

 

int* fun(void)

{

int i = 1;

return &i ;

} 

 

/*

引用是直接访问变量的，他自身不分配空间出来

指针是间接访问变量的，指针有自己的空间

引用一经初始化，空间是不会变的。而指针是可以变量（int * const p 这样的除外）

-- 尽可能用引用 不得已时 再用指针

*/

 

return 0;

}

 

void swap(int& a, int& b)

{

int temp = a;

a = b;

b = temp;

}

 

int& index(int dex)

{

return array_test[dex];

}

 

int& sum(int a, int b)

{

int su = a + b;

return su;

}