C++学习（1）

1.引用

• 引用,某个变量的别名，等价于这个变量，相当于这个变量的一个别名。
• 概念：定义引用是一定要将其初始化成引用某个变量。
  初始化后，它就一直引用该变量，不会再引用别的变量。
  引用只能引用变量，不能引用常量和表达式。

//示例1：初始化为引用某个变量
    int n = 4;
    int & r = n; //r引用了n,r的类型是 int &
    r = 4;
    cout << r << endl; //4
    cout << n << endl; //4
    n = 5;
    cout << r << endl; //5

//示例2：引用作为函数的返回值
    int n = 4;
    int & SetValue() { return n; }
    int main()
    {
        SetValue() = 40;
        cout << n;
        return 0;
    }

//示例3：前加const关键字，即为“常引用”
    int n1;
    const int & n2 = n1;
    /*
    !!! 注意不能通过常引用去修改其引用的内容
    int n =100;
    const int &r = n;
    r = 200;  //编译出错
    n = 300;
    */

常引用和非常引用的转换
const T & 和 T & 是不同的类型
T & 类型的引用或T类型的变量可以用来初始化 const T &类型的引用。反过来则不可以这样操作。

2.const

• 定义常量

    const int MAX_VAL = 23;
    const string SCHOOL_NAME = "Peking University";

• 定义常量指针
  函数参数为常量指针时， 可避免函数内容不小心改变参数指针所指向地方的内容。

//不可通过常量指针修改其指向的内容
    int n,m;
    const int *p = &n;
    *p = 5; //编译出错
    n = 4;  //ok
    p = &m; //ok，常量指针的指向可以变化
    

//不能把常量指针赋值给非常量指针，反过来可以
    const int *p1;
    int *p2;
    p1 = p2; //ok
    p2 = p1; //常量不可以赋值给常量
    p2 = (int *)p1; //ok,强制类型转换
    

• 定义常引用
  不能通过常引用修改其引用的变量

    int n;
    const int &r = n;
    r = 5; //error
    n = 4; //ok

3.动态内存分配

动态内存分配：用new运算符实现动态内存分配

• 分配一个变量
  p = new T;

  T是任意类型名，P是类型为T*的指针，
  动态分配出一片大小为sizeof(T)字节的内存空间，
  并且该存储空间的起始地址赋值给P。

    int *pn;
    pn = new int;
    *pn = 5;

• 分配一个数组
  P = new T[N];

  T:任意类型名
  P:类型为T的指针
  N:要分配的数组元素的个数，可以是整形表达式
  动态分配出一片大小为sizeof(T)N字节的内存空间，并且将该内存空间的起始地址赋值给P。

    int *pn;
    int i = 5;
    pn = new int[i*20];
    pn[0] =20;
    pn[100] = 30; //编译没问题，运行时导致数组越界

用delete运算符释放动态分配的数组

• 用new动态分配的内存空间，一定要用delete运算符进行释放

    int *pn;
    pn = new int;
    *pn = 5;
    delete p;
    delete p; //导致异常，一片空间不能被delete多次

    //对于数组
    delect []指针； // 该指针必须指向new出来的数组
    
    int *pn = new int[20];
    pn[0] =20;
    delete [] p;

4.函数重载

• 定义：一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载

• 函数的缺省参数：
  C++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，那么调用函数的时候若相应位置不写参数，参数就是缺省值。