C++学习——C++基础部分

一、形参带缺省值的函数

1.缺省参数：

缺省参数：是指是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

2.缺省参数的分类：

(1)全缺省参数：

int sum(int a = 10, int b = 20)
{
 return a + b;
}

即形参的所有参数均给以缺省值。

(2)半缺省参数：

int sum(int a , int b = 20)
{
 return a + b;
}

即形参中部分参数赋以缺省值。

int sum(int a,int b=20)	
{
  return a+b;
}

3.注意：

(1)半缺省参数必须从右往左依次来给出，不能隔着赋给形参缺省值。
例如：

int sum(int a=10,int b)//错误
{
  return a+b;
}

(2)声明时可以给形参缺省值，定义处也可以给形参缺省值，但是只能在声明或定义时赋给形参缺省值，不能声明和定义同时给出。
(3)缺省值必须是常量或者全局变量。

形参带缺省值的函数相对于普通函数的调用而言效率更高，在其传参时，会少一条MOV指令。

二、inline内联函数

内联函数：

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。
普通函数：

内联函数：

内联函数的特性：

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联,是否进行展开，由编译器决定。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到，会出现链接错误。

//F.h
#include<iostream>
using namespace std;
inline void f(int i);
//F.cpp
#include"F.h"
void f(int i)
{
 cout << i << endl;
}
int main()
{
 f(10);
 return 0;
}
// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?
f@@YAXH@Z)，该符号在函数 _main 中被引用

4. inline函数在函数的调用点直接把函数的代码进行展开处理，inline函数不会在符号表中在生成相应的函数符号。
5. debug版本上，inline是不起作用的；inline只有在release版本下才能出现。

三、函数重载

概念：

函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。

int Add(int left, int right)
{
  return left+right;
}
double Add(double left, double right)
{
  return left+right;
}
long Add(long left, long right)
{
  return left+right;
}
int main()
{
  Add(10, 20);
  Add(10.0, 20.0);
  Add(10L, 20L);
return 0;
}

注意：

1. 函数重载的前提是函数属于同一个作用域。
2. 函数返回值不同，不构成重载。
3. 参数信息是指：参数类型、参数个数、参数类型的顺序。

几个常见的面试题：

1. 为什么c++支持函数重载，c语言不支持函数重载？
   (1).c++代码产生函数符号的时候，符号是由函数名+参数列表类型组成的
   (2).c语言代码产生函数符号，符号由下划线+函数名
   (3).编译器根据c++所产生的符号中参数的个数以及参数的类型来区分,而c语言不带参数列表，所以无法区分。
2. 什么是函数重载？函数重载需要注意些什么？
   (1).一组函数，出现在同一个作用域，其中函数名相同，参数列表的个数或者类型不同，就称为函数重载。
   (2).一组函数，函数名相同，参数列表也相同，仅仅是返回值不同，是不构成函数重载的。
3. c++和c语言之间如何互相调用？
   c调用c++:无法直接调用(生成符号规则不同)。解决办法：把c++源码的声明括在extern"c"中。
   c++调用c:无法直接调用(生成符号规则不同)。解决办法：把c函数声明括在extern "c"中。

四、const修饰指针变量

如何理解const：

const修饰的变量不能在作为左值，并且初始化完成后值不能被修改。

C语言和C++中const的区别：

1. C语言中被const所修饰的，可以不用初始化，但是不叫常量，叫做常 变量，其不能作为左值被修改。
2. C++中被const所修饰的必须初始化，为常量。
3. const的编译方式不同：
C语言中，const就是当作一个变量来编译生成指令的。
C++中，所有出现const常量的地方，都被常量的初始化值替换掉了，并且初始化值必须为立即数。

const修饰的常量经常出现的错误：

1. 直接修改常量的值====>常量不能作为左值
2. 间接修改常量的值====>不能把常量的地址泄露给一个普通的指针

const和一级指针的结合：修饰指向或所指内存中的值

1. c++语言规范：cosnt修饰的是离它最近的类型。
   记忆方法：去掉const所修饰的类型即为不能改变的常量
2. int const *p;\const int *p = &a; ===》*p=20//错误 p = &a;//正确
   修饰* p，即指针所指内存单元中的值不能被改变，但指针指向可以被改变即可以任意指向int类型的内存，但是不能通过指针间接修改所指内存单元中的值。
3. int *const p = &a; ===>p = &b//错误 *p = 20;//正确
   修饰p，即指针的指向不能被修改，但是指针所指内存单元中的值可以被修改即这个指针p现在是常量，不能再指向其他内存，但是可以通过指针解引用修改指针所指内存单元中的值
4. const int *const p = &a; ===>p = &b//错误* p=30;//错误
   以上两种情况的结合，指针的指向和所指内存单元的值绝不能被修改

const和二级指针的结合

1. const int* *q;cosnt修饰的是**q,所以*q和q是可以改变的。
2. int *cosnt *q;const修饰的是*q,所以**q和q是可以改变的。
3. int **const q;cosnt修饰的是q,所以**q，*q是可以改变的。

const和指针的类型转换公式：

int* <= const int*  是错误的！
cosnt int* <=== int*  是正确的！
int ** <= const int**  是错误的！
cosnt int** <= int**  是错误的！
int** <= int* const*  是错误的！
int* cosnt* <= int**  是正确的！

注意：如果const右边没有接指针运算符*的话，cosnt是不参与类型的
例如：
int * const p = &a;//int*<===int* const后无指针*，不参与类型

int main()
{
 int b = 20;
 const int a = b;//此时已经退化成常变量，因为初始化值不是立即数，是一个变量。
 const int a = 20; 
 b = 30;//错误，被cosnt修饰的变量不能作为左值
 int arr[b] = {};
 int* p = (int*)&a;//已经把b内存中的值改掉了
 *p = 30;
 printf("%d %d %d\n", a, *p, *(&a));//在编译阶段const修饰的变量就已经被初始化的值替换了
 const int a = 10;
 int* p = &a;//错误，不能把常量的地址泄露给普通指针
 const int* p = &a;//正确
 int a = 0;
 int* p = &a;
 const int** q = &p;//错误的，const int **<===int **
  /*
 const int * *q = &p;
 错误的原因：
 如果const int * *q = &p是正确的，则：
  *q<=>p; //*q即为p的地址
 因为*q只能接收const int类型变量的地址：
 所以有定义：const int b = 20;
 对于*q来说，他的类型是const int*类型
 而&b的类型也是const int*类型，所有有如下代码:
  *q = &b <=> p = &b;//即把常量b的地址赋给了一个普通指针p，
 所以const int* *q=&p是错误的
 */
 //可以修改为：
  int a = 0;
 const int* p = &a;
 const int** q = &p;
 //或者
 int a = 0;
 int* p = &a;
 const int* const* q = &p;
 return 0;
}

五、C++的引用

概念：

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

语法：

类型& 引用变量名(对象名) = 引用实体

int a=10;
int& ra=a;//int类型的引用，ra是a的别名，即引用
ra=100;//修改引用ra的值，a的值也随之改变

可以给一个变量定义多个引用，改变其中一个引用或者变量的值，所有引用和变量的值均发生改变。

注意：

引用在定义的时候必须对其进行初始化；引用类型必须和引用实体是同种类型的；引用引用一旦引用一个实体，再不能引用其他实体。引用可以看作是一个const指针，指向不能变，所指内存中的内容可变。

int a=10;
int b=20;
int& ra=a;
int& ra1;//错误，引用在定义时必须进行初始化
char& ra=a;//错误，引用ra和实体a的类型不同
int& ra=b;//此时a和ra的值将都会被改成20

常引用

对常量的引用：

const int& ra=10；
int d=10;
const int& rd=d;//此时rd不可修改
float f=2.0;
const int& rf=f;//引用和实体类型不同，通过float类型的变量f赋值给一个临时变量(具有常性，即const)，所以加const，只读。

引用的使用场景：

1.做函数参数

void Swap(int& a,int& b)
{
   int tmp=a;
   a=b;
   b=tmp;
}

2.做函数返回值

int& SelfAdd(int& a)
{
 a++;
 return a;
}
int main()
{
 int a=1;
 int& ra=SelfAdd(a);
 return 0;
}

注意：返回变量的生命周期要大于函数的生命周期，否则，会返回一个随机值。
例如：

int& SelfAdd(int a)//将其改成int& SelfAdd(int& a)，就正确了
{
 a++;
 return a;
}
int main()
{
 int a=1;
 int& ra=SelfAdd(a);
 return 0;
}

输出结果为随机值，因为函数形参a的生命周期只在该函数中，调用结束，形参a则交还系统，所以返回随机值。

引用的好处：

可以减少拷贝，提高代码的效率。
引用和指针的区别：在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间；在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

引用和指针的不同点：

1. 引用在定义时必须初始化，指针没有要求 ;
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体 ;
3. 没有NULL引用，但有NULL指针 ;
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节) ;
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小;
6. 有多级指针，但是没有多级引用 ;
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理 ;
8. 引用比指针使用起来相对更安全;

左值引用和右值引用

1. 右值引用:int&& c = 20;专门用来引用右值类型，指令上，可以自动产生临时量，然后直接引用临时量c=40;
2. 右值引用变量本身是一个左值，只能用左值引用来引用它
3. 不能用一个右值引用变量来引用一个左值

六、认识new和delete

此处仅做简单介绍，后续文章中会有详细描述。
new用于开辟内存，delete用于释放空间。

1. new和malloc的区别、delete和free的区别;
   new不仅可以做内存开辟，还可以做内存的初始化操作;
   malloc开辟内存失败，是通过返回值和nullptr作比较；而new开辟内存失败是通过抛出bad_alloc类型的异常来判断;
   malloc和free，都是c的库函数;
   new和delete都是运算符;
2. new有多少种
   int *p1=new int(20);//抛出异常的new
   int *p2=new (nothrow) int;//不抛出异常的new
   const int *p3=new cosnt int(40);//堆上开辟一个常量空间并初始化为40
   int *p4=new(某地址) int(50);定位new

七、auto关键字

概念：

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型;变量的实际类型通过初始化表达式确定。

使用细则：

1. auto与指针和引用结合起来使用
   用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
 int x=10;
 auto a=&x;//指针
 auto* b=&x;//指针
 auto& c=x;//引用
 return 0;
}

2. 在同一行定义多个变量
   当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量

auto不适用的场景

1. 不能做函数参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导 
void TestAuto(auto a) 
{}

2. 不能用来声明数组

void TestAuto() 
{    
 int a[] = {1,2,3};    
 auto b[] = {4，5，6};//错误 
}

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4. auto在实际中常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等 进行配合使用。
5. auto不能定义类的非静态成员变量
6. 实例化模板时不能使用auto作为模板参数

八、基于范围的for循环

语法：for(当前遍历的元素值：遍历的范围){}

for(int e:a)
{
 cout << e << " ";
}
for(auto e:a)
{
 cout << e << " ";
}
for(auto& e:a)
{
 e*=2;
 cout << e << " ";
}
for(const auto& e:a)
{
 cout << e << " ";
}

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环