布尔类型、操作符别名、C++函数、动态内存分配（newdelete）、引用（day02）

六 C++的布尔类型
1 bool类型是C++中基本类型，专门表示逻辑值:true/false
2 bool在内存上占一个字节：1表示true，0表示false
3 bool类型可以接收任意类型和表达式的结果，其值非0则为true,值为0则为false

七 操作符别名（了解）
&&  --》 and
||  --》 or
{   --》 <%
}   --》 %>
...

八 C++函数
1 函数重载
strcpy(char*,const char*)
strcpy(char*,const char*,int)
1）定义
  在相同的作用域，定义同名的函数，但是它们的参数表必须有所区分，这样的函数构成重载关系。
  注：重载和返回返回类型无关
2）函数重载匹配
  调用重载关系函数函数，编译器根据实参与形参匹配程度，自动选择最优的重载版本。
  当前编译器的匹配原则 g++ V4.8.1：
  完全匹配>常量转换>升级转换>降级转换>省略号匹配
3）函数重载原理
  C++编译器通过函数换名，将参数表的信息整合到新的函数名中，实现解决函数重载与名字冲突的矛盾
eg：
  代码里面写的函数：
  void func(int i,double d);
  void func(int i);
  编译之后函数名将改变：
  func(int,double)-->_Z4funcid
  func(int)-->_Z4funci
  
  笔试题：函数声明中加入extern "C"作用？
  要求C++编译器不会函数做换名，便于C程序调用该函数。
  语法：
  extern "C" void func(..){..}
  ----------------------------
  extern "C"{
      void func1(){}
      void func2(){}
  }
-------
2 函数的缺省参数(默认实参)
1)可以为函数的部分参数和全部参数指定缺省值，调用该函数，如果不给实参，就取缺省值作为相应的形参值。
eg:
  void func(int a,int b,int flag=0){..}
  int main(void){
      func(10,20,1);
      func(10,20);
  }
2)缺省参数必须靠右，如果一个参数有缺省值，那么这个参数的右侧所有参数都必须带有缺省值。

3）如果函数的定义和声明分开，缺省参数应该写在函数的声明部分，而定义部分不写。
void func(){..} -->函数的定义
void func();    -->函数的声明

3 函数的哑元参数
1）定义：只有类型而没有变量名的形参称为哑元
eg：
 void func(int a,int/*哑元*/){}
2）使用哑元的场景
--》为了兼容旧代码
算法库:
     void math_func(int a,int b){...}
使用者：
    int main(void){
        math_func(10,20);
        ...
        math_func(20,30);
    }
------------------------------------
升级算法库:
     void math_func(int a,int=0){...}

--》操作符重载时，区分前后++/--（后面讲）

4 内联函数(inline)
//笔试题：inline关键字的作用
1）定义
  使用inline关键修饰的函数，表示这个函数是内联函数，编译器将尝试做内联优化，避免函数调用的开销，提高代码的执行的效率。
2）适用场景
--》多次调用的小而简单的函数适合内联
--》调用次数极少获取大而复杂的函数不适合内联
--》递归函数不适合内联

注：内联只是一种建议而不是强制要求，能否内联主要取决于编译器，有些函数不加inline关键字修改也会被默认处理为内联，有些函数即便加了inline关键字也会被编译器忽略。
---------------------
笔试题：
1）代码片段1
for(int i=0;i<100000;i++)
   for(int j=0;j<100;j++)
      ... 
2）代码片段2
for(int i=0;i<100;i++)
   for(int j=0;j<100000;j++)
      ...
---------------------
九 C++的动态内存分配
//笔试题：C++中new/delete和C中malloc和free区别
1 回顾C中动态分配
1）分配：malloc()
2）释放：free()
3）错误：返回值
eg:
  int* p = (int*)malloc(sizeof(int));
  *p = 100;
  free(p);//避免泄露
  p = NULL;//避免使用野指针

2 C++使用运算符分配动态内存
1）分配：new、new[]
2）释放：delete、delete[]
3）错误处理：异常(后面讲)
eg：
   //int* p = new int;//分配不初始化
   //*p = 100;
   int* p = new int(100);//分配同时初始化
   delete p;
   p = NULL;
   -----------------
   int* parr = new int[10];//分配数组
   parr[0]=10;
   parr[1]=20;
   ...
   delete[] parr;
   parr = NULL;
--------------------------
十 C++的引用(Reference)
1 定义
1）引用就是某个变量的别名，对引用的操作与对该变量的操作完全相同。
2）语法规则
 类型& 引用名 = 变量名;
 注：引用在定义时必须初始化，而且初始化以后不能修改引用的目标。
 注：引用类型和它所绑定的目标变量类型要一致
 eg:
 int a = 10;
 int& b = a;//b就是a的别名
 b++；
 cout << a << endl;//11
 int c = 20;
 b = c;//将c的值赋值给b(a)
 cout << a << endl;//20
 
2 常引用
1）定义引用时加const修饰，即为常引用，不能通过常引用修改引用的目标。
  const 类型& 引用名 = 变量名;
eg：
  int a = 10；
  const int& b = a;//b就是a的常引用
  b = 200;//error
2）普通的引用只能引用左值，而常引用也叫做万能引用，既能引用左值，也能引用右值。
==================
注：关于左值和右值
1）左值：可以放在赋值运算符的左侧
-->普通变量都是左值
-->前++/--表达式结果是左值
-->赋值表达式的结果是左值
eg:
  int a = 1;
  ++a = 20;//ok
  cout << a << endl;//20
  ++++++a;
  cout << a << endl;//23
eg:
  int a = 3,b = 5;
  int c = 0;
  (c = a) = b;//ok
  cout << c << endl;//5

2）右值：只能放在赋值运算符右侧
--》字面值常量
--》大多数表达式的值
eg:
  int a = 3,b = 5;
  (a + b) = 10;//error,a+b的结果是右值  
--》函数返回值
eg:
  int foo(void){
      int a = 100;
      return a;//分配临时变量=a
  }
  int main(void)
  {
      int res = foo();//函数调用结果是临时变量
      cout << res << endl;//100
      int& r = foo();//error
      const int& cr = foo();
      return 0;
  }