1.C++关键字(C++98)

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

注意：下面我们只看C++有多少关键字，不对关键字进行具体详讲。后面学到以后再细讲。

其中有32个是C语言中的:

2.类域和命名空间

一、类域

类域是指类中定义的成员变量和成员函数的作用范围。类的成员变量只能通过类的实例访问，而成员函数可以直接操作这些变量。

后续的文章会详细讲解类此处只是为了引入类的作用域。

示例：

class MyClass
{
public:
    int classval = 10;//类域中的成员变量
    void display()
    {
        std::cout << "classval: " << classval << std::endl;
    }
};
int main()
{
    MyClass obj;
    obj.display();//输出classval: 10
    return 0;
}

类域中的变量通过对象访问，确保了数据的封装性和安全性。

二、命名空间

1.定义

//命名空间域的定义
namespace zuo
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }
注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
    struct Node
    {
    struct Node* next;
    int val;
    };
}

2.嵌套命名空间

命名空间可以嵌套，访问时需要逐层使用::

namespace Outer
{
    namespace Inter
    {
        int val = 20;
    }
}

int main()
{
    std::cout << Outer::Inter::val << std::endl;//输出20
    return 0;
}

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

所以我们不能在相同名称的命名空间中定义两个相同名称的成员。

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

3.命名空间的使用

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

int main()
{
    printf("%d\n",zuo::a);
    return 0;
}

2.使用using将命名空间中某个成员引入

我们还可以通过"using 命名空间域名称::命名空间成员"的方式将命名空间中指定的成员引入。这样一来该句话之后就可以直接使用引入的成员变量了。

namespace zuo
{
	int a;
	double b;
}
using bit::zuo;
void Test()
{
	printf("%d", a);
}

//若using bit::zuo;放这则函数中直接后面打印a会报错
int main()
{
	printf("%d\n", a);
	printf("%p\n", bit::b);
	return 0;
}

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

最后就是使用"using namespace 命名空间名称 "将命名空间中的成员全部引入。这样一来该句代码之后就可以直接使用该命名空间内的所有成员了。

namespace N
{
	int a;
	double b;
}

using namespace N;

void Test()
{
	printf("%d", a);
}


int main()
{
	printf("%d\n", a);
	printf("%p\n", N::b);
	return 0;
}

3.C++中的输入&输出

学习C语言的时第一段代码就是频幕上输出“hello world”,那么C++也该向世界打招呼了。

#include<iostream>

//std是C++标准库的命名空间名，C++标准库的定义实现都放到这个命名空间中
using namespace std;

int main()
{
    cout << "hello world" << endl;
    return 0;
}

说明：

1.使用cout标准输出流(控制台)和cin标准输入流(键盘)时，必须包含头文件<iostream>以及按命名空间使用方法使用std。

2.cout和cin是全局的流对象，endl是特殊的C++符号，表示输出换行，他们都必须包含在<iostream>头文件中。

3.<<是流插入运算符，>>是流提取运算符。

4.使用C++输入输出更方便，不需要像printf/scanf输入输出那样，需要手动输入格式(%d,%s.....)，C++的输入输出可以自动识别变量的类型。

5.实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载的知识，这些知识我们后续才会学到，所以此处只是简单应用，后面会深入学习IO流用法及原理。

4.缺省参数

1.缺省参数的概念

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

void Func(int a = 0)
{
 cout<<a<<endl;
}
int main()
{
 Func();     // 没有传参时，使用参数的默认值
 Func(10);   // 传参时，使用指定的实参
return 0;
}

2.缺省参数分类

1.全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

2.半缺省参数

void Func(int a, int b = 10, int c = 20)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

注意：

1.半缺省参数必须从右往左依次来给出，不能间隔着给

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

//错误示范 
//a.h
  void Func(int a = 10);
  
  // a.cpp
  void Func(int a = 20)
 {}
  
  // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。

一般建议在函数声明时给。二者出现其一也对。

3.缺省参数必须是常量或者全局变量

int x = 10;
void Func(int a,int b = 20,int c = x)
{
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
}

4.C语言不支持（编译器不支持）

在我们未屏蔽这段代码（int func(int a)）时编译会爆出如下错误

说明C编译器不支持函数重载。

5.函数重载

在自然语言中，一个词可以有多重含义，人们可以通过上下文判断该词的真正含义，即该词被重载了 。

比如：以前有个笑话，国有两个体育项目不需要看，也不用担心。一个是乒乓球，一个是足球，前者“谁也赢不了”,后者“谁也赢不了”。

1.函数重载的概念

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

#include<iostream>
using namespace std;


// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}
// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

int main()
{
    Add(10,20);
    Add(10.1,20.2);
    
    f();
    f(10);
    
    f(10,'a');
    f('a',10);
    return 0;
}

注意：形参不同指的是参数的个数、参数的类型或参数的顺序不同，若仅仅是返回类型不同，则不能构成重载。

2.函数重载的原理（名字修饰）

为什么C++支持函数重载，而C语言不支持呢？

我们知道，一个C/C++程序运行起来需要经历以下阶段：预处理、编译、汇编、链接。

注意：

预处理阶段：头文件的替换/宏替换/条件编译/去掉注释.....

编译：检查语法，生成汇编代码。

汇编：汇编代码转换成二进制机器码

1.实际项目通常是由多个头文件和多个源文件构成，而通过C语言学习阶段的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中，那么怎么办呢？

2.所以在链接阶段专门就是处理这种问题，链接看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。

3.那么链接时，面对Add函数，链接器会使用哪个名字去查找呢？这里每个编译器都有自己的函数名修饰规则。

4.Windows下的vs过于复杂，我们看Linux下的g++演示修饰后的名字。

这段代码（int func(int a)）屏蔽时

这里的<func>就是对函数的修饰

C++如下命名规则【_Z+函数长度+函数名+类型首字母】

5.通过这里我们就可以理解C语言没法支持函数重载，因为同名函数没办法区分。而C++则是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

6.再次重申如果两个函数函数名和参数一样，返回值不同是不构成重载的，因为编译器调用时没法区分

3.extern “C”

有时候在C++工程中可能需要某些函数按照C语言的风格来编译，在函数前加"extern C"，告诉编译器此函数按照C语言的规则来编译。

注意：在函数前加了"extern C"该函数便不支持重载了

6.引用

1.引用概念

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

比如：李逵，在家称为“铁牛”，江湖人称“黑旋风”。

基本形式：类型& 引用变量名(对象名) = 引用实体

void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

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

2.引用的特性

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

int a = 1;
int& b = a;
//错误示例
int c = 10;
int& d;
d = c;

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

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

也就是说a可以有多个别名，b,c,d的改变都会引起a的改变。

3.引用一旦引用一个实体便不能引用其他实体

int a = 0;
int& b = a;
int& c = b;
//引用一旦引用一个实体，再不能引用其他实体
int x = 10;
c = x;//这里是把x的值赋给c,c依旧是a/b对象的别名

3.常引用

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;
}

此处我解释一下为什么第一个会报错？

const修饰的成员是不能被改变的，而int& ra是可以被改变的这就涉及了权限的放大而权限只能平移和缩小不能被放大。后续在类和对象中会着重讲解，这里先知道就可以。

4.引用的使用场景

1.引用做参数

void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}
int main()
{ 
    int a = 10;
    int b = 20;
    Swap(a,b);
    return 0;
}

这里就不用再像c语言一样传指针了，因为传引用相当于取别名，Swap函数中的值改变会影响main函数中的值的改变.

2.引用做返回值

 //传值返回
int Count()
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	int ret = Count();
	return 0;
}

//传引用返回
 //正确样例
int& Count()
{
	static int n = 0;//静态对象可以用引用返回
	n++;
	return n;
}
int main()
{
	int ret = Count();
	return 0;
}

//错误样例
int& Count()
{
	int n = 0;//局部对象不可以用引用返回
	n++;
	return n;
}

注意：如果函数返回时，出了函数作用域，返回对象未还给操作系统，则可以使用引用返回。如果已经还给操作系统了，则必须使用传值返回。

3.指针和引用的区别

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

int main()
{
    int a = 10;
    //语法上给a取了一个别名没有开辟空间
    int& ra = a;
    ra = 20;
    //在语法上开辟了4个字节（32位机器）空间，用于存储a的地址
    int* pa = &a;
    *pa = 20;
    
    return 0;
}

但是在底层实际上是有空间开辟的引用：

从汇编角度来看，引用的底层实现逻辑也是类似指针存地址的方式来处理的。

引用和指针的重要区别：

1.引用在定义时必须初始化，指针没有要求。

2.引用在初始化后引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向一个同类型的实体。

3.没有NULL引用，但是又NULL指针。

4.在sizeof中含义不同：引用的结果为引用类型的大小，但是指针始终指的是空间所占字节的大小（32位机器下4字节）。

5.引用自增操作相当于实体加1，而指针进行自增是指指针向后偏移一个类型的大小。

6.有多级指针，但是没有多级引用。

7.访问实体的方式不同，指针需要显式解引用，而引用则是编译器自己处理。

8.引用比指针更安全。

7.内联函数

1.内联函数的概念

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

C语言想将代码展开我们可以用宏函数：

#define Add(x,y) ((x) + (y))
int main()
{
	for (int i = 0; i < 10000; i++)
	{
		cout << Add(i, i + 1) << endl;
	}
	return 0;
}

在C++中我们可以通过内联函数

//普通函数
int Add(int a,int b)
{
    return a + b;
}

int main()
{
    int ret = Add(1,2);
    return 0;
}
//内联函数
inline int Add(int a,int b)
{
    return a + b;
}

int main()
{
    int ret = Add(1,2);
    return 0;
}

从汇编代码中我们可以看到，内联函数没有调用函数这个过程的汇编指令。

2.内联函数的特性

1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数来处理，在编译阶段，会用函数体替换函数调用，缺陷：可能使目标文件变大;优势：少了调用开销，提高程序运行效率。

2.inline对于编译器来说只是一个建议，编译器会自动优化，如果定义中有递归，则编译器优化时会忽略掉内联。

3.inline函数不建议声明和定义分离，分离会导致链接错误。因为inline被展开，没有内存地址了链接时就无法找到。

面试题：

宏的优缺点？

优点：

1.增强代码的复用性。

2.提高性能。

缺点：

1.不方便调试（因为编译阶段进行了替换）

2.导致代码的可读性变差，可维护性差，容易误用。

3.没有安全类型检查。

C++中有哪些技术可以代替宏？

1.常量定义 换用const enum

2.短小函数定义 换用内联函数

auto关键字（C++11）

随着程序的复杂，程序中用到的类型也越来越复杂

1.类型难于拼写

2.含义不明确导致容易出错

#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.end())
 {
 //....
 }
 return 0;
}

聪明的同学已经想到使用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.end())
 {
 //....
 }
 return 0;
}

1.auto简介

在早期C/C++中的auto含义是：auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人使用。

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

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;
    //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
    return 0;
}

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

2.auto的使用细则

一、auto与指针和引用结合起来使用

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

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    *a = 20;
    *b = 30;
     c = 40;
    return 0;
}

二、在同一行定义多个变量

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

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};//error
}

3.为了避免C++98与C++11混淆，C++11只保留了auto作为类型指示符的用法

4.auto实际中最常见的优势是跟以后C++11提供的新式for循环，还有lambda表达式等配合使用

基于范围for循环（C++11）

范围for的语法

若是C++98中我们遍历一个数组，可以这么做

int main()
{
	int arr[] = { 1,2,3,4,5 };
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		arr[i] *= 2;
	for (int* p = arr; p < arr + sizeof(arr) / sizeof(int); p++)
		cout << *p << endl;

	return 0;
}

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

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
         e *= 2;
    for(auto e : array)
     cout << e << " ";
    return 0;
}

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

范围for的使用条件

一、for迭代的范围必须是确定的

对于数组而言，就是数组的第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end方法，begin和end就是for循环的迭代范围

//错误示范
void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}

二、迭代的对象要实现++和==的操作。（关于迭代器的问题大家先了解一下，以后还会讲）。

指针空值nullptr（C++11）

1.C++98中的空指针

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

void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
    // ……
}

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

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

可以看到NULL可能被定义为字面常量0，或者定义为无类型指针（void*）的常量。无论采取何种方式，在使用空值的指针时，都不可避免会遇到一些麻烦，比如：

void f(int)
{
 cout<<"f(int)"<<endl;
}
void f(int*)
{
 cout<<"f(int*)"<<endl;
}
int main()
{
 f(0);
 f(NULL);//输出f(int)
 f((int*)NULL);//输出f(int*)
 return 0;
}

程序的本意是通过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。