C++入门（二）

 返回随机值

 但是为什么函数的返回值还能被接收呢？

这是因为系统会创建一个临时变量，函数返回值会赋给这个临时变量，同时这个临时变量又会赋给要赋给的变量；而这种临时变量具有常性，只能赋给了一个类型为const int 的临时变量，而ra作为int类型的引用，显然是无法接收这个具有常性的临时变量。

 先看下列代码的返回值：12

 下面函数可以用引用返回（c储存在静态区中，函数栈帧销毁，静态区不销毁）

 引用的ret变量越界，但不报错->越界不一定报错

注意： 如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已 经还给系统了，则必须使用传值返回。

 当引用作为函数返回值时,被引用的对象其作用域必须是有效范围,所以返回一个对局部变量的引用是不合法的,应该是返回值为全局变量或则static修饰的变量.

引用作为引用实体的别名，没有独立空间，与实体共用同一块空间，但是在底层实现上，引用和指针的实现方式是一样的（可以通过编译器反汇编观察到）。

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

#include 
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& 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; 
}

 6.5.1 值和引用的作为返回值类型的性能比较

#include 
struct A{ int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a;}
// 引用返回
A& TestFunc2(){ return a;}
void TestReturnByRefOrValue()
{
 // 以值作为函数的返回值类型
 size_t begin1 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc1();
 size_t end1 = clock();
 // 以引用作为函数的返回值类型
 size_t begin2 = clock();
 for (size_t i = 0; i < 100000; ++i)
 TestFunc2();
 size_t end2 = clock();
 // 计算两个函数运算完成之后的时间
 cout << "TestFunc1 time:" << end1 - begin1 << endl;
 cout << "TestFunc2 time:" << end2 - begin2 << endl; 
}

 通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
 int a = 10;
 int& ra = a;
 
 cout<<"&a = "<<&a<

int TestAuto()
{
 return 10; }
int main()
{
 int a = 10;
 auto b = a;
 auto c = 'a';
 auto d = TestAuto();
 
 cout << typeid(b).name() << endl;
 cout << typeid(c).name() << endl;
 cout << typeid(d).name() << endl;
 
 //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
 return 0; 
}

int main()
{
 int x = 10;
 auto a = &x;
 auto* b = &x;
 auto& c = x;
 cout << typeid(a).name() << endl;
 cout << typeid(b).name() << endl;
 cout << typeid(c).name() << endl;
 *a = 20;
 *b = 30;
 c = 40;
 return 0; 
}

void TestAuto()
{
 auto a = 1, b = 2; 
 auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

void TestAuto()
{
 int a[] = {1,2,3};
 auto b[] = {4，5，6};
}

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
 array[i] *= 2;
 
 for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
 cout << *p << endl; 
}

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for(auto& e : array)
 e *= 2;
 
 for(auto e : array)
 cout << e << " ";
 
 return 0; 
}

void TestFor(int array[])
{
 for(auto& e : array)
 cout<< e <

void TestPtr()
{
 int* p1 = NULL;
 int* p2 = 0;
 
 // ……
}

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

void f(int) {
 cout<<"f(int)"<