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;

//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() = 2;


//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 = 2; //此时 PI 的值改变为 2
    cout<< PI << endl;
}

 char szBuff[10] = "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[0] = 'c';
    
//指针的值不能修改，指向的内容不能修改
    char const * const psz4 = szBuff;
    //psz4 = NULL;
    //psz4[0] = 'd';
    
//指针的值不能修改，指向的内容不能修改
    const char * const psz5 = szBuff;
    //psz5 = NULL;
    //psz5[0] = 'd';
    
总结：
1.当 const 在 * 的左边时，指针所指向的内容不能修改
2.当 const 在 * 的右边时，指针的值不能修改
3.当 * 的两边都有 const 时，指针的值和指针所指向的内容都不能修改

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

调用函数--fun(2, 4);  ------->输出：2 4
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(1, 2) << endl;
  cout << Add(2, 2) << endl;
  cout << Add(3, 2) << endl;

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