c++基础

1. 引用

---

某个变量的引用，等价于这个变量，相当于这个变量的别名；（概念 > ）

定义引用时一定要初始化成引用某个变量，初始化后，它就一直引用该变量，不会再引用别的变量。

类型名 & 引用名 = 某变量名
int n = 4;
int & r = n; //r引用了n, r的类型是 int &

int a = 1, b = 2;
int & r = a;
r = b;
r = 7;
cout << a << endl;//a=7,由r引用a,r=7=a;此处r仅仅引用了a，会一直引用该变量

交换两个整型变量值的函数：

void swap (int & a, int & b)
{
    int tmp;
    tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1, n2);//n1, n2的值被交换

• 引用作为函数的返回值

int n = 4;
int & SetValue() {return n;}
int main()
{
    SetValue() = 40;
    cout <<n;
    return 0;
}//n = 40

• 常引用

定义时，前面添加关键字–const, 即为 常引用

int n;
const int & r = n;  //r的类型是 const int &，r不能被修改
r = 5;  //error
n = 4;  //ok

不能通过常引用修改其引用的内容

2. const关键字

---

• 定义常量（支持类型检查）
• 定义常量指针

不可通过常量指针修改其指向的内容

int n, m;
const int * p = & n; //常量指针， p->n
*p = 5;//出错，不可通过p来修改
n = 4;
p = &m;

不能把常量指针赋值给非常量指针，反过来可以

const int * p1; int *p2;
p1 = p2;
p2 = p1;  //常量指针赋值给非常量指针，非法
p2 = (int *) p1;  //ok,能通过强制类型转换

• 定义常量指针

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

void MyPrintf(const char * p)
{
    strcpy(p, "this");//error, 存在修改p的可能，p为常量字符型，strcpy为char
    printf("%s", p);  //ok
}

• 定义常引用

不能通过常引用修改其引用的变量，见第一节引用的内容

3. 动态内存分配

---

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

第一种用法，分配一个变量

P = new T;  //T--任意类型名，P--T*指针

第二种用法，分配一个数组

P = new T[N]
T:  任意类型名
P： 类型为 T* 的指针
N： 元素个数，N * sizeof(T)

• 分配一个数组

P = new T[N];  //返回值为 T*

• 释放动态分配的内存（一片存储空间不能delete两次）

delete [] p;  //释放动态分配的数组

int *p = new int;
*p = 5;
delete p;  //指向new出来的空间

4. 内联函数和重载函数

---

函数调用是有时间开销。如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数所产生的开销就会显得比较大

为了减少函数调用开销，引入内联函数机制。编译器处理对内联函数的调用语句时，是将整个函数代码插入到调用语句处，而不会产生调用函数的语句。

• 定义内联函数

inline int max(int a, int b)  //关键字--inline
{
    if(a > b) return a;
    return b;
}

• 函数重载

一个或多个函数，函数名相同，参数或参数类型不同，即重载。

int Max(double f1, double f2)
int Max(int n1, int n2)

• 函数的缺省参数

最右边连续若干个参数有缺省值，提升程序的可扩充性。调用函数的时候，若相应位置不写，即缺省值。