C++(第二篇——离港）

" 以梦为马 不负韶华 "

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

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 <<endl;
  return 0;
}

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 <<endl;
  cout<< c1.y <<endl;
  return 0;
}

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 <<endl;
  return 0;
}

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 <<endl;
  system("pause");
  return 0;
}  

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

int main()
{
     
  int x = 3;
  int y = 5;
  int const*p = &x;
  p = &y;
  cout<< x <<endl;
  system("pause");
  return 0;
}  

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

int main()
{
     
  int x = 3;
  int y = 5;
  int const &z = x;
  z = 10;
  cout<< x <<endl;
  system("pause");
  return 0;
}  

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

int main()
{
     
  int x = 3;
  int y = 5;
  fun(x,y);
  cout<< x << "," << y <<endl;
  system("pause");
  return 0;
}

void fun(const &a,const &b)
{
     
  a = 10;
  b = 20;
}  

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_int
getMax(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 <<endl;
  return 0;
}  

int max(a,b,c)
{
     
  if(b>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 <<endl;
  return 0;
}

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

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++

new
delete

• 申请内存不一定成功

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;