C++初阶 —— 引用

int main()
{
  //有一块空间a,后面给a取了三个别名b、c、d
  int a = 10;
  int& b = a;
  int& c = a;
  int& d = b;
  //char& d = a;//err,引用类型和引用实体不是同类型(这里有争议————char a = b[int类型],留个悬念,下面会解答)
  //会被修改
  c = 20;
  d = 30;
  return 0;
}

void TestConstRef()
{
  const int a = 10;
  //int& ra = a; //该语句编译时会出错，a为常量;由const int到int
  const int& ra = a;//ok
  int b = 20;
  const int& c = b; //ok,由int到const int
  //b可以改,c只能读不能写
  b = 30;
  //c = 30;//err
  //b、c分别起的别名的权限可以是不变或缩小
  int& d = b;//ok
  //int& e = c//err
  const int& e = c;//ok
  //int& f = 10; // 该语句编译时会出错，b为常量
  const int& g = 10;//ok
  int h = 10;
  double i = h;//ok
  //double& j = h;//err
  const double& j = h;//ok
  //?为啥h能赋值给i了(隐式类型转换)，而给h起一个double类型的别名却不行————如果是仅仅是类型的问题那为啥加上const就行了？
  //double i = h;并不是直接把h给i,而是在它们中间产生了一个临时变量(double类型、常量),并利用这个临时变量赋值
  //也就是说const double& j = h;就意味着j不是直接变成h的别名,而是变成临时变量(doublde类型)的别名,但是这个临时变量是一个常量,这也解释了为啥需要加上const
}

typedef struct Stack
{
  int* a;
  int top;
  int capacity;
}ST;
void InitStack(ST& s)//传引用是为了形参的改变影响实参
{//...}
void PrintStack(const ST& s)//1.传引用是为了减少拷贝 2. 同时保护实参不会被修改
{//...}
void Test(const int& n)//即可以接收变量，也可以接收常量
{//...}
int main()
{
  ST st;
  InitStack(st);
  //...
  PrintStack(st);
  int i = 10;
  Test(i);
  Test(20);
  return 0;
}

void Swap1(int* p1, int* p2)
{
  int temp = *p1;
  *p1 = *p2;
  *p2 = temp;
}
void Swap2(int& rx, int& ry)
{
  int temp = rx;
  rx = ry;
  ry = temp;
}
int main()
{
  int x = 3, y = 5;
  Swap1(&x, &y);//C传参
  Swap2(x, y);//C++传参
  return 0;
}

#include <time.h>
#include<iostream>
using namespace std;
struct A { int a[10000]; };
A a;
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
A TestFunc3() { return a; }
A& TestFunc4() { return a; }
void TestRefAndValue()
{
  A a;
  // 以值作为函数参数
  size_t begin1 = clock();
  for (size_t i = 0; i < 10000; ++i)
    TestFunc1(a);
  size_t end1 = clock();
  // 以引用作为函数参数
  size_t begin2 = clock();
  for (size_t i = 0; i < 10000; ++i)
    TestFunc2(a);
  size_t end2 = clock();
  // 分别计算两个函数运行结束后的时间
  cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
  cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
void TestReturnByRefOrValue()
{
  // 以值作为函数的返回值类型
  size_t begin1 = clock();
  for (size_t i = 0; i < 100000; ++i)
    TestFunc3();
  size_t end1 = clock();
  // 以引用作为函数的返回值类型
  size_t begin2 = clock();
  for (size_t i = 0; i < 100000; ++i)
    TestFunc4();
  size_t end2 = clock();
  // 计算两个函数运算完成之后的时间
  cout << "TestFunc1 time:" << end1 - begin1 << endl;
  cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
  //传值、传引用效率比较
  TestRefAndValue();
  cout << "----------cut----------" << endl;
  //值和引用作为返回值类型的性能比较
  TestReturnByRefOrValue();
  return 0;
}