点击上方“C语言与CPP编程”，选择“关注/置顶/星标公众号”

干货福利，第一时间送达！最近有小伙伴说没有收到当天的文章推送，这是因为微信改了推送机制，确实会一部分有小伙伴刷不到当天的文章，一些比较实用的知识和信息，错过了就是错过了。所以建议大家加个星标⭐️，就能第一时间收到推送了。

小伙伴们大家好，我是飞宇。

(资料图片)

const 的指针与引用

（为了方便记忆可以想成）被 const 修饰（在 const 后面）的值不可改变，如下文使用例子中的 p2、p3。

使用

// 类class A{private:  const int a;        // 常对象成员，只能在初始化列表赋值public:  // 构造函数  A() : a(0) { };  A(int x) : a(x) { };    // 初始化列表  // const可用于对重载函数的区分  int getValue();       // 普通成员函数  int getValue() const;    // 常成员函数，不得修改类中的任何数据成员的值};void function(){  // 对象  A b;            // 普通对象，可以调用全部成员函数、更新常成员变量  const A a;         // 常对象，只能调用常成员函数  const A *p = &a;      // 指针变量，指向常对象  const A &q = a;       // 指向常对象的引用  // 指针  char greeting[] = "Hello";  char* p1 = greeting;        // 指针变量，指向字符数组变量  const char* p2 = greeting;     // 指针变量，指向字符数组常量（const 后面是 char，说明指向的字符（char）不可改变）  char* const p3 = greeting;     // 自身是常量的指针，指向字符数组变量（const 后面是 p3，说明 p3 指针自身不可改变）  const char* const p4 = greeting;  // 自身是常量的指针，指向字符数组常量}// 函数void function1(const int Var);      // 传递过来的参数在函数内不可变void function2(const char* Var);     // 参数指针所指内容为常量void function3(char* const Var);     // 参数指针为常量void function4(const int& Var);     // 引用参数在函数内为常量// 函数返回值const int function5();   // 返回一个常数const int* function6();   // 返回一个指向常量的指针变量，使用：const int *p = function6();int* const function7();   // 返回一个指向变量的常指针，使用：int* const p = function7();

static

作用

this 指针

在以下场景中，经常需要显式引用 this 指针：

inline 内联函数

特征

使用

inline 使用

// 声明1（加 inline，建议使用）inline int functionName(int first, int second,...);// 声明2（不加 inline）int functionName(int first, int second,...);// 定义inline int functionName(int first, int second,...) {/****/};// 类内定义，隐式内联class A {  int doA() { return 0; }     // 隐式内联}// 类外定义，需要显式内联class A {  int doA();}inline int A::doA() { return 0; }  // 需要显式内联

编译器对 inline 函数处理步骤

优缺点

优点

虚函数（virtual）可以是内联函数（inline）吗？

Are "inline virtual" member functions ever actually "inlined"?

虚函数内联使用

#include using namespace std;class Base{public:inline virtual void who(){cout << "I am Base\n";}virtual ~Base() {}};class Derived : public Base{public:inline void who() // 不写inline时隐式内联{cout << "I am Derived\n";}};int main(){// 此处的虚函数 who()，是通过类（Base）的具体对象（b）来调用的，编译期间就能确定了，所以它可以是内联的，但最终是否内联取决于编译器。Base b;b.who();// 此处的虚函数是通过指针调用的，呈现多态性，需要在运行时期间才能确定，所以不能为内联。Base *ptr = new Derived();ptr->who();// 因为Base有虚析构函数（virtual ~Base() {}），所以 delete 时，会先调用派生类（Derived）析构函数，再调用基类（Base）析构函数，防止内存泄漏。delete ptr;ptr = nullptr;system("pause");return 0;}

volatile

volatile int i = 10;

assert()

断言，是宏，而非函数。assert 宏的原型定义在 （C）、（C++）中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义 NDEBUG 来关闭 assert，但是需要在源代码的开头，include 之前。

assert() 使用

#define NDEBUG     // 加上这行，则 assert 不可用#include assert( p != NULL );  // assert 不可用

sizeof()

#pragma pack(n)

设定结构体、联合以及类成员变量以 n 字节方式对齐

#pragma pack(n) 使用

#pragma pack(push) // 保存对齐状态#pragma pack(4)   // 设定为 4 字节对齐struct test{  char m1;  double m4;  int m3;};#pragma pack(pop)  // 恢复对齐状态

位域

Bit mode: 2; // mode 占 2 位

类可以将其（非静态）数据成员定义为位域（bit-field），在一个位域中含有一定数量的二进制位。当一个程序需要向其他程序或硬件设备传递二进制数据时，通常会用到位域。

extern "C"

extern "C" 的作用是让 C++ 编译器将 extern "C" 声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。

extern "C" 使用

#ifdef __cplusplusextern "C" {#endifvoid *memset(void *, int, size_t);#ifdef __cplusplus}#endif

struct 和 typedef struct

C 中

// ctypedef struct Student {  int age;} S;

等价于

// cstruct Student {  int age;};

typedef struct Student S; 此时 S 等价于 struct Student，但两个标识符名称空间不相同。

另外还可以定义与 struct Student 不冲突的 void Student() {}。

C++ 中

由于编译器定位符号的规则（搜索规则）改变，导致不同于C语言。

1.如果在类标识符空间定义了 struct Student {...};，使用 Student me; 时，编译器将搜索全局标识符表，Student 未找到，则在类标识符内搜索。

即表现为可以使用 Student 也可以使用 struct Student，如下：

// cppstruct Student {  int age;};void f( Student me );    // 正确，"struct" 关键字可省略

2.若定义了与 Student 同名函数之后，则 Student 只代表函数，不代表结构体，如下：

typedef struct Student {  int age;} S;void Student() {}      // 正确，定义后 "Student" 只代表此函数//void S() {}        // 错误，符号 "S" 已经被定义为一个 "struct Student" 的别名int main() {  Student();  struct Student me;   // 或者 "S me";  return 0;}

C++ 中 struct 和 class

总的来说，struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。

区别:

最本质的一个区别就是默认的访问控制

union 联合

联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：

union 使用

#includeunion UnionTest {  UnionTest() : i(10) {};  int i;  double d;};static union {  int i;  double d;};int main() {  UnionTest u;  union {    int i;    double d;  };  std::cout << u.i << std::endl; // 输出 UnionTest 联合的 10  ::i = 20;  std::cout << ::i << std::endl; // 输出全局静态匿名联合的 20  i = 30;  std::cout << i << std::endl;  // 输出局部匿名联合的 30  return 0;}

C语言实现C++类

C 实现 C++ 的面向对象特性（封装、继承、多态）

explicit（显式）关键字

explicit 使用

struct A{A(int) { }operator bool() const { return true; }};struct B{explicit B(int) {}explicit operator bool() const { return true; }};void doA(A a) {}void doB(B b) {}int main(){A a1(1);// OK：直接初始化A a2 = 1;// OK：复制初始化A a3{ 1 };// OK：直接列表初始化A a4 = { 1 };// OK：复制列表初始化A a5 = (A)1;// OK：允许 static_cast 的显式转换doA(1);// OK：允许从 int 到 A 的隐式转换if (a1);// OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换bool a6（a1）;// OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换bool a7 = a1;// OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换bool a8 = static_cast(a1); // OK ：static_cast 进行直接初始化B b1(1);// OK：直接初始化B b2 = 1;// 错误：被 explicit 修饰构造函数的对象不可以复制初始化B b3{ 1 };// OK：直接列表初始化B b4 = { 1 };// 错误：被 explicit 修饰构造函数的对象不可以复制列表初始化B b5 = (B)1;// OK：允许 static_cast 的显式转换doB(1);// 错误：被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换if (b1);// OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换bool b6(b1);// OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换bool b7 = b1;// 错误：被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换bool b8 = static_cast(b1); // OK：static_cast 进行直接初始化return 0;}

friend 友元类和友元函数

using

using 声明

一条 using 声明 语句一次只引入命名空间的一个成员。它使得我们可以清楚知道程序中所引用的到底是哪个名字。如：

using namespace_name::name;

构造函数的 using 声明

在 C++11 中，派生类能够重用其直接基类定义的构造函数。

class Derived : Base {public:  using Base::Base;  /* ... */};

如上 using 声明，对于基类的每个构造函数，编译器都生成一个与之对应（形参列表完全相同）的派生类构造函数。生成如下类型构造函数：Derived(parms) : Base(args) { }

using 指示

using 指示 使得某个特定命名空间中所有名字都可见，这样我们就无需再为它们添加任何前缀限定符了。如：

using namespace_name name;

尽量少使用 using 指示 污染命名空间

一般说来，使用 using 命令比使用 using 编译命令更安全，这是由于它只导入了指定的名称。如果该名称与局部名称发生冲突，编译器将发出指示。using编译命令导入所有的名称，包括可能并不需要的名称。如果与局部名称发生冲突，则局部名称将覆盖名称空间版本，而编译器并不会发出警告。另外，名称空间的开放性意味着名称空间的名称可能分散在多个地方，这使得难以准确知道添加了哪些名称。

using 使用

尽量少使用 using 指示

using namespace std;

应该多使用 using 声明

int x;std::cin >> x ;std::cout << x << std::endl;

或者

using std::cin;using std::cout;using std::endl;int x;cin >> x;cout << x << endl;

:: 范围解析运算符

分类

:: 使用

int count = 11;     // 全局（::）的 countclass A {public:static int count;  // 类 A 的 count（A::count）};int A::count = 21;void fun(){int count = 31;   // 初始化局部的 count 为 31count = 32;     // 设置局部的 count 的值为 32}int main() {::count = 12;    // 测试 1：设置全局的 count 的值为 12A::count = 22;   // 测试 2：设置类 A 的 count 为 22fun();    // 测试 3return 0;}

enum 枚举类型

定作用域的枚举类型

enum class open_modes { input, output, append };

不限定作用域的枚举类型

enum color { red, yellow, green }; enum { floatPrec = 6, doublePrec = 10 };

decltype

decltype 关键字用于检查实体的声明类型或表达式的类型及值分类。语法：

decltype ( expression )

decltype 使用

// 尾置返回允许我们在参数列表之后声明返回类型template auto fcn(It beg, It end) -> decltype(*beg){  // 处理序列  return *beg;  // 返回序列中一个元素的引用}// 为了使用模板参数成员，必须用 typenametemplate auto fcn2(It beg, It end) -> typename remove_reference::type{  // 处理序列  return *beg;  // 返回序列中一个元素的拷贝}

引用

左值引用

常规引用，一般表示对象的身份。

右值引用

右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。

右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：

引用折叠

宏

宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对 “参数” 进行的是一对一的替换。

成员初始化列表

好处

initializer_list 列表初始化

用花括号初始化器列表初始化一个对象，其中对应构造函数接受一个 std::initializer_list 参数.

initializer_list 使用

#include #include #include template struct S {  std::vectorv;  S(std::initializer_listl) : v(l) {     std::cout << "constructed with a " << l.size() << "-element list\n";  }  void append(std::initializer_listl) {    v.insert(v.end(), l.begin(), l.end());  }  std::pairc_arr() const {    return {&v[0], v.size()}; // 在 return 语句中复制列表初始化                  // 这不使用 std::initializer_list  }}; template void templated_fn(T) {} int main(){  Ss = {1, 2, 3, 4, 5}; // 复制初始化  s.append({6, 7, 8});   // 函数调用中的列表初始化   std::cout << "The vector size is now " << s.c_arr().second << " ints:\n";   for (auto n : s.v)    std::cout << n << " ";  std::cout << "\n";   std::cout << "Range-for over brace-init-list: \n";   for (int x : {-1, -2, -3}) // auto 的规则令此带范围 for 工作    std::cout << x << " ";  std::cout << "\n";   auto al = {10, 11, 12};  // auto 的特殊规则   std::cout << "The list bound to auto has size() = " << al.size() << "\n"; //  templated_fn({1, 2, 3}); // 编译错误！“ {1, 2, 3} ”不是表达式，               // 它无类型，故 T 无法推导  templated_fn>({1, 2, 3}); // OK  templated_fn>({1, 2, 3});      // 也 OK}

面向对象

面向对象程序设计（Object-oriented programming，OOP）是种具有对象概念的程序编程典范，同时也是一种程序开发的抽象方针。

面向对象特征

面向对象三大特征 —— 封装、继承、多态

封装

把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。关键字：public, protected, private。不写默认为 private。

继承

多态

静态多态（编译期/早绑定）

函数重载

class A{public:  void do(int a);  void do(int a, int b);};

动态多态（运行期期/晚绑定）

注意：

动态多态使用

class Shape           // 形状类{public:  virtual double calcArea()  {    ...  }  virtual ~Shape();};class Circle : public Shape   // 圆形类{public:  virtual double calcArea();  ...};class Rect : public Shape    // 矩形类{public:  virtual double calcArea();  ...};int main(){  Shape * shape1 = new Circle(4.0);  Shape * shape2 = new Rect(5.0, 6.0);  shape1->calcArea();     // 调用圆形类里面的方法  shape2->calcArea();     // 调用矩形类里面的方法  delete shape1;  shape1 = nullptr;  delete shape2;  shape2 = nullptr;  return 0;}

虚析构函数

虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。

虚析构函数使用

class Shape{public:  Shape();          // 构造函数不能是虚函数  virtual double calcArea();  virtual ~Shape();      // 虚析构函数};class Circle : public Shape   // 圆形类{public:  virtual double calcArea();  ...};int main(){  Shape * shape1 = new Circle(4.0);  shape1->calcArea();  delete shape1; // 因为Shape有虚析构函数，所以delete释放内存时，先调用子类析构函数，再调用基类析构函数，防止内存泄漏。  shape1 = NULL;  return 0；}

纯虚函数

纯虚函数是一种特殊的虚函数，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。

virtual int A() = 0;

虚函数、纯虚函数

虚函数指针、虚函数表

虚继承

虚继承用于解决多继承条件下的菱形继承问题（浪费存储空间、存在二义性）。

底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现，每个虚继承的子类都有一个虚基类指针（占用一个指针的存储空间，4字节）和虚基类表（不占用类对象的存储空间）（需要强调的是，虚基类依旧会在子类里面存在拷贝，只是仅仅最多存在一份而已，并不是不在子类里面了）；当虚继承的子类被当做父类继承时，虚基类指针也会被继承。

实际上，vbptr 指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚基类表（virtual table），虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。

虚继承、虚函数

虚继承

虚函数

模板类、成员模板、虚函数

抽象类、接口类、聚合类

抽象类：含有纯虚函数的类

接口类：仅含有纯虚函数的抽象类

聚合类：用户可以直接访问其成员，并且具有特殊的初始化语法形式。满足如下特点：

内存分配和管理

malloc、calloc、realloc、alloca

malloc、free

用于分配、释放内存

malloc、free 使用

申请内存，确认是否申请成功

char *str = (char*) malloc(100);assert(str != nullptr);

释放内存后指针置空

free(p);p = nullptr;

new、delete

new、delete 使用

申请内存，确认是否申请成功

int main(){  T* t = new T();   // 先内存分配 ，再构造函数  delete t;      // 先析构函数，再内存释放  return 0;}

定位 new

定位 new（placement new）允许我们向 new 传递额外的地址参数，从而在预先指定的内存区域创建对象。

new (place_address) typenew (place_address) type (initializers)new (place_address) type [size]new (place_address) type [size] { braced initializer list }

delete this 合法吗？

合法，但：

定义只在堆(栈)生成对象类

只能在堆上

方法：将析构函数设置为私有

原因：C++ 是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。

能在栈上

方法：将 new 和 delete 重载为私有

原因：在堆上生成对象，使用 new 关键词操作，其过程分为两阶段：第一阶段，使用 new 在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。将 new 操作设置为私有，那么第一阶段就无法完成，就不能够在堆上生成对象。

智能指针

C++ 标准库（STL）中

头文件：#include

C++ 98

std::auto_ptrps (new std::string(str))；

C++ 11

对于该论述，欢迎读者查阅之前发过的文章，你是《未来世界的幸存者》么？

3.7 分割线

可以在一行中用三个以上的减号来建立一个分隔线，同时需要在分隔线的上面空一行。如下：

shared_ptr

多个智能指针可以共享同一个对象，对象的最末一个拥有着有责任销毁对象，并清理与该对象相关的所有资源。

weak_ptr

weak_ptr 允许你共享但不拥有某对象，一旦最末一个拥有该对象的智能指针失去了所有权，任何 weak_ptr 都会自动成空（empty）。因此，在 default 和 copy 构造函数之外，weak_ptr 只提供 “接受一个 shared_ptr” 的构造函数。

unique_ptr

unique_ptr 是 C++11 才开始提供的类型，是一种在异常时可以帮助避免资源泄漏的智能指针。采用独占式拥有，意味着可以确保一个对象和其相应的资源同一时间只被一个 pointer 拥有。一旦拥有着被销毁或编程 empty，或开始拥有另一个对象，先前拥有的那个对象就会被销毁，其任何相应资源亦会被释放。

auto_ptr

被 c++11 弃用，原因是缺乏语言特性如 “针对构造和赋值” 的 std::move 语义，以及其他瑕疵。

auto_ptr 与 unique_ptr 比较

强制类型转换运算符

static_cast

dynamic_cast

const_cast

reinterpret_cast

bad_cast

bad_cast 使用

try {  Circle& ref_circle = dynamic_cast(ref_shape);}catch (bad_cast b) {  cout << "Caught: " << b.what();}

运行时类型信息 (RTTI)

dynamic_cast

typeid

type_info

typeid、type_info 使用

#include using namespace std;class Flyable            // 能飞的{public:  virtual void takeoff() = 0;   // 起飞  virtual void land() = 0;    // 降落};class Bird : public Flyable     // 鸟{public:  void foraging() {...}      // 觅食  virtual void takeoff() {...}  virtual void land() {...}  virtual ~Bird(){}};class Plane : public Flyable    // 飞机{public:  void carry() {...}       // 运输  virtual void takeoff() {...}  virtual void land() {...}};class type_info{public:  const char* name() const;  bool operator == (const type_info & rhs) const;  bool operator != (const type_info & rhs) const;  int before(const type_info & rhs) const;  virtual ~type_info();private:  ...};void doSomething(Flyable *obj)         // 做些事情{  obj->takeoff();  cout << typeid(*obj).name() << endl;    // 输出传入对象类型（"class Bird" or "class Plane"）  if(typeid(*obj) == typeid(Bird))      // 判断对象类型  {    Bird *bird = dynamic_cast(obj); // 对象转化    bird->foraging();  }  obj->land();}int main(){Bird *b = new Bird();doSomething(b);delete b;b = nullptr;return 0;}

你好，我是飞宇，本硕均于某中流985 CS就读，先后于百度搜索以及字节跳动电商等部门担任Linux C/C++后端研发工程师。
同时，我也是知乎博主@韩飞宇，日常分享C/C++、计算机学习经验、工作体会，欢迎点击此处查看我以前的学习笔记&经验&分享的资源。
这里分享一些C++开发手册、LeetCode刷题模板等精品资料，扫描下方二维码免费领取。