C++第二课(2013.9.27 )

 //引用的作用：代码简洁
 //形参和实参同地址，实现的方式和指针的一样
 //引用和指针没有本质的区别

 //强转引用
 float f = 3.14f;
 cout<< hex << (int&)f << endl;
 cout<< hex << *(int*)&f <<endl;//两式是等价的

 cout<< hex << (float&)(int&)f << endl;
 cout<< hex << *(float*)&(*(int*)&f) << endl;//两式是等价的

 //引用类型和指针类型的区别
 char ch = 'a', ch2 = 'b';

 //1.引用不能为 NULL ,必须初始化，指针可以为 NULL
 // char& Ref = NULL;   错误：引用不能为 NULL
 // char& Ref = 123;    错误：引用不能为常量
 // char& Ref ;         错误：引用必须初始化
    char& Ref = ch;     //引用的初始化
    Ref = ;

 //2.引用一旦绑定无法解除， 指针可以
    Ref = ch2; //这里 Ref 的地址和 ch 的地址是一样，而不是 ch2 的地址

 //3.没有二级引用，有二级指针

 //引用当作函数的返回值
 //1.当返回值为引用时，不能返回局部变量或形参变量
 //使用场合：返回返回值当左值

 int& fun()
 {
     //全局变量
     return g_nNum;
 }

 int& fun1(int *pNum)
 {
     //实际上返回值的是实参
     return *pNum;
 }

 int nN = fun1();
 int& r = fun1();

 //返回值当左值
 fun1() = ;

 //const的用法
 //1.不能当左值，通常用来替代无参数宏
     不能把 const 转化为 非const
     float const PI = 3.14f;
     const float PI = 3.14f;

 //2.const 是编译器做限制
 float Area (float R)
 {
     float* pf = NULL;
     const float PI = 3.14f;//此时的 PI 是在栈中不是在堆中
     pf = (float*)&PI;
     *pf = ; //此时 PI 的值改变为 2
     cout<< PI << endl;
 }

  char szBuff[] = "Hello";

 //指针的值可以修改，指向的内容不能被修改
   const char *psz1 = szBuff;
   psz1 = NULL;
   //psz1[0] = 'a'; //错误

 //指针的值可以修改，指向的内容不能被修改
     char const *psz2 = szBuff;
   psz2 = NULL;
   //psz2[0] = 'b'; //错误

 //指针的值不能修改，指向的内容可以修改
     char * const psz3 = szBuff;
     //psz3 = NULL;
     psz3[] = 'c';

 //指针的值不能修改，指向的内容不能修改
     char const * const psz4 = szBuff;
     //psz4 = NULL;
     //psz4[0] = 'd';

 //指针的值不能修改，指向的内容不能修改
     const char * const psz5 = szBuff;
     //psz5 = NULL;
     //psz5[0] = 'd';

 总结：
 .当 const 在 * 的左边时，指针所指向的内容不能修改
 .当 const 在 * 的右边时，指针的值不能修改
 .当 * 的两边都有 const 时，指针的值和指针所指向的内容都不能修改

 void fun( const int& nN1, const int& nN2)
 {
     //nN1、nN2 的值都不能被改变
     cout<<nN1<<' '<<nN2;
 }

 调用函数--fun(, );  ------->输出：
 const引用，首先为 2和4 申请堆空间，然后地址
 即 const--引用支持 常量 传给引用

 //内联 inline
 //注意：加了inline 编译器认为函数简单就内联，否者不内联(没有if for while。。。)
 //1.通常用来替代有参宏
 //2.比有参宏多了类型检查
 //3.debug版不内联
 //4.可以在头文件声明定义放一起,多文件包含没问题
 //在类机构中，在类体内定义的成员函数都是内联函数

 #define ADD(x,y) ((x) + (y))

 inline int Add(int nNum1, int nNum2)
 {
   return nNum1 + nNum2;
 }

 int main(int argc, char* argv[])
 {
   cout << Add(, ) << endl;
   cout << Add(, ) << endl;
   cout << Add(, ) << endl;

   cout << ADD(1.2, ) << endl;
     return ;
 }