本文共 4040 字，大约阅读时间需要 13 分钟。

" 以梦为马 不负韶华 "

这篇文章将带我们了解到（以后内容将头文件省略）：

1. C语言的指针与C++的引用
2. C语言的#define与C++的const
3. C++提供了函数默认值与函数重载
4. C++的头痛问题——内存管理

1、C++语言引用

概念：引用是变量的一个别名（但是只存在别名是行不通的）

1. 基本数据类型的引用

• 下列代码块中&b即是变量a的引用、但是只存在&b是行不通的、必须在引用的同时进行赋值

int main(){     int a = 3;  int &b = a;//引用必须初始化    b = 10;//改变引用的值、也就对应改变了其变量的值  cout<< a <

2. 结构体的引用

• 下列代码块中&c即是结构体c1的引用

typedef struct{     int x;  int y;}Coor;int main(void){     Coor c1;  Coor &c = c1;  c.x = 10;  c.y = 20;  cout<< c1.x <

3. 指针类型的引用

• 令 *p 指针指向a变量的地址、另外p的引用为q、改变指针q所指向的值（*q = 20）、也就是改变了指针p所指向的值（*p = 20）、也就是说a = 20

int main(void){     int a = 10;  int *p = &a;  int *&q = p;  *q = 20;  cout<< a <

4. 引用作为函数参数

• C语言

• 其中涉及到了C语言中较难的一个知识点——指针在实参和形参之间的传递过程（代码中、将x和y的地址作为实参分别传递给指针 *a 和 *b 、既完成了地址的传递也完成了值的传递）

void fun(int *a,int*b){     int c = 0;  c = *a;  *a = *b;  *b = c;}int main(){     int x = 10;  int y = 20;  fun(&x,&y);  return 0;}

• C++

• &a和&b分别是x和y的引用、改变a和b的值也就对应改变了x和y

void fun(int &a,int&b){     int c = 0;  c = a;  a = b;  b = c;}int main(){     int x = 10;  int y = 20;  fun(x,y);  return 0;}

2、C++语言const关键字

2.1、C++语言——const

• const与基本数据类型

int x = 3;//变量const int x = 3;//常量

• const与指针类型

1. const修饰 *p（const *p）代表 *p 是不能被重新赋值的
2. const修饰 *p中的p（*const p）代表 p 是不能重新被赋予地址的

const int *p = NULL;int const *p = NULL;//完全等价const int *const p =NULL;int const * const p = NULL;//完全等价1. int x = 3;   const int *p = &x;   //p = &y;正确   //*p = 4;错误2. int x = 3;    int *const p = &x;    //p = &y;错误const int x = 3;const int *const p = &x;//p = &y;*p = 4;错误

• const与引用

1. 若用const修饰引用、则不能将引用重新赋值

1. int x = 3;   const int &y = x;   //x = 10;正确   //y = 20;错误

• 错误类型示例

1. const修饰整型（x = 3）为常量、常量不能被重新赋值
2. const修饰整型（y = x = 3）为常量、常量不能被重新赋值
3. const修饰指针（*y）为常量、*y不能被重新赋值
4. const修饰地址（y）为常量、常量y不能指向其他地址
5. const修饰引用（&y）为常量、y不能再改变
6. const修饰整型（x）为常量、不能借助指针*y中的y指向其他地址改变常量x的值

1. const int x = 3;  x = 5;2. int x = 3;  const int y = x;  y= 5;3. int x = 3;  const int *y = &x;  *y = 5;4. int x = 3,z = 4;  int *const y = &x;  y = &z;5. const int x = 3;  const int &y = x;  y = 5;6. const int x = 3;  int *y = &x;

2.2、const代码演示

1. const修饰 p 、不能改变 p 指向的地址、但是可以通过改变*p的值来改变相对应的值、即程序输出10

int main(){     int x = 3;  int y = 5;  int *const p = &x;  *p = 10;  cout<< x <

2. const修饰 *p、不能改变 *p 的值、但是能通过改变其指向的地址来改变相对应的值、即程序输出5

int main(){     int x = 3;  int y = 5;  int const*p = &x;  p = &y;  cout<< x <

3. const修饰引用&z、z不能被重新赋值

int main(){     int x = 3;  int y = 5;  int const &z = x;  z = 10;  cout<< x <

4. 主函数里面将实参x和y传递过去后、引用（a和b）即被赋值、不能重新改变引用的值

int main(){     int x = 3;  int y = 5;  fun(x,y);  cout<< x << "," << y <

3、C++函数新亮点（函数特性）

1. 函数参数默认值

• 函数参数默认值：有默认参数值的参数必须在参数表的最右端

void fun(int i,int j = 5,int k = 10);//正确void fun(int i,int j = 5,int k);//错误

• 定义函数的时候不建议将默认值写上（有些编译器无法通过）

void fun(int i,int j = 5,int k = 10);//声明函数void fun(int i,int j,int k);//定义函数

• 无实参则用默认值、否则实参覆盖默认值

void fun(int i,int j = 5,int k = 10);void fun(int i,int j,int k);{     cout<< i << j << k;}int main(){     fun(20);  //输出20 5 10  fun(20,30);  //输出20 30 10  fun(20,30,40);  //输出20 30 40  return 0;}

2. 函数重载

• 函数重载：在相同作用域内、用同一个函数名定义的多个函数、参数个数和参数类型不同
• 系统会自动将其识别为不同的函数、从而达到区分的目的

getMax(int x,int y,int z)//新函数名getMax_int_int_intgetMax(double x, double y)//新函数名getMax_double_double

• 好处：给函数起名字的时候不需要煞费苦心（如求多个数最大值的函数）

3. 内联函数

• 内联函数：编译时将函数体代码和实参代替函数调用语句
• 优点：节省时间（尤其是循环调用）
• 关键字：inline

int main(){     int i = 10;j = 20,k = 30,m;  m = max(i,j,k);  cout<< "max = " << m <
   
    a)  a = b;  if(c>a)  a = c;  returm a;}int main(){     int i = 10;j = 20,k = 30,m;  int a,b,c;  a = i;b = j;c = k;  if(b>a) a = b;  if(c>a) a = c;  m = a;  cout<< "max = " << m <
   

• 内联编译是建议性的，由编译器决定
• 逻辑简单，调用频繁的函数建议使用内联
• 递归函数无法使用内联方式

4、C++内存管理

1. 内存管理

• 内存管理：内存的本质是资源、由操作系统掌握、我们可以进行申请和归还操作
• 内存的申请和释放（借助运算符）：申请内存（new）、释放内存（delete）

int *p = new int;//申请内存delete p;//释放内存

• 申请和释放块内存

int *arr = new int[10];//申请块内存delete [ ]arr;//释放块内存

• 申请和释放内存的其他方式（配套使用、不要混搭）
• C语言

void *malloc(size_t size);void free(void *memblock);

• C++

newdelete

• 申请内存不一定成功

int *p = new int[1000];if(NULL == p){     //内存分配失败}

• 释放内存注意事项

int *p = new int;if(NULL == p){     //内存分配失败  //异常处理}  delete p;p = NULL;

int *p = new int[1000];if(NULL == p){     //内存分配失败  //异常处理}  delete [ ]p;p = NULL;

转载地址：http://orqo.baihongyu.com/