目录
C++是在C语言的基础上，容纳进去了面向对象的编程思想。并增加了许多有用的库，以及编程范式，熟悉C语言，对C++的学习有一定的帮助。
1.C++关键字
- C++有63个关键字，而C语言有32个关键字。这里我们简单看一下即可。后续的学习不断的了解。
2.命名空间的介绍
在C/C++中，变量，函数，后面学到的类是大量存在的，这些变量，函数和类的名称都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免名字冲突或名字污染，namespace关键字的出现就是针对这种问题的。
#include <stdio.h>
#include <stdlib.h>
int rand = 0;
// C语言无法解决自己定义的变量和库里面的变量或者函数名冲突的问题，因此C++提出了命名空间的概念。
int main()
{
printf("%d ", rand);
return 0;
}
//编译后报错，rand重定义，以前的定义是“函数”。
2.1.命名空间的定义
定义命名空间的定义需要使用namespace关键字，后面跟命名空间的名字即外加一个{}即可。
#include <stdio.h>
#include <stdlib.h>
//1.正常的命名空间定义
namespace smk
{
int rand = 0;
int add(int x, int y)
{
return x + y;
}
}
int main()
{
//使用的时候加上域作用限定符即访问的是命名空间里的内容。
printf("%d ", smk::rand);//0
printf("%d ", smk::add(1,2));//3
return 0;
}
//注：一个命名空间即定义了一个新的作用域，命名空间的所有内容都局限该命名空间中。
//2.命名空间可以嵌套
test.cpp
namespace N1
{
int a = 1;
int b = 2;
namespace N2
{
int c = 3;
int d = 4;
}
}
//3.同一个工程中允许存在多个名称相同的命名空间，编译器最后会合并到同一个命名空间中
//test.cpp和test.h中的N1，最后会合并为同一个。
test.h
namespace N1
{
int mul(int left, int right)
{
return left * right;
}
}
2.2.命名空间三种使用方式
- 1.加命名空间名称和作用域限定符
namespace N1
{
int a = 1;
int b = 2;
}
int main()
{
printf("%d ", N1::a);//1
return 0;
}
- 2.使用using将命名空间的某个成员引入
namespace N1
{
int a = 1;
int b = 2;
}
using N1::a;
using N1::b;
int main()
{
printf("%d ", a);//1
printf("%d ", b);//2
return 0;
}
- 3.使用using namespace命名空间名称引入
namespace N1
{
int a = 1;
int b = 2;
}
//把命名空间中的内容全部展开到全局
using namespace N1;
int main()
{
printf("%d ", a);
printf("%d ", b);
return 0;
}
3.输入和输出
接下来我们先用C++敲出第一行代码Hello world，初步了解输入和输出
#include <iostream>
using namespace std;
int main()
{
cout << "hello world" << endl;//输出hello world
return 0;
}
说明：
1.使用cout标准输出对象（控制台）和cin标准输入对象（键盘）时，必须包含头文件以及按照命名空间的使用方法使用std;
2.cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在中。
3.<<是流插入运算符，>>是流提取运算符。
4.使用C++输入输出更加方便，不想printf和scanf那样，需要手动控制格式，C++的输入输出会自动控制格式。
5.实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载的知识，这些知识我会慢慢更新，所以这里我们先简单的了解一下使用。
6.早期标准库的功能在全局域里实现，声明在.h后缀的头文件里，使用只需要包含对应的头文件即可。后来将其实现在std的命名空间下，为了和C的头文件区分，也为了正确使用命名空间，规定C++的头文件不带.h。旧的编译器可能依然支持<iostream.h>格式，如VC6.0等，因此推荐 + std的方式。
#include <iostream>
using namespace std;
int main()
{
int a = 0;
int b = 1;
char c = 'a';
double d = 3.14;
//自动识别变量的类型
cout << a << " " << b << " " << c << " " << d << endl;
return 0;
}
命名空间的使用惯例:
- std是C++标准库的命名空间，如何展开std会更加合理呢？
1.在日常练习中，一般方便的话全部展开，使用using namespace std；
2.在大型项目中，容易造成我们定义和库里面的变量，函数，类发生冲突。所以在大型项目中一般使用指定命名空间（std：：cout）和部分展开using std：：cout方式。
3.缺省参数
3.1.缺省参数的概念
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调佣该函数时，如果没有指定实参则使用该形参的缺省值，否则使用指定的实参。
#include <iostream>
using std::cout;
using std::endl;
void func(int a = 0)
{
cout << a << endl;
}
int main()
{
func();//0
func(10);//10
return 0;
}
3.2.缺省参数的分类
- 全缺省参数
void func(int a = 10, int b = 20, int c = 30)
{
cout << a << endl;//10
cout << b << endl;//20
cout << c << endl;//30
}
int main()
{
func();
return 0;
}
- 半缺省参数
void func(int a, int b = 20, int c = 30)
{
cout << a << endl;//1
cout << b << endl;//20
cout << c << endl;//30
}
int main()
{
func(1);
return 0;
}
注意：
1.半缺省参数必须从右往左依次来给出，不能间隔着给。
2.缺省参数不能在函数声明和定义同时出现。
//a.h
void func(int a = 10, int b = 20);
//a.cpp
void func(int a = 10, int b = 20);
//如果声明和定义位置同时出现，恰巧两个位置提供位置的值不同，那编译器就无法确定到底该用那个缺省值。
4.函数重载
4.1.函数重载概念
函数重载：函数重载是一种特殊情况。C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数或类型或类型顺序）不同，常用来处理实现功能类似数据类型不同的问题。
//1 .形参的类型不同
int Swap(int left, int right)
{
cout << "int Swap(int left,int right)" << endl;
return left + right;
}
double Swap(double left, double right)
{
cout << "double Swap(double left,double right)" << endl;
return left + right;
}
//2.函数的形参个数不同
void func()
{
cout << "void func()" << endl;
}
void func(int a)
{
cout << "void func(int a)" << endl;
}
//3.函数形参的顺序不同
int Swap(double left, int right)
{
cout << "int Swap(double left,int right)" << endl;
return left + right;
}
double Swap(int left, double right)
{
cout << "double Swap(int left,double right)" << endl;
return left + right;
}
5.引用
5.1.引用的概念
引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用一块内存空间。
void TestRef()
{
int a = 10;
int& ra = a;
cout << &a << endl;//00EFFB48
cout << &ra << endl;//00EFFB48
//注意:
//1.引用变量名 = 引用实体
//2.引用类型必须和引用实体是同种类型的。
}
5.2.引用特性
- 引用在定义的时候必须初始化
- 一个变量可以有多个引用
- 引用一但引用一个实体不能引用其他实体
void TestRef()
{
int a = 10;
int& ra;//编译会报错，引用的时候并没有初始化
cout << &a << endl;
cout << &ra << endl;
}
5.3.常引用
void TestRef()
{
const int a = 10;
int& ra = a;//编译时会报错，权限的放大，a从可读的变成可读可写的
double d = 12.34;
int& rd = d;//编译时报错，类型不同
}
5.4.使用场景
1.做参数
void Swap(int& left, int& right)
{
int tmp = left;
left = right;
right = tmp;
}
2.做返回值
//正确的范例
int& count()
{
static int n = 0;
n++;
return n;
}
//错误的范例
int& count()
{
int n = 0;
n++;
return n;
}
//如果函数返回时，出了函数作用域，如果返回对象还在，则可以使用引用返回。如果已经还给了操作系统，则必须使用传值返回。
5.5.引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块区间
int main()
{
int a = 10;
int& ra = a;
//a和ra的地址是相同的
cout << &a << endl;//0054FBD0
cout << &ra << endl;//0054FBD0
return 0;
}
在底层实现上实际上是有空间的，因为引用是按照指针方式实现的。
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
引用和指针汇编代码分析：
指针和引用的不同点：
1.引用概念上定义一个变量的别名，指针存储一个变量的地址。
2.引用在定义时必须初始化，指针没有要求。
3.引用在初始化引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何同一类型实体。
4.没有NULL引用，但有NULL指针。
5.在sizeof中的含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节数。
6.有多级指针，但没有多级引用。
7.访问实体方式不同，指针需要解引用使用，引用编译器可以自己处理。
8.引用比指针使用起来安全。
6.内联函数
6.1.概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开，没有函数建立栈帧的消耗，内联函数提升函数运行的效率。
int Add(int left, int right)
{
return left + right;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
注：
如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会将函数体替换函数的调用。
- 在release模式下，查看编译器生成的汇编代码是否存在call add。
- 在debug模式下，需要对编译器进行设置，否则不会展开。
6.2.特性
1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能使目标文件变大，优势：少了调用开销，提高程序运行效率。
2.inline只是对编译器的一个建议，不用的编译器对inline的实现机制可能不一样，一般的建议：将函数规模较小的，不是递归，且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
3.inline不支持声明和定义分离，分离会导致链接错误。因为inline被展开，没有函数地址，链接就会找不到。
6.3.宏的优缺点
宏的优点：
1.增强代码的复用性。
2.提高性能
宏的缺点：
1.不方便调试宏（宏在预处理阶段进行替换） *
2.导致代码可读性差，可维护性差，容易出错。
3.没有安全类型的检查。
C++有哪些技术替代宏：
1.常量替换，换用const enum。
2.短小函数定义，调用内联函数。
7.auto关键字
7.1.类型别名思考
随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：
- 类型难以拼写
- 含义不明确导致容易出错
#include <string>
#include <map>
int main()
{
std::map<std::string, std::string> m{ {"apple","苹果"},{"orange","橙子"},
{"pear","梨"} };
std::map<std::string, std::string>::iterator it = m.begin();
while (it != m.begin())
{
//......
}
return 0;
}
std::map<std::string, std::string>::iterator it是一个类型，但是该类型太长，特别容易写错，当然我们也可以用typedef给类型取别名。
#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;
int main()
{
Map m{ {"apple","苹果"},{"orange","橙子"},
{"pear","梨"} };
Map::iterator it = m.begin();
while (it != m.begin())
{
//......
}
return 0;
}
使用typedef给类型取别名确实可以简化代码，但是typedef有时候会遇到新的问题。
typedef char* pstring;
int main()
{
const pstring p1;
const pstring* p2;
return 0;
}
在编程时，常常需要把表达式的值赋值给变量，这时候要求声明变量的时候清楚知道表达式的类型，然而有时候并非那么容易，因此C++给auto赋予了新的定义。
7.2.auto简介
在早期C/C++中auto的定义是：使用auto修饰的变量，是具有自动存储器的局部变量，很遗憾的是一直没人去使用它。
C++11中，标准委员会赋予了auto全新的定义：auto不再是一个存储类型的指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须在编译器在编译时期推导而得。
#include <iostream>
int TestAuto()
{
return 0;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = TestAuto();
std::cout << typeid(b).name() << std::endl;//int
std::cout << typeid(c).name() << std::endl;//char
std::cout << typeid(d).name() << std::endl;//int
//auto e无法通过编译，使用auto定义的变量必须对其初始化
return 0;
}
注意：使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto实际类型。因此，auto并非一种“类型”的声明，而是一种类型声明的“占位符”，编译器在编译器会将auto替换为变量实际的类型。
7.3.auto的使用规则
1.auto 与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型必须加&。
#include <iostream>
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
std::cout << typeid(a).name() << std::endl;//int*
std::cout << typeid(b).name() << std::endl;//int*
std::cout << typeid(c).name() << std::endl;//int
*a = 20;
*b = 30;
c = 40;
return 0;
}
2.在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器会报错，因为编译器实际上只对第一个类型进行推导，然后用这些推导来定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0;//这段代码会编译失败，因为c和d的类型不一样
}
7.4.不能推导的场景
1.auto不能作为函数的参数
//此处代码会编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{
}
2.auto 不能用来声明数组
void TestAuto()
{
int a[] = {1, 2, 3};
auto b[] = {4, 5, 6};
}
8.基于范围for循环（C++）
8.1.范围for的语法
对于一个有范围集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错，因为C++引入了基于范围的for循环。范围for循环由冒号“：”分为两部分；第一部分是范围内用于迭代的变量，第二部分表示被迭代的范围。
#include <iostream>
int main()
{
int a[10] = { 5,9,1,3,4,2,6,7,8,0 };
for (auto e : a)
{
std::cout << e << std::endl;
}
return 0;
}
8.2.范围for的使用条件
1.范围for的迭代条件必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begi和end就是循环迭代的范围。
2.迭代的对象要实现++和==的操作。
9.指针空值nullptr
在良好的编程习惯时，声明变量或者指针最好给初始化值，否则会出现意想不到的错误。
NULL实际上是一个宏，在传统的C头文件（stddef.h）中
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以注意到NULL被定义为字面常量0，或者被定义为无类型指针（void*）的常量，无论何种定义，在使用空值的指针时候，难免会遇到一些麻烦。
#include <iostream>
void f(int a)
{
std::cout << "f(int)" << std::endl;
}
void f(int* a)
{
std::cout << "f(int*)" << std::endl;
}
int main()
{
f(0);
f(NULL);//int
return 0;//int
}
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器
默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。
注意：
1.在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为关键字来引入的。
2.在C++11中，sizeof（nullptr)和sizeof（（void*）0）所占字节相等。
3.为了提高代码的健壮性，在后续的表示指针空值时，最好使用nullptr。