1  引用的应用

1.1  数据传递--值传递

        C语言只要涉及数据传递（例如：初始化、赋值、传参、返回值），

        都为值传递（将数据复制一份给到目标内存）。

// value.cpp 值传递：将数据复制一份给别人
#include <iostream>
using namespace std;void foo( int x ) {  }int bar( ) {int m = 8888;return m;
}int main( void ) {int a = 10; // 初始化a = 20; // 赋值foo( a ); // 传参/*|8888|*/bar( ); // 返回值return 0;
}

        C++语言因为有引用，可以不做值传递。 

        1）引用型形参：函数的形参是实参的别名，避免对象复制的开销。

                非常引用型参数，可在函数中修改实参值；

                常引用型参数，防止了对实参的意外修改，  也接受常量型实参(右值)。

// vparam.cpp 引用 作为函数的 形参
// 当我们在设计一个函数时，只要可以确定在函数内部绝对不修改实参，那么大胆的加上const
#include <iostream>
using namespace std;void Swap( int* x, int* y ) { // int z = *x;*x = *y;*y = z;
}void Swap( int& x, int& y ) { // 非常引用型 形参:函数内部可以直接修改实参int z = x;x = y;y = z;
}
void Printer( const int& x, const int& y ) { // 常引用型 形参:能够防止意外修改实参
//  x = 888; // 编译器会提醒我们read-only  (打印机就应该原样打印哦)cout << x << ' ' << y << endl;
}int main( void ) {int a=10, b=20;Swap( a, b );
//  Swap( &a, &b ); // 这种写法并不直观cout << "a=" << a << ", b=" << b << endl;Print( a, b );Print( 888, 999 ); //接受常亮型实参(右值)return 0;
}

         2）引用型的返回值：从函数中返回引用，一定要保证函数返回后，该引用的目标依然有效

                        -可以返回全局、静态变量的引用

                        -可以返回在堆中动态创建(new)的对象的引用

                        -可以返回引用型参数本身

                        -可以返回成员变量的引用 

                        -可以返回调用对象自身的引用 

                        -不能返回局部变量的引用

               非常引用型返回值：通过引用可以修改目标

               常引用型返回值：通过引用不能修改目标

// vreturn.cpp 引用 作为函数的 返回值
#include <iostream>
using namespace std;
int g_value = 0;
int& foo() { // 非常引用型 返回值:可以通过引用修改目标return g_value;
}
const int& fooo() { // 常引用型 返回值:不可以通过引用修改目标return g_value;
}int& bar() {static int s_value=0;//这行代码是在程序启动时就执行,而且只执行1次,不是每次调bar都执行cout << "s_value=" << s_value << endl;return s_value;
}int& hum() {int* p = new int;return *p;
}int& fun( int& x ) {// ...return x; // 返回 引用型 参数本身
}
/*
int& boo() {int m = 666;return m; // 不要返回局部变量的引用
}
*/
int main( void ) {foo() = 100;cout << "g_value=" << g_value << endl;//    fooo() = 888; // readonly - errorbar() = 200;bar();hum() = 300;int a_value = 0;fun(a_value) = 400;cout << "a_value=" << a_value << endl;//  boo();return 0;
}

        在实现(汇编)层面，引用就是指针，但在C++语言层面，引用不是实体类型，由此推导出，C++语言层面，引用与指针存在明显的差别：

        1）指针可以不初始化，其目标可在初始化后随意变更（指针常量除外），

              引用必须初始化，且一旦初始化就无法变更其目标。

        2）存在空指针，不存在空引用。

        3）存在指向指针的指针，不存在引用的引用。

        4）存在指针的引用，不存在引用的指针。

        5）存在指针数组，不存在引用数组，但存在数组引用。

// poi_ref 指针 和 引用 的差别
#include <iostream>
using namespace std;int main( void ) {int a=10, b=20;int* pa = &a; // 指针可以不做初始化,也可以做初始化pa = &b; // 指针可以随意变更它所指向的目标内存int& ra = a; // 引用必须初始化ra = b; // 引用不可以随意变更它所代表的目标内存( ra仍然是a的别名 )pa = NULL; // 存在空指针
//  ra = NULL; // 不存在空引用int** ppa = &pa; // 存在二级指针
//  int&& rra = ra;  // 不存在二级引用int* &rpa = pa; // 存在指针的引用  ！！
//  int& *pra = &ra; // 不存在引用的指针int* p = &ra; // 这里取的并不是引用本身的地址，而是引用的目标内存a的地址int x, y, z;int*parr[3] = {&x, &y, &z}; // 存在指针的数组
//  int&rarr[3] = {x,y,z}; // 不存在引用的数组int arr[3];int(&rr)[3] = arr; // 存在数组的引用return 0;
}

 

2  显示类型转换(强转)

        C风格的显示类型转换：        (int)a 

        C++风格的显示类型转换：    int(a) 

// convert_pre.cpp 显式(强制)类型转换
#include <iostream>
using namespace std;int main( void ) {int a;  double b;   float c;    short d;    char e;// 任何基本类型变量之间都可以 隐式转换a = b = c = d = e;e = d = c = b = a;// 任何其他类型的指针 到 void* 都可以隐式转换void* pv = &a;pv = &b;pv = &c;pv = &d;pv = &e;// void* 到 任何其他类型的指针 都必须强转（显式转换）int* pa = (int*)(pv);double* pb = (double*)(pv);float* pc = (float*)(pv);short* pd = (short*)(pv);char* pe = (char*)(pv);// 任何类型的 非常指针 到 同类型的常指针 都可以隐式转换const int* cpa = pa;const double* cpb = pb;const float* cpc = pc;const short* cpd = pd;const char* cpe = pe;// 任何类型的 常指针 到 同类型非常指针 都必须强转pa = (int*)(cpa);pb = (double*)(cpb);pc = (float*)(cpc);pd = (short*)(cpd);pe = (char*)(cpe);return 0;
}

3  温和强转

3.1  静态类型转换

                static_cast<目标类型>(源类型变量)

                隐式类型转换的逆转换（去常除外）

                自定义类型转换 

3.2  动态类型转换 

                dynamic_cast<目标类型>(源类型变量) 

                多态父子类指针或引用之间的转换 

3.3  常类型转换

                const_cast<目标类型>(源类型变量)

                去除指针或引用上的const属性

3.4  重解释类型转换

                reinterpret_cast<目标类型>(源类型变量)

                任意类型的指针之间的转换

                任意类型的引用之间的转换

                任意类型的指针和整型之间的转换

// convert.cpp 显式(强制)类型转换
#include <iostream>
using namespace std;int main( void ) {int a;  double b;   float c;    short d;    char e;// 任何基本类型变量之间都可以 隐式转换a = b = c = d = e;e = d = c = b = a;// 任何其他类型的指针 到 void* 都可以隐式转换void* pv = &a; // int*->void*pv = &b;pv = &c;pv = &d;pv = &e;// void* 到 任何其他类型的指针 都必须强转（显式转换）*************int* pa = static_cast<int*>(pv); // void*->int*的反向int*->void*可以隐式double* pb = static_cast<double*>(pv);float* pc = static_cast<float*>(pv);short* pd = static_cast<short*>(pv);char* pe = static_cast<char*>(pv);// 任何类型的 非常指针 到 同类型的常指针 都可以隐式转换const int* cpa = pa; // int*-->const int*const double* cpb = pb;const float* cpc = pc;const short* cpd = pd;const char* cpe = pe;// 任何类型的 常指针 到 同类型非常指针 都必须强转***************pa = const_cast<int*>(cpa); // 去常属性pb = const_cast<double*>(cpb);pc = const_cast<float*>(cpc);pd = const_cast<short*>(cpd);pe = const_cast<char*>(cpe);// 除了void*外，其他任何类型的指针之间都必须强转*************pa = reinterpret_cast<int*>(pb); // double*-->int*pb = reinterpret_cast<double*>(1000); // int-->double*return 0;
}

 

4  面向对象

4.1  what

        一切皆对象。

        把大型软件看成是由多个对象组成的团推。

        对象拥有足够的智能，能够理解来自其他对象的信息，并以适当的行为作出反应。

        面向对象的三大特征：封装、继承、多态。

4.2  why

        相比分而治之的结构化程序设计，强调大处着眼的面向对象程序设计思想，更适合开发大型软件。

        得益于代码复用等面向对象的固有特征，软件开发的效率获得极大提升，成本却大幅降低。

4.3  how

        至少掌握一种面向对象的程序设计语言，如C++

        深入理解封装、继承、多态等面向对象的重要概念

        学习设计模式，源自多年成功经验的积累总结。

第三个错误：等号右边是右值，故等号左边应为万能引用int* const &r :

//test.cpp
#include <iostream>
using namespace std;int main( void ) {int arr[9] = {9,3,1,4,2,7,5,8,6};int* p = arr;       // 正确  &arr[0]int(*pp)[9] = &arr; // 正确//  int* &r = arr;      // 错误 &arr[0]     int* const& r = arr;// 正确int(&rr)[9] = arr;  // 正确
}