基于 Effective C++ 整理 C++ 编程最佳实践。主要涵盖四点：一、视 C++ 为语言联邦（C、面向对象、模板、STL），根据不同场景选择合适范式；二、优先使用 const、enum、inline 替代 #define，避免宏的类型检查和副作用问题；三、尽可能使用 const 修饰符，包括迭代器、返回值及成员函数，利用 bitwise 和 logical constness 提升安全性并复用代码；四、确保对象在使用前初始化，构造函数应使用初始化列表而非赋值，并注意 static 对象的初始化顺序陷阱，推荐使用 local static 对象。
C++ 不是'单一规则的语言'，而是由 4 个核心'子语言'组成的联邦，每个子语言有专属规则和适用场景，理解这一点能避免用'单一思维'写 C++：
vector 替代原生数组）。核心价值：写 C++ 时不用'一刀切'—— 比如底层逻辑用 C 风格保证效率，业务层用面向对象保证复用，数据处理用 STL 减少重复代码。
#define 是预处理器指令（编译前替换），存在无类型检查、调试困难、副作用等问题，替代方案更安全、易维护：
| 场景 | #define 方案（问题） | 替代方案（优势） |
|---|---|---|
| 定义常量 | #define RATIO 1.653（无类型、不进符号表） | const double RATIO = 1.653（类型安全、可调试）；class 内用 static const/enum（作用域隔离） |
| 类专属常量（旧编译器） | 无法限定作用域 | enum { NumTurns = 5 }（模拟常量，无内存开销，不可取地址） |
| 形似函数的宏 | #define MAX(a,b) f(a>b?a:b)（参数副作用） | template<class T> inline void max(T&a,T&b)（无副作用、类型检查、内联高效） |
#define ASPECT_RATIO 1.653 // 当使用这个宏时，它也许从未被编译器看见过，因为也许在编译器处理之前，它以及被预处理器移走了，不利于追踪调试 (ASPECT_RATIO 可能未进入记号表)
// 解决之道是以一个常量来替代
const double ASPECT_RATIO_THRESHOLD = 0.75;
// 当然也有特殊情况
// 一是定义常量指针的时候
const char* const authorName = "John Doe"; // 更推荐 std::string
// 二是 class 专属常量
class GamePlayer {
private:
static const int NumTurns = 5; // 常量声明式
int scores[NumTurns];
};
// 而然它并不是定义式。C++ 通常要求你对使用的任何东西提供一个定义式，但如果它是 class 专属常量又是 static 且为整数类型时，只要不取它们的地址，就可以声明后直接使用
// 否则要使用里面只声明，在外部再定义
// const int GamePlayer::NumTurns = 3;
// 值得一提的是我们无法使用#define，它并不重视作用域
// 如果你的编译器不支持 static 整数型 class 常量完成初值设定时
class GamePlayer2 {
enum{ NumTurns = 5 };
int scores[NumTurns];
};
// 但是注意，enum 无法取地址
示例验证：宏的副作用问题
// 宏的问题：++a 被执行 2 次，最终 a=7
int a=5, b=0;
#define CALL_MAX(a,b) f((a)>(b)?(a):(b))
CALL_MAX(++a, b);
// inline 模板函数：++a 仅执行 1 次，最终 a=6
template<class T> inline void callMax(T& a, T& b) {
f(a>b?a:b);
}
callMax(++a, b);
// 替换方法
template<class T> inline void callWithMax(T& a,T& b){ f(a>b?a:b); }
请记住:
const 的核心是'只读约束'，帮助编译器检测错误（比如意外修改值），提升代码安全性，主要有 4 个使用场景：
类比指针的 const 规则，区分两种 const：
const vector<int>::iterator iter：迭代器本身不可改（类似 T* const），但可以通过 iter 修改指向的元素；vector<int>::const_iterator iter：迭代器指向的元素不可改（类似 const T*），但迭代器本身可以移动。// STL 迭代器系是以指针为根据塑模出来的，所以迭代器的作用就像个 T*
std::vector<int> vec;
const std::vector<int>::iterator iter = vec.begin(); // T* const
std::vector<int>::const_iterator iter1 = vec.begin(); // const T*
避免客户的错误操作，比如：
// 令函数返回一个常量值，可以降低因客户错误而造成的意外，且不至于放弃安全性和高效性
class Rational{};
const Rational operator*(const Rational& lhs,const Rational& rhs);
// 保证了客户不会使用 (a*b)=c，if(a*b = c) 这种行为的出现
logical constness（逻辑层面）：允许修改 mutable 修饰的成员（客户端不可感知），比如缓存计算结果：
// const 成员函数
// 注意：成员函数的常量性也属于函数签名，可以被重载
// 现在对成员函数 const 由两个流行概念
// 1.bitwise constness 不应该改变对象内任何 non-const 成员
class CTextBlock{
public:
char& operator[](int index)const{ return pText[index]; }
private:
char* pText;
};
// 这个符合这个概念 (能通过 bitwise 测试), 但是却可以改变指针指向的对象
// 由这种情况引出了
// 2.logical constness
// 一个 const 成员函数可以改变它所处理对象的 bits，但只有在客户端侦测不出的情况下
class CText{
public:
std::size_t length()const;
private:
char* pText;
std::size_t textLength;
bool lengthValidity;
};
std::size_t CText::length()const{
if(!lengthValidity){
textLength = strlen(pText);
lengthValidity = true;
}
return textLength;
}
// 但是会报错，需要将两个成员 (textlength 和 lengthValidity) 前加上 mutable 关键词
避免重复代码，让 non-const 版本调用 const 版本（通过类型转换解除 const）：
// 在 const 和 non-const 成员函数中避免重复
// 假设 operator[] 里还要执行边界检验，注意访问信息等行为，就会有很多重复代码出现
// 这个时候可以令其中一个调用另一个，这促使我们将常量性转除
// 一般而言，转型是一个很糟糕的想法 (27)
class TextBlock{
public:
const char& operator[](int index)const{ /* ... */ return pText[index]; }
char& operator[](int index){
return const_cast<char&>(static_cast<const TextBlock&>(*this)[index]); // 这里如果不转型为常量，就会无限递归自己
}
private:
char* pText;
std::size_t textLength;
};
// 更值得了解的是，如将 const 转为 non-const，就把权力放大了
请记住:
C++ 对内置类型（int、指针等）不保证初始化，类类型虽会调用构造函数，但错误的初始化方式会导致效率 / 逻辑问题：
| 方式 | 示例（构造函数内赋值） | 示例（成员初始化列） | 区别 |
|---|---|---|---|
| 赋值 | ABEntry(...) { theName = name; } | ABEntry2(...) : theName(name) {} | 赋值：先调用默认构造→再赋值；初始化列：直接调用拷贝构造，效率更高 |
| 强制要求 | 无 | const / 引用成员必须用初始化列（无法赋值） | 比如 const int num; 或 string& ref; 只能在初始化列初始化 |
注意：初始化列的顺序与类内成员声明顺序一致，与书写顺序无关（建议保持一致，提升可读性）。
// 规则很简单：确保每一个构造函数都将对象得每一个成员初始化
class ABEntry{
private:
std::string theName;
std::string theAddress;
int numTimes;
public:
ABEntry(std::string name,std::string address,int numTimes){
theName = name;
theAddress = address;
numTimes = numTimes; // 这些都是赋值，不是初始化
}
};
// 在赋值之前，会调用成员的默认构造函数，但却因为赋值的存在而浪费了开销
// 解决方法：使用 member initialization list
class ABEntry2{
private:
std::string theName;
std::string theAddress;
int numTimes;
public:
ABEntry2(std::string name,std::string address,int numTimes) :theName(name),theAddress(address),numTimes(numTimes){ }
};
// 这样就只是调用 copy 构造函数了
// 由于 numTimes 是内置类型，若成员初值列遗漏了它，就会有不明确行为
// 但是 const 或 references，一定需要初值，不能被赋值
// 成员初始化顺序与初值列顺序无关 (最好一致来增加可读性)，与声明顺序有关
static 对象（寿命从构造到程序结束）的坑：跨编译单元的 non-local static 对象初始化顺序不确定，解决方案是用 local static（函数内 static）：
// static 对象
// 寿命从被构造出来直到程序结束
// 函数内的 static 对象称为 local static
// 当有多个源码文件时，non-local static 对象的初始顺序是不确定的 (不小心可能会导致使用未被初始化的对象)
// C++ 对'多个编译单元的 non-local static 对象的初始化相对顺序无明确定义'
// 一个小小的设计，用 local static 对象替换 (单例模式的思想之一) 基础在于 C++ 保证，函数内的 local static 对象会在首次遇上定义式时被初始化
class FileSystem{};
FileSystem& tfs(){
static FileSystem fs;
return fs;
}
// 但是内含 static 对象使它们在多线程系统中具有不确定性
注意：local static 在多线程环境下可能有初始化竞争，需额外加锁。
请记住:
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online