C++知识梳理

最新推荐文章于 2022-05-26 11:02:26 发布

LoaryBetter

最新推荐文章于 2022-05-26 11:02:26 发布

阅读量1.5k

点赞数

文章标签： c++

本文链接：https://blog.youkuaiyun.com/qq_21717739/article/details/119456266

版权

📖 Github | 📚 Docsify

简体中文 | English

💡 关于

📚 本仓库是面向 C/C++ 技术方向校招求职者、初学者的基础知识总结，包括语言、程序库、数据结构、算法、系统、网络、链接装载库等知识及面试经验、招聘、内推等信息。

💡 侧边目录支持方式：📚 Docsify 文档、Github + TOC 导航（TOC预览.png）

📄 保存为 PDF 方式：使用 Chrome 浏览器打开 📚 Docsify 文档页面，缩起左侧目录-右键 - 打印 - 选择目标打印机是另存为PDF - 保存（打印预览.png）

🙏 仓库内容如有错误或改进欢迎 issue 或 pr，建议或讨论可在 #12 提出。由于本人水平有限，仓库中的知识点有来自本人原创、读书笔记、书籍、博文等，非原创均已标明出处，如有遗漏，请 issue 提出。本仓库遵循 CC BY-NC-SA 4.0（署名 - 非商业性使用 - 相同方式共享）协议，转载请注明出处，不得用于商业目的。

📑 目录

➕ C/C++
⭐️ Effective
📦 STL
〽️ 数据结构
⚡️ 算法
❓ Problems
💻 操作系统
☁️ 计算机网络
🌩 网络编程
💾 数据库
📏 设计模式
⚙️ 链接装载库
📚 书籍
🔱 C/C++ 发展方向
💯 复习刷题网站
📝 面试题目经验
📆 招聘时间岗位
👍 内推
👬 贡献者
🍭 支持赞助
📜 License

➕ C/C++

const

作用

修饰变量，说明该变量不可以被改变；
修饰指针，分为指向常量的指针（pointer to const）和自身是常量的指针（常量指针，const pointer）；
修饰引用，指向常量的引用（reference to const），用于形参类型，即避免了拷贝，又避免了函数对值的修改；
修饰成员函数，说明该成员函数内不能修改成员变量。

const 的指针与引用

指针
- 指向常量的指针（pointer to const）
- 自身是常量的指针（常量指针，const pointer）
引用
- 指向常量的引用（reference to const）
- 没有 const reference，因为引用只是对象的别名，引用不是对象，不能用 const 修饰

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

使用

const 使用

// 类
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

作用

修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。
修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。

静态成员函数的主要作用就是用来访问静态成员变量

this 指针

this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向调用该成员函数所属的那个对象。

当对一个对象调用成员函数时，编译程序先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，都隐式使用 this 指针。

当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。

this 指针被隐含地声明为: ClassName *const this，这意味着不能给 this 指针赋值；在 ClassName 类的 const 成员函数中，this 指针的类型为：const ClassName* const，这说明不能对 this 指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；

this 并不是一个常规变量，而是个右值，所以不能取得 this 的地址（不能 &this）。

注意：静态成员函数没有this指针

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

为实现对象的链式引用；
为避免对同一对象进行赋值操作；

在实现一些数据结构时，如 list，链式编程，

Person& addAge(Person& p) //这里返回的是引用Person&，才能一直累加，如果返回的是Person，一直是副本，最后值等于28
{
	this->age+=p.age;
	return *this;//链式编程此处必须使用this指针
}
int main()
{
	Person p1(10);
    Person p2(18);
	p2.addAge(p1).addAge(p1).addAge(p1).....
	//再自身的基础上继续累加，链式编程
}

空指针访问成员函数

要看成员函数有没有用到this指针，用到会报空指针异常，因为入参用到了this指针。

常函数与常对象

成员函数声明后面加const，代表常函数，里面不可以修改成员属性了

void showPersion() const
- 特殊情况，如果成员属性使用mutable修饰的，则可以修改
常对象也不可以修改属性了

const Person p1
- 常对象只能调用常函数，不能调用非常函数，因为非常函数可以修改属性
- 特殊情况，如果成员属性使用mutable修饰的，则可以修改

inline 内联函数

特征

相当于把内联函数里面的内容写在调用内联函数处；
相当于不用执行进入函数的步骤，直接执行函数体；
相当于宏，却比宏多了类型检查，真正具有函数特性；
编译器一般不内联包含循环、递归、switch 等复杂操作的内联函数；
在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数。

使用

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 函数的处理步骤

将 inline 函数体复制到 inline 函数调用点处；
为所用 inline 函数中的局部变量分配内存空间；
将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；
如果 inline 函数有多个返回点，将其转变为 inline 函数代码块末尾的分支（使用 GOTO）。

优缺点

优点

内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。
内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。
在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义则不能。
内联函数在运行时可调试，而宏定义不可以。

缺点

代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译，不像 non-inline 可以直接链接。
是否内联，程序员不可控。内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器。

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

Are “inline virtual” member functions ever actually “inlined”?

虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。
内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
inline virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 Base::who()），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。

虚函数内联使用

#include <iostream>  
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;
}

虚函数

由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。虚函数只能借助于指针或者引用来达到多态的效果。

#include<iostream> 
#include <stdio.h>
using namespace std;
class A
{
   
    public:
    virtual void foo()
{
   
cout<<"A::foo() is called"<<endl;
}
};
    class B:public A
{
   
public:
void foo()
{
   
    cout<<"B::foo() is called"<<endl;
}
};
int main(void)
{
   
	A *a = new B();
	a->foo(); // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!因为class A中使用了virtual修饰
		     //由a所指的内存中的虚函数表的foo()的位置已经被B::foo()函数地址所取代，于是在实际调用发生时，是B::foo()被调用了。这就实现了多态。
	return 0;
}

其析构函数中对这些内存空间进行释放。假设基类中采用的是非虚析构函数,当删除基类指针指向的派生类对象时就不会触发动态绑定,因而只会调用基类的析构函数,而不会调用派生类的析构函数

volatile

volatile int i = 10;

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素（操作系统、硬件、其它线程等）更改。所以使用 volatile 告诉编译器不应对这样的对象进行优化。
volatile 关键字声明的变量，每次访问时都必须从内存中取出值（没有被 volatile 修饰的变量，可能由于编译器的优化，从 CPU 寄存器中取值）
const 可以是 volatile （如只读的状态寄存器）
指针可以是 volatile

assert()

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

assert() 使用

#define NDEBUG          // 加上这行，则 assert 不可用
#include <assert.h>

assert( p != NULL );    // assert 不可用

sizeof()

sizeof 对数组，得到整个数组所占空间大小。
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 限定的函数或变量是 extern 类型的
被 extern "C" 修饰的变量和函数是按照 C 语言方式编译和链接的

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

extern “C” 使用

#ifdef __cplusplus
extern "C" {
   
#endif

void *memset(void *, int, size_t);

#ifdef __cplusplus
}
#endif

struct 和 typedef struct

C 中

// c 结构体重命名
typedef struct Student {
   
    int age; 
} S;

等价于

// c
struct Student {
    
    int age; 
};

typedef struct Student S;

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

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

C++ 中

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

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

即表现为可以使用 Student 也可以使用 struct Student，这和C语言不同，C语言需要使用struct Student,即必须带上struct，C++不加struct会自己在类标识符中搜索，如下：

// cpp
struct Student {
    
    int age; 
};

void func1( Student me );       // 正确，"struct" 关键字可省略
//C
void func2(struct Student me)	//C语言必须使用struct

二、若定义了与 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;
}

可以看出，结构体的重命名和函数名不能重复，但是结构体的原名Student和函数名是可以重复的，并且重复后，Student是代表函数，不会代表结构体名，因此使用Student me;会报错（也就是回归了C,失去了C++搜索规则特性），必须使用 struct Student me;不分谁先定义的顺序。

C++ 中 struct 和 class

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

struct里也可以放函数

区别

最本质的一个区别就是默认的访问控制
1. 默认的继承访问权限。struct 是 public 的，class 是 private 的。
2. struct 作为数据结构的实现体，它默认的数据访问控制是 public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。.

union 联合

出现联合的目的是什么：就是为了省空间，较多域的数据结构里比较省，其实很少使用到，联合的大小就是这个体内占空间最大的那个值，每次改里面的值，都会影响到体内的其他值（其他值变更为未定义）。

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

默认访问控制符为 public
可以含有构造函数、析构函数
不能含有引用类型的成员
不能继承自其他类，不能作为基类
不能含有虚函数
匿名 union 在定义所在作用域可直接访问 union 成员
匿名 union 不能包含 protected 成员或 private 成员
全局匿名联合必须是静态（static）的

union 使用

#include<iostream>

union 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;    // main里 输出局部匿名联合的 30

    return 0;
}

C 实现 C++ 类

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

封装：使用函数指针把属性与方法封装到结构体中

封装是隐藏对象的属性和实现细节，仅对外公开接口和对象进行交互，将数据和操作数据的方法进行有机结合
继承：结构体嵌套
多态：父类与子类方法的函数指针不同

Can you write object-oriented code in C? [closed]

explicit（显式）关键字

explicit 修饰构造函数时，可以防止隐式转换和复制初始化
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<bool>(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<bool>(b1);  // OK：static_cast 进行直接初始化

	return 0;
}

单实例涉及模式

私有默认构造函数（不然别人通过new Singleton触发默认构造函数会创建多实例）
私有拷贝构造函数（不然会通过拷贝构造函数会创建多实例）
私有类静态成员指针（类外初始化）
新增public访问静态成员指针（唯一对象）接口getInstant

对象模型存储

只有非静态成员变量占空间，成员函数和static静态修饰的都不占空间
空对象的大小是1
空类也可以实例化对象

friend 友元类和友元函数

为什么会出现友元：你的家有客厅public，有卧室private，但是你偶尔会让你的基友允许进入你的卧室。这个基友就是友元。全局函数、类的成员函数、整个类都可以作为友元

能访问私有成员
破坏封装性
友元关系不可传递
友元关系的单向性
友元声明的形式及数量不受限制

[友元函数案例](https://www.c nblogs.com/zoneofmine/p/6497933.html)

数组类封装（myIntArray）

#include <iostream>
#include <stdio.h>
class MyIntArray
{
   
public:
	MyIntArray();
	MyIntArray(int capcity);
	MyIntArray(const MyIntArray & myarray);
	int getlength();
	void setvalue(int pos,int value);
	int getvalue(int pos);
	void back_push(int value);
	~MyIntArray();
private:
	int m_capcity;
	int m_length;
	int * m_arrayAddress;
};
MyIntArray::MyIntArray()
{
   
	m_capcity =100;
	m_length=0;
	m_arrayAddress =new int[m_capcity];
}
//拷贝构造函数
MyIntArray::MyIntArray(const MyIntArray & myarray)
{
   
	m_capcity =myarray.m_capcity;
	m_length=myarray.m_length;
	m_arrayAddress =new int[m_capcity];
	for(int i= 0;i< m_length;i++)
	{
   
		m_arrayAddress[i] = myarray.m_arrayAddress[i];
	}
}
MyIntArray::~MyIntArray()
{
   
	if(m_arrayAddress!=NULL)
	{
   	printf("析构函数\n");
		delete [] m_arrayAddress;
		m_arrayAddress=NULL;
	}		
}
MyIntArray::MyIntArray(int capcity)
{
   
	m_capcity = capcity;
	m_length=0;
	m_arrayAddress =new int[m_capcity];
}
int MyI

最低0.47元/天解锁文章