C++引用、类型转换、类和对象（day03）

十 C++的引用(Reference)

 引用型函数参数
）将引用用于函数的参数，可以修改实参变量的值，同时也能减小函数调用的开销。
）引用参数有可能意外修饰实参的值，如果不希望修改实参变量本身，可以将其定义为常引用，提高传参效率的同时还可以接收常量型的实参。 

 引用型函数返回值
）可以将函数返回类型声明为引用，避免函数返回值所带来的开销。
）一个函数返回类型被声明为引用，那么该函数返回值可以是一个左值。
）为了避免在函数外部修改引用的目标，可以为该引用附加常属性。
eg：
  int& foo(void){
     static int a = ;
     return a;
  }
  int main(void)
  {
        foo() = ;//ok
  }
注：不要返回局部变量的引用，因为所引用的目标内存会在函数返回以后被释放，危险！
但是可以返回成员变量、静态变量、全局变量的引用

//笔试题：引用和指针的区别...
 引用和指针
）从C语言角度，引用的本质就是指针，但是在C++中推荐使用引用而不是指针。
eg:
   double d = 3.14;
   double& rd = d;
   double* const pd = &d;
   rd <=等价=>*pd
）指针定义可以不做初始化，其目标可以修改(指针常量除外)，而引用必须做初始化，而且一旦初始化所引用的目标能再改变。
eg:
  int a=,b=;
  int* p;//ok,可以不初始化
  //int& r;//error
  p = &a;
  p = &b;
  int& r = a;
  r = b;//不是修改引用的目标，而是对r(a)进行赋值

//后面了解
）可以定义指针的指针（二级指针），但是不能定义引用的指针
eg:
  int a = ;
  int* p = &a;
  int** pp = &p;

  int& r = a;
  int& * pr = &r;//error
  int* pr = &r;//ok，是一个普通的指针
）可以定义指针的引用,但是不能定义引用的引用
eg:
  int a = ;
  int* p = &a;
  int* & rp = p;//ok,指针的引用
  -----------
  int& r = a;
  int&& rr = r;//error,在C++11中称为右值引用
  int& r2 = r;//ok，不能称为引用的引用，只是一个普通的引用，相当于给a再起一个别名。

）可以指针数组，但是不能引用数组
eg:
  int a=,b=,c=;
  int* parr[] = {&a,&b,&c};//指针数组
  int& rarr[] = {a,b,c};//error
）可以定义数组引用
eg：
  int arr[] = {,,};
  //rarr称为数组引用,给数组起一个别名
  int (&rarr)[] = arr;//ok
  arr[] <-等价-> rarr[]
）和函数指针一样，可以定义函数引用，语法和函数指针一致。
eg：
  void func(int a,int b){...}
  int main(void){
       //定义和使用函数指针
       void (*pfunc)(int,int) = func;
       pfunc(,);
       //定义和使用函数引用
       void (&rfunc)(int,int) = func;
       rfunc(,);
  }
======================================
十一 类型转换
 隐式类型转换
eg:
  char c = 'A';
  int n = c;//隐式类型转换
  -----------
  void foo(int n){..}
  foo(c);//隐式类型转换
  -----------
  int foo(void){
        char c = 'A';
        return c;//隐式类型转换
  }
 强制类型转换
eg:
  char c = 'A';
  int n = (int)c;//C风格的强制转换
  int n = int(c);//C++风格的强制转换

 C++增加了四种操作符形式的显式类型转换
）静态类型转换
语法：
   目标类型变量 =
           static_cast<目标类型>(源类型变量);
适用场景：
   用于将void*转换为其它类型指针。
eg:
    int a = ;
    void* pv = &a;//ok
    int* pi = pv; //error
    int* pi = static_cast<int*>(pv);//ok

）动态类型转换(后面讲)
语法：
   目标类型变量 =
           dynamic_cast<目标类型>(源类型变量);
）常类型转换
语法：
   目标类型变量 =
           const_cast<目标类型>(源类型变量);
适用场景：用于去除一个指针或引用的常属性
eg:
   int a = ;
   const int* pa = &a;
   *pa = ;//error
   int* pa2 = const_cast<int*>(pa);
   *pa2 = ;//ok
   -------------------
   const int& r = a;
   r = ;//error
   int& r2 = const_cast<int&>(r);
   r2 = ;//ok

）重解释类型转换
语法：
   目标类型变量 =
        reinterpret_cast<目标类型>(源类型变量);
适用场景:
   -->任意类型的指针或引用之间的转换
   -->在指针和整型数之间的转换
   eg:
     int addr = 0x12345678;
     int* p =
         reinterpret_cast<int*>(0x12345678);
     *p = ;
======================
小结：
 慎用宏,用const、enum、inline替换
#define PAI 3.14 --》const double PAI = 3.14 

#define STATE_SLEEP 0
#define STATE_RUN    1
#define STATE_STOP  2
--》enum STATE{SLEEP,RUN,STOP};

#define max(a,b) ((a)>(b)?(a):(b))
--> inline int max(int a,int b){
        return a > b ? a : b;
    }
 变量随用随声明同时初始化

 尽量使用new/delete分配，取代malloc/free

 少用void*、指针计算、联合体、强制转换

 尽量使用string表示字符串，少用C中的char*表示的字符串

====================================
十二 类和对象//了解
 什么是对象？
  万物皆对象，任何一种事物都可以看做是对象。

 如何描述对象？
  通过对象的属性(名词、数量词、形容词)和行为(动词)描述和表达对象。

 面向对象的程序设计
  对自然世界中对象观察引入到编程实践的一种理念和方法。这种方法称为"数据抽象",即在描述对象时把细节的东西剥离出去，只考虑一般性的，有规律性的和统一性的东西。

 什么是类?
  类是将多个对象的共性提取出来定义的一种新的数据类型，是对 对象的属性和行为的抽象描述。