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++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率。 普通函数： 内联函数：

内联函数的特性：

inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联,是否进行展开，由编译器决定。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 中被引用 inline函数在函数的调用点直接把函数的代码进行展开处理，inline函数不会在符号表中在生成相应的函数符号。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; }

注意：

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

几个常见的面试题：

为什么c++支持函数重载，c语言不支持函数重载？ (1).c++代码产生函数符号的时候，符号是由函数名+参数列表类型组成的 (2).c语言代码产生函数符号，符号由下划线+函数名 (3).编译器根据c++所产生的符号中参数的个数以及参数的类型来区分,而c语言不带参数列表，所以无法区分。什么是函数重载？函数重载需要注意些什么？ (1).一组函数，出现在同一个作用域，其中函数名相同，参数列表的个数或者类型不同，就称为函数重载。 (2).一组函数，函数名相同，参数列表也相同，仅仅是返回值不同，是不构成函数重载的。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修饰的常量经常出现的错误：

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

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

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

const和二级指针的结合

const int* *q;cosnt修饰的是**q,所以*q和q是可以改变的。int *cosnt *q;const修饰的是*q,所以**q和q是可以改变的。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则交还系统，所以返回随机值。

引用的好处：

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

引用和指针的不同点：

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

左值引用和右值引用

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

六、认识new和delete

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

new和malloc的区别、delete和free的区别; new不仅可以做内存开辟，还可以做内存的初始化操作; malloc开辟内存失败，是通过返回值和nullptr作比较；而new开辟内存失败是通过抛出bad_alloc类型的异常来判断; malloc和free，都是c的库函数; new和delete都是运算符;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替换为变量实际的类型;变量的实际类型通过初始化表达式确定。

使用细则：

auto与指针和引用结合起来使用 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加& int main() { int x=10; auto a=&x;//指针 auto* b=&x;//指针 auto& c=x;//引用 return 0; } 在同一行定义多个变量 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量

auto不适用的场景

不能做函数参数 // 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导 void TestAuto(auto a) {} 不能用来声明数组 void TestAuto() { int a[] = {1,2,3}; auto b[] = {4，5，6};//错误 } 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法auto在实际中常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等 进行配合使用。auto不能定义类的非静态成员变量实例化模板时不能使用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来跳出整个循环