• ➕ C/C++
• ⭐️ Effective
• 📦 STL
• 〽️ 数かず据すえ结构
• ⚡️ 算法さんぽう
• ❓ Problems
• 💻 操作そうさ系けい统
• ☁️ 计算机つくえ网络
• 🌩 网络编程
• 💾 数かず据すえ库
• 📏 设计模も式しき
• ⚙️ 链接装そう载库
• 📚 书籍
• 🔱 C/C++ 发展方向ほうこう
• 💯 复习刷すり题网站
• 📝 面めん试题目め经验
• 📆 招聘しょうへい时间岗位
• 👍 内うち推
• 👬 贡献者しゃ
• 📜 License

1. 修おさむ饰变量りょう，说明该变量りょう不可ふか以被改あらため变；
2. 修おさむ饰指针，分ふん为指向しこう常つね量的りょうてき指ゆび针（pointer to const）和かず自身じしん是ぜ常つね量的りょうてき指ゆび针（常つね量りょう指ゆび针，const pointer）；
3. 修おさむ饰引用いんよう，指向しこう常つね量的りょうてき引用いんよう（reference to const），用よう于形参さん类型，即そく避免了りょう拷贝，又また避免了りょう函数かんすう对值的てき修おさむ改あらため；
4. 修おさむ饰成员函数すう，说明该成员函数すう内ない不能ふのう修おさむ改あらため成なり员变量りょう。

• 指ゆび针
  • 指向しこう常つね量的りょうてき指ゆび针（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();

1. 修おさむ饰普通どおり变量，修おさむ改あらため变量的てき存そん储区域くいき和わ生命せいめい周期しゅうき，使つかい变量存そん储在静せい态区，在ざい main 函数かんすう运行前ぜん就分配ぶんぱい了りょう空そら间，如果有ゆう初はつ始はじめ值就用よう初はつ始はじめ值初始はじめ化か它，如果没ぼつ有ゆう初はつ始はじめ值系统用默だま认值初はつ始はじめ化か它。
2. 修おさむ饰普通どおり函数かんすう，表明ひょうめい函数かんすう的てき作用さよう范围，仅在定てい义该函数かんすう的てき文ぶん件けん内ない才能さいのう使用しよう。在ざい多た人じん开发项目时，为了防止ぼうし与あずか他人たにん命名めいめい空そら间里的てき函はこ数すう重じゅう名めい，可か以将函数かんすう定位ていい为 static。
3. 修おさむ饰成员变量りょう，修おさむ饰成员变量りょう使し所有しょゆう的てき对象只ただ保存ほぞん一いち个该变量，而且不ふ需要じゅよう生成せいせい对象就可以访问该成なり员。
4. 修おさむ饰成员函数すう，修おさむ饰成员函数すう使つかい得とく不ふ需要じゅよう生成せいせい对象就可以访问该函数かんすう，但ただし是ぜ在ざい static 函数かんすう内ない不能ふのう访问非ひ静せい态成员。

1. this 指ゆび针是一个隐含于每一个非静态成员函数中的特殊指针。它指向しこう调用该成员函数すう的てき那な个对象ぞう。
2. 当とう对一个对象调用成员函数时，编译程ほど序じょ先さき将はた对象的てき地ち址し赋给 this 指ゆび针，然しか后きさき调用成なり员函数すう，每次まいじ成なり员函数すう存そん取と数かず据すえ成なり员时，都と隐式使用しよう this 指ゆび针。
3. 当とう一个成员函数被调用时，自じ动向它传递一个隐含的参数，该参数すう是ぜ一个指向这个成员函数所在的对象的指针。
4. this 指ゆび针被隐含地ち声明せいめい为: ClassName *const this，这意味いみ着ぎ不能ふのう给 this 指ゆび针赋值；在ざい ClassName 类的 const 成なり员函数すう中ちゅう，this 指ゆび针的类型为：const ClassName* const，这说明あかり不能ふのう对 this 指ゆび针所指向しこう的てき这种对象是ぜ不可ふか修おさむ改あらため的てき（即そく不能ふのう对这种对象ぞう的てき数すう据すえ成なり员进行ぎょう赋值操作そうさ）；
5. this 并不是ぜ一个常规变量，而是个右值，所以ゆえん不能ふのう取得しゅとく this 的まと地ち址し（不能ふのう &this）。
6. 在ざい以下いか场景中ちゅう，经常需要じゅよう显式引用いんよう this 指ゆび针：
   1. 为实现对象ぞう的てき链式引用いんよう；
   2. 为避免めん对同一对象进行赋值操作；
   3. 在ざい实现一些数据结构时，如 list。

• 相当そうとう于把内ない联函数すう里さと面めん的てき内容ないよう写うつし在ざい调用内ない联函数すう处；
• 相当そうとう于不用よう执行进入函数かんすう的てき步ふ骤，直接ちょくせつ执行函数かんすう体たい；
• 相当そうとう于宏，却比宏ひろし多た了りょう类型检查，真正しんしょう具有ぐゆう函数かんすう特性とくせい；
• 编译器き一般不内联包含循环、递归、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; }   // 需要じゅよう显式内ない联

1. 将はた inline 函数かんすう体たい复制到いた inline 函数かんすう调用点てん处；
2. 为所用よう inline 函数かんすう中ちゅう的てき局部きょくぶ变量分配ぶんぱい内ない存そん空そら间；
3. 将はた inline 函数かんすう的てき的てき输入参さん数すう和わ返かえし回かい值映射い到いた调用方法ほうほう的てき局部きょくぶ变量空そら间中；
4. 如果 inline 函数かんすう有ゆう多た个返回かい点てん，将はた其转变为 inline 函数かんすう代だい码块末尾まつび的てき分ぶん支ささえ（使用しよう GOTO）。

优点

1. 内うち联函数すう同どう宏ひろし函数かんすう一样将在被调用处进行代码展开，省はぶけ去ざ了りょう参まいり数すう压栈、栈帧开辟与回收かいしゅう，结果返かえし回かい等とう，从而提ひさげ高だか程ほど序じょ运行速度そくど。
2. 内うち联函数すう相そう比ひ宏ひろし函数かんすう来らい说，在ざい代だい码展开时，会かい做安全ぜん检查或ある自じ动类型がた转换（同どう普通ふつう函数かんすう），而宏定てい义则不ふ会かい。
3. 在ざい类中声明せいめい同どう时定义的成なり员函数すう，自じ动转化か为内联函数すう，因いん此内联函数すう可か以访问类的てき成なり员变量りょう，宏ひろし定てい义则不能ふのう。
4. 内うち联函数すう在ざい运行时可调试，而宏定てい义不可ふか以。

缺点けってん

1. 代だい码膨胀。内うち联是以代码膨胀（复制）为代价，消しょう除じょ函数かんすう调用带来的てき开销。如果执行函数かんすう体内たいない代だい码的时间，相そう比ひ于函数すう调用的てき开销较大，那な么效率りつ的てき收おさむ获会很少。另一方面ほうめん，每まい一处内联函数的调用都要复制代码，将しょう使し程ほど序じょ的てき总代码量增大ぞうだい，消耗しょうもう更さら多た的てき内ない存そん空そら间。
2. inline 函数かんすう无法随ずい着ぎ函数かんすう库升级而升ます级。inline函数かんすう的てき改あらため变需要じゅよう重おも新しん编译，不ふ像ぞう non-inline 可か以直接ちょくせつ链接。
3. 是ぜ否ひ内ない联，程ほど序じょ员不可ふか控ひかえ。内うち联函数すう只ただ是ぜ对编译器的てき建けん议，是ぜ否ひ对函数すう内ない联，决定权在于编译器。

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

volatile int i = 10; 

• volatile 关键字じ是ぜ一种类型修饰符，用よう它声明せいめい的てき类型变量表示ひょうじ可か以被某ぼう些编译器未み知的ちてき因いん素もと（操作そうさ系けい统、硬かた件けん、其它线程等とう）更改こうかい。所以ゆえん使用しよう volatile 告つげ诉编译器不ふ应对这样的てき对象进行优化。
• volatile 关键字じ声明せいめい的てき变量，每次まいじ访问时都必须从内存そん中ちゅう取出とりで值（没ぼつ有ゆう被ひ volatile 修おさむ饰的变量，可能かのう由よし于编译器的てき优化，从 CPU 寄よせ存そん器き中ちゅう取と值）
• const 可か以是 volatile （如只读的状じょう态寄存そん器き）
• 指ゆび针可以是 volatile

断言だんげん，是ぜ宏ひろし，而非函数かんすう。assert 宏ひろし的てき原型げんけい定てい义在 <assert.h>（C）、<cassert>（C++）中ちゅう，其作用よう是ぜ如果它的条件じょうけん返かえし回かい错误，则终止とめ程ほど序じょ执行。可か以通过定义 NDEBUG 来らい关闭 assert，但ただし是ぜ需要じゅよう在ざい源みなもと代だい码的开头，include <assert.h> 之これ前まえ。

assert() 使用しよう

#define NDEBUG          // 加か上じょう这行，则 assert 不ふ可用かよう
#include <assert.h>

assert( p != NULL );    // assert 不ふ可用かよう

• sizeof 对数组，得とく到いた整せい个数组所占うらない空そら间大小しょう。
• sizeof 对指针，得とく到いた指ゆび针本身ほんみ所しょ占うらない空そら间大小しょう。

设定结构体たい、联合以及类成员变量りょう以 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 限定げんてい的てき函数かんすう或ある变量是ぜ 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

// c
typedef struct Student {
    int age; 
} S;

等とう价于

// c
struct Student { 
    int age; 
};

typedef struct Student S;

此时 S 等とう价于 struct Student，但ただし两个标识符ふ名称めいしょう空そら间不相しょう同どう。

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

由よし于编译器定位ていい符号ふごう的てき规则（搜索そうさく规则）改あらため变，导致不同ふどう于C语言。

一いち、如果在ざい类标识符空そら间定义了 struct Student {...};，使用しよう Student me; 时，编译器き将はた搜索そうさく全局ぜんきょく标识符ふ表ひょう，Student 未み找到，则在类标识符内ない搜索そうさく。

即そく表おもて现为可か以使用しよう Student 也可以使用しよう struct Student，如下：

// cpp
struct Student { 
    int age; 
};

void f( Student me );       // 正せい确，"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;
}

总的来らい说，struct 更さら适合看み成なり是ぜ一个数据结构的实现体，class 更さら适合看み成なり是ぜ一个对象的实现体。

• 最さい本ほん质的一个区别就是默认的访问控制
  1. 默だま认的继承访问权限。struct 是ぜ public 的てき，class 是ぜ private 的てき。
  2. struct 作さく为数据すえ结构的てき实现体たい，它默认的数すう据すえ访问控ひかえ制せい是ぜ public 的てき，而 class 作さく为对象ぞう的てき实现体たい，它默认的成なり员变量りょう访问控ひかえ制せい是ぜ private 的てき。

联合（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;