C++入门基础(万字总结）（建议收藏！！！）

什么是C++

C++的发展史

C++关键字

C++中总计有63个关键字：

其中画圈的是C语言的关键字。这里要注意了：false和true并不是C语言的关键字。

命名空间

命名空间的定义

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

1.命名空间的普通定义

//1. 普通的命名空间，里面可以定义变量，也可以定义函数 namespace xjt { 
       int printf = 1; int rand = 2; int Add(int a, int b) { 
       return a + b; } } 

2.命名空间可以嵌套

//2.命名空间可以嵌套 namespace xjt { 
       int printf = 1; int rand = 2; int Add(int a, int b) { 
       return a + b; } namespace xjt2 { 
       int a = 0; int Sub(int a, int b) { 
       return a - b; } } } 

3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。 namespace xjt { 
       int a = 3; int b = 1; } 

它会与上面的xjt命名空间合并

命名空间使用

下面来看这么一段代码

 namespace xjt { 
       int printf = 1; int rand = 2; int Add(int a, int b) { 
       return a + b; } } #include<iostream> int main() { 
       printf("%d\n",printf); //这样打印出来的结果和我们预期的不一样，因为你这样调用的是printf的地址通过下面两个可以加深理解 printf("%p\n", printf); //6A35CE70 printf("%p\n", rand); //6A42FAB0; } 

很显然直接打印printf是不可能的，因为你这样调用的是printf的地址，所以会出现的这样的结果，正面的调用方法为以下三种。

1.加命名空间名称及作用域限定符

符号“::”在C++中叫做作用域限定符，我们通过“命名空间名称::命名空间成员”便可以访问到命名空间中相应的成员

2.使用using namespace 命名空间名称引入

3.使用using将命名空间中的成员引入

这种方法可以防止命名的污染，因为它只引入了一部分。

C++中的输入和输出

新生婴儿会以自己独特的方式向这个崭新的世界打招呼，C++刚出来后，也算是一个新事物，那C++是否也应该向这个美好的世界来声问候呢？我们来看下C++是如何来实现问候的。

#include<iostream> using namespace std; int main() { 
        cout<<"Hello world!!!"<<endl; return 0; } 

在C语言中有标准输入输出函数scanf和printf，而在C++中有cin标准输入和cout标准输出。在C语言中使用scanf和printf函数，需要包含头文件stdio.h。在C++中使用cin和cout，需要包含头文件iostream以及std标准命名空间。

C++的输入输出方式与C语言更加方便，因为C++的输入输出不需要控制格式，例如：整型为%d，字符型为%c。

#include<iostream> using namespace std; int main() { 
        int a = 1; float b = 2.1; double c= 2.111; char arr[10] = { 
        0 }; char d[] = "hello world"; cin >> arr; cout << arr << endl; cout << a << endl; cout << b << endl; cout << c << endl; cout << d << endl; return 0; } 

注意：endl，这其中的l不是阿拉伯数字1，而是26个英文字母的l，它的作用相当于换行。

缺省参数

//缺省参数 #include<iostream> using namespace std; //这儿的0就相当于缺省参数，如果实参什么都没传过来，缺省参数就赋值给a，相当于备胎的意思。 void func(int a = 0) { 
         cout << a << endl; } int main() { 
         func(10); func(); //在c语言中这样写肯定是不行的，但是在c++中有了缺省参数，如果你什么都不传，只要你前面有缺省参数的存在，就能过。 return 0; } 

全缺省

全缺省参数，即函数的全部形参都设置为缺省参数。

//全缺省 #include<iostream> using namespace std; void func(int a = 0, int b = 1, int c = 2) { 
         cout <<"a="<< a << endl; cout << b << endl; cout << c << endl; } int main() { 
         func(); return 0; } 

半缺省参数

void func(int a, int b, int c = 2) { 
         cout << a << endl; cout << b << endl; cout << c << endl; } 

//错误示例 void func(int a, int b = 2, int c) { 
         cout << a << endl; cout << b << endl; cout << c << endl; } 

2、缺省参数不能在函数声明和定义中同时出现

//错误示例 //test.h void func(int a, int b, int c = 3); //test.c void func(int a, int b, int c = 2) { 
         cout << a << endl; cout << b << endl; cout << c << endl; } 

3、缺省值必须是常量或者全局变量。

//正确示例 int x = 3;//全局变量 void func(int a, int b = 2, int c = x) { 
         cout << a << endl; cout << b << endl; cout << c << endl; } 

函数重载

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

#include <iostream> using namespace std; int Add(int x, int y) { 
          return x + y; } double Add(double x, double y) { 
          return x + y; } int main() { 
          cout << Add(0,1) << endl;//打印0+1的结果 cout << Add(1.1,2.2) << endl;//打印1.1+2.2的结果 return 0; } 

注意：若仅仅只有返回值不同，其他都相同，则不构成函数重载。

short Add(short left, short right) { 
          return left+right; } int Add(short left, short right) { 
          return left+right; } 

函数重载的原理

采用C语言编译器编译之后

采用C++编译器编译之后

extern “C”

引用

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

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

#include<iostream> using namespace std; int main() { 
            int a = 1; int&b = a; //相当于给a起了一个别名为b，int是b的类型 cout << a << endl; cout << b << endl; b = 3; //改变b也就相当于改变了a cout << b << endl; cout << a << endl; } 

注意：引用类型必须和引用实体是同种类型的

引用的特征

1.引用在定义时必须初始化

//正确示例 int a = 10; int& b = a;//引用在定义时必须初始化 //错误示例 int a = 10; int &b;//定义时未初始化 b = a; 

2.一个变量可以有多个引用

int a = 10; int& b = a; int& c = a; int& d = a; 

3.引用一旦引用了一个实体，就不能再引用其他实体

 int a = 10; int& b = a; int c = 20; b = c;//你的想法：让b转而引用c 

但实际的效果，确实将c的值赋值给b，又因为b是a的引用，所以a的值见解变成了20。

常引用

上面提到，引用类型必须和引用实体是同种类型的。但是仅仅是同种类型，还不能保证能够引用成功，这儿我们还要注意可否可以修改的问题。

void TestConstRef() { 
            const int a = 10; //int& ra = a; // 该语句编译时会出错，a为常量 const int& ra = a; // int& b = 10; // 该语句编译时会出错，b为常量 const int& b = 10; double d = 12.34; //int& rd = d; // 该语句编译时会出错，类型不同 const int& rd = d; } 

#include<iostream> using namespace std; int main() { 
            int a = 10; double&ra = a; } 

这个引用对吗？想要弄明白这个问题，首先要明白隐士类型提升的问题，在这里int到double存在隐士类型的提升，而在提升的过程中系统会创建一个常量区来存放a类型提升后的结果。因此到这儿，这段代码一看就是错了，因为你隐士类型提升时a是存放在常量区中的，常量区是不可以被修改的，而你用double&ra去引用他，ra这个引用是可以被修改的。

加个const就可以解决这个问题。

#include<iostream> using namespace std; int main() { 
            int a = 10; const double&ra = a; } 

注意：将不可修改的量用可读可写的量来引用是不可以的，但是反过来是可以的，将可读可写的量用只可读的量来引用是可以的。

引用的使用场景

1.引用做参数

还记得C语言中的交换函数，学习C语言的时候经常用交换函数来说明传值和传址的区别。现在我们学习了引用，可以不用指针作为形参了。因为在这里a和b是传入实参的引用，我们将a和b的值交换，就相当于将传入的两个实参交换了。

//交换函数 void Swap(int& a, int& b) { 
            int tmp = a; a = b; b = tmp; } 

2.引用做返回值

当然引用也能做返回值，但是要特别注意，我们返回的数据不能是函数内部创建的普通局部变量，因为在函数内部定义的普通的局部变量会随着函数调用的结束而被销毁。我们返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。

不加static的后果

你是不是疑惑为什么打印的不是2而是7了？

为什么会出现随机值，因为你在函数里定义的变量是临时变量，出了函数函数是会销毁的，这时它就随机指向内存中的一块空间了。所以在引用做函数返回值时最好还是给在函数中定义的变量加上static。

这时你觉得你真的懂这段代码了吗？

#include<iostream> using namespace std; int& Add(int a, int b) { 
            static int c = a + b; return c; } int main() { 
            int& ans = Add(1,2); Add(3, 4); cout << ans << endl; } 

可能你会好奇了？为什么这儿是3了？下面来看看分析

其实你换种写法，这儿的结果就会换成7，原因也很简单，正是上面图片中说的原因

int& Add(int a, int b) { 
            int c=a+b; //出了函数作用域，c不在，回给了系统 return c; } int& Add(int a,int b) { 
            static c=a+b; //出了函数作用域，c还在，可以用引用返回 return c; } 

大家是不是感觉这个传引用返回用起来很怪了，下面我们来分析一下它是如何返回的。

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main() { 
            int a = 10; int& ra = a; cout<<"&a = "<<&a<<endl; cout<<"&ra = "<<&ra<<endl; return 0; } 

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main() { 
            int a = 10; int& ra = a; ra = 20; int* pa = &a; *pa = 20; return 0; } 

我们来看下引用和指针的汇编代码对比

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

内联函数

概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，
内联函数提升程序运行的效率。（看到在加粗部分时，小伙伴肯定会想，这和c语言中的宏是不是很像了？）

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用

特性

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; } // main.cpp #include "F.h" int main() { 
             f(10); return 0; } // 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (? // f@@YAXH@Z)，该符号在函数 _main 中被引用 

c++有哪些技术可以代替宏

C++有哪些技术替代宏？

1. 常量定义 换用const
2. 函数定义 换用内联函数

auto关键字(C++11)

#include<iostream> using namespace std; int TestAuto() { 
              return 10; } int main() { 
              int a = 10; auto b = a; auto c = 'a'; auto d = TestAuto(); cout << typeid(b).name() << endl; //这个地方要学到后面类的时候才可以解释，这里打印出的是类型名 cout << typeid(c).name() << endl; cout << typeid(d).name() << endl; cout << a << endl; cout << b<< endl; cout << c << endl; cout << d << endl; //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化 return 0; } 

auto的使用细则

1.auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

#include <iostream> using namespace std; int main() { 
              int a = 10; auto b = &a; //自动推导出b的类型为int* auto* c = &a; //自动推导出c的类型为int* auto& d = a; //自动推导出d的类型为int //打印变量b,c,d的类型 cout << typeid(b).name() << endl;//打印结果为int* cout << typeid(c).name() << endl;//打印结果为int* cout << typeid(d).name() << endl;//打印结果为int return 0; } 

注意：用auto声明引用时必须加&，否则创建的只是与实体类型相同的普通变量，只不过将其换了个姓名而已。

2.在同一行定义多个变量

void TestAuto() { 
              auto a = 1, b = 2; auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同 } 

auto不能推导的场景

1.auto做为函数的参数

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

2.auto不能直接用来声明数组

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

基于范围的for循环（C++11)

范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：

void TestFor() { 
               int array[] = { 
               1, 2, 3, 4, 5 }; //将数组所有元素乘以2 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i) array[i] *= 2; for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p) cout << *p << endl; } 

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中
引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，
第二部分则表示被迭代的范围。

注意不能写成auto，不然改变不了原数组

正确的写法

void TestFor() { 
               int array[] = { 
               1, 2, 3, 4, 5 }; //将数组中所有元素乘以2 for(auto& e : array) e *= 2; for(auto e : array) cout << e << " "; return 0; } 

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

范围for的使用条件

1.for循环迭代的范围必须是确定的

注意：以下代码就有问题，因为for的范围不确定

void TestFor(int array[]) { 
               for(auto& e : array) //这里的array其实不是数组，数组在传参时会退化成指针 cout<< e <<endl; } 

2. 迭代的对象要实现++和==的操作。

关于迭代器这个问题，以后会讲，现在大家了解一下就可以了。

指针空值nullptr

C++98中的指针空值

在良好的C/C++编程习惯中，在声明一个变量的同时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误。比如未初始化的指针，如果一个指针没有合法的指向，我们基本都是按如下方式对其进行初始化：

int* p1 = NULL; int* p2 = 0; 

NULL其实是一个宏，在传统的C头文件(stddef.h)中可以看到如下代码：

#ifndef NULL #ifdef __cplusplus #define NULL 0 #else  #define NULL ((void *)0) #endif  #endif  

#include <iostream> using namespace std; void Fun(int p) { 
                cout << "Fun(int)" << endl; } void Fun(int* p) { 
                cout << "Fun(int*)" << endl; } int main() { 
                Fun(0); //打印结果为 Fun(int) Fun(NULL); //打印结果为 Fun(int) Fun((int*)NULL); //打印结果为 Fun(int*) return 0; } 

程序本意本意是想通过Fun(NULL)调用指针版本的Fun(int* p)函数，但是由于NULL被定义为0，Fun(NULL)最终调用的是Fun(int p)函数。

注：在C++98中字面常量0，既可以是一个整型数字，也可以是无类型的指针(void*)常量，但编译器默认情况下将其看成是一个整型常量，如果要将其按照指针方式来使用，必须对其进行强制转换。

C++11中的指针空值