引用的使用学习

/* 练习引用的使用。
使用引用的原因：
1、能够修改调用函数中的数据对象；
2、传递引用可以提高程序运行速度，经常用于传递大的结构体或类对象；


使用值传递、指针、引用的指导（不需要修改调用函数中的数据的函数）：
1、数据对象很小，如数据类型和小型结构，则按值传递；
2、数据对象是数组，使用指针，这是唯一选择，并将指针声明为指向const的指针；
3、数据对象是较大的结构，使用const指针或引用，以提高程序的效率。可节省复制结构所需的时间、空间；


使用值传递、指针、引用的指导（需要修改调用函数中的数据的函数）：
1、如果数据对象是内置数据类型，则使用指针；
2、数据对象是数组，只能使用指针；
3、数据对是结构，则使用引用或指针；
4、数据对象是类对象，则使用引用；


函数返回引用的好处：
当返回值时，如下，plus1，z会被复制到一个临时的位置，然后赋值给t1
而，当返回时引用时，如plus3，直接将z复制到t3，,效率更高，当引用指向类或结构时更明显。
将const用于引用返回类型的原因：
不用const的话，yin.plus3(yin.a,yin.b,yin.c)=100;是合法的，因为返回的是引用，指向的是可修改的内存块，为了避免这种情况，以免犯错误，使用const，如plus6.


使用const的好处：
1、可以避免无意中修改程序的错误
2、使用const可使函数可以处理const和非const实参，否则只能接受非const数据
3、使用const引用使函数能够正确生成并使用临时变量。


引用与类的继承：
基类的引用可以指向派生类的对象，无需强制类型转换。如，可以定义一个接受基类引用作为参数的函数，
调用时，可以将基类对象作为参数，也可以将派生类对象作为参数。


*/


#include "stdafx.h"
#include "iostream"
#include "string"
using namespace std;


class Yin1
{
public:
Yin1();
~Yin1();
public:
int a,b,c;      
public:
int plus1(int x,int y,int z);
int* plus2(int *x,int *y,int *z);
int& plus3(int &x,int &y,int &z);
int& plus4(int &x,int &y,const int &z);
int& plus5(const int &x,const int &y,const int &z);
const int& plus6(const int &x,const int &y,const int &z);
const string& plus7(const string &s1,string& s2);//作用是在s1的两边加上（），再赋给s2
};
Yin1:: Yin1()
{
a=100;b=200;c=0;
}
Yin1:: ~Yin1(){}
int Yin1:: plus1(int x,int y,int z) //传递是副本，返回的也是副本，可行
{
z=x+y;
return z;
}
int* Yin1::plus2(int *x,int *y,int *z) //传递指针，返回指针
{
*z=*x+*y;
return z;
}
int& Yin1::plus3(int &x,int &y,int &z) //传递引用，返回引用
{
z=x+y;
return z;
}
int& Yin1::plus4(int &x,int &y,const int &z) //传递引用，返回引用,如果不允许修改z，则申明为const
{


//z=x+y;错误，不能修改z
// int &q=x+y;  //错误，引用指向了一个值，就不在变了，所以不能把变量给引用
int q=x+y;
return q;
}
const string& Yin1::plus7(const string &s1,string& s2)
{
s2="(" + s1 +")";
return s2;
}


int& Yin1::plus5(const int &x,const int &y,const int &z) //传递引用，返回引用,不允许修改x,y,z
{


//z=x+y;x=100;错误，不能修改z,x
// int &q=x+y;  //错误
//return (x+y); //错误
//一下这种方法虽然能运行成功，但不应该采用，因为返回的是指向局部变量的引用
//局部变量p，q都会在程序结束时消失，因此返回引用时应该避免函数终止时不再存在的内存单元！
//最好的方法是采用plus3（）方法，将参数z作为返回值
int q=x+y;  //可以
int &p=q;   //可以
return p;   //return q;也可以
}
const int& Yin1::plus6(const int &x,const int &y,const int &z) //传递引用，返回引用,不允许修改x,y,z
{


//z=x+y;x=100;错误，不能修改z,x
// int &q=x+y;  //错误
//return (x+y); //错误
//一下这种方法虽然能运行成功，但不应该采用，因为返回的是指向局部变量的引用
//局部变量p，q都会在程序结束时消失，因此返回引用时应该避免函数终止时不再存在的内存单元！
//最好的方法是采用plus3（）方法，将参数z作为返回值
int q=x+y;  //可以
int &p=q;   //可以
return p;   //return p;也可以
}


int main(int argc,char *argv[])
{
Yin1 yin;
int t1=yin.plus1(yin.a,yin.b,yin.c);//值传递，复制a，b，c到x，y，z，将x+y赋给z，返回z的副本给t1
cout <<"使用值传递：" << endl;
cout << "yin.a="<< yin.a << ";yin.b="<< yin.b << ";yin.c=" << yin.c << endl;
cout <<"返回值t=" << t1 <<  endl;


yin.c=0;
int *t2=yin.plus2(&yin.a,&yin.b,&yin.c); //指针传递，将a,b,c的地址复制给x,y,z，能够修改a,b,c
cout <<"使用指针传递，改变了c的值：" << endl;
cout << "yin.a="<< yin.a << ";yin.b="<< yin.b << ";yin.c=" << yin.c << endl;
cout <<"返回值t2=" << *t2 <<  endl;


yin.c=0;
int t3=yin.plus3(yin.a,yin.b,yin.c); //引用，x,y,z作为a,b,c的引用，能够修改a,b,c
cout <<"使用引用传递，改变了c的值：" << endl;
cout << "yin.a="<< yin.a << ";yin.b="<< yin.b << ";yin.c=" << yin.c << endl;
cout <<"返回值t3=" << t3 <<  endl;


yin.plus3(yin.a,yin.b,yin.c)=100; //合法，因为返回的是引用，指向的是可修改的内存块


yin.c=0;
int t4=yin.plus4(yin.a,yin.b,yin.c); //引用，c为const
cout <<"使用引用传递，不能改变c的值：" << endl;
cout << "yin.a="<< yin.a << ";yin.b="<< yin.b << ";yin.c=" << yin.c << endl;
cout <<"返回值t4=" << t4 <<  endl;


yin.c=0;
int t5=yin.plus5(yin.a,yin.b,yin.c); //引用，a,b,c为const
cout <<"使用引用传递，不能改变a，b，c的值：" << endl;
cout << "yin.a="<< yin.a << ";yin.b="<< yin.b << ";yin.c=" << yin.c << endl;
cout <<"返回值t5=" << t5 <<  endl;


yin.c=0;
int t6=yin.plus6(yin.a,yin.b,yin.c); //引用，a,b,c为const
cout <<"使用引用传递，不能改变a，b，c的值：" << endl;
cout << "yin.a="<< yin.a << ";yin.b="<< yin.b << ";yin.c=" << yin.c << endl;
cout <<"返回值t6=" << t6 <<  endl;


//指向类的引用
string ss="在括号里";string ss2;
string s1=yin.plus7(ss,ss2);
cout <<"前：ss="<< ss << "；后：ss2="<< ss2 << ";s1=" << s1 <<endl;


return 0;
}