目录
一、const
二、static
三、#define 和 typedef
四、#define 和 inline
五、#define 和 const
六、new 和 malloc
七、const 和 constexpr
八、volatile
九、extern
十、前置 ++ 和后置 ++
十一、atomic
十二、struct 和 class
一、const
1、const 关键字可用于定义常量，一旦被赋值，其值在程序运行期间就不能被修改。
const int num = 10; // 定义一个常量 num，值为 10
2、const 用来修饰指针时，有两种用法：
（1）const 数据类型 *指针变量 = 变量名 or 数据类型 const *指针变量 = 变量名
当const在*前时，指的是不能通过这个指针变量来修改其指向的值，而指针本身可被修改
int temp = 10， b = 1; const int* a = &temp; int const *a = &temp; // 更改： *a = 9; // 错误：只读对象 temp = 9; // 正确 a = &b; //正确（2）数据类型 * const 指针变量 = 变量名
当const在*后时，指的是指针本身不可被修改，但可以通过指针修改其指向的值
int temp = 10; int temp1 = 12; int* const p = &temp; // 更改： p = &temp2; // 错误 *p = 9; // 正确
3、const 可用来修饰引用，表示不能通过该引用修改变量
int temp = 10;
const int& t = temp;
temp = 9; // 正确
t = 9; //错误其中，const权限只可降级，即非const引用或非const值可以初始化const引用，而反过来不行
int temp1 = 10;
const int temp2 = 5;
int& a = temp1;
const int& b = a; //正确
int& c = b; //错误，const权限不可升级
int& d = temp2; //错误，const权限不可升级4、const修饰成员函数和实例对象
- 当一个成员函数被 const 修饰时，它表明这个函数不会修改类的成员变量，但可以修改类的静态成员变量，因为静态成员变量不属于对象本身，而是属于整个类的，是所有对象共享一个的。
- 当一个对象被 const 修饰后，意味着这个对象在生命周期内的成员属性不可改变，故该对象只能调用 const 成员函数。
#include <iostream>
class MyClass {
private:
int nonStaticValue;
public:
static int staticValue;
MyClass(int v) : nonStaticValue(v) {}
int getNonStaticValue() const { // const 成员函数
return nonStaticValue;
}
void modifyStaticValue(int v) const { // const 成员函数修改静态成员变量
staticValue = v;
}
};
int MyClass::staticValue = 0; // 静态成员变量初始化
int main() {
const MyClass obj(10); // 创建 const 对象
std::cout << obj.getNonStaticValue() << std::endl; // 可以调用 const 成员函数获取非静态成员变量的值
obj.modifyStaticValue(20); // const 成员函数可以修改静态成员变量
std::cout << MyClass::staticValue << std::endl; // 输出修改后的静态成员变量的值
return 0;
}二、static
1、在函数内部，static 修饰的变量其生存期贯穿整个程序运行期间，但作用域仍在函数内部。
void func() {
static int count = 0; // 每次调用 func 函数，count 的值都会保留
count++;
}
2、在类中，static 成员变量属于整个类，而非某个对象。
class MyClass {
public:
static int staticVar;
};
int MyClass::staticVar = 0;
3、如果static修饰了全局变量，生命周期不变，还是全局，但是作用域降为了本文件有效；修饰全局函数是同样的道理
#include <iostream>
// 定义全局变量
static int globalStaticVar = 10; // 使用 static 修饰的全局变量
void function() {
std::cout << "globalStaticVar in function: " << globalStaticVar << std::endl;
}
int main() {
std::cout << "globalStaticVar in main: " << globalStaticVar << std::endl;
function();
// 错误：在其他文件中无法访问这个 static 修饰的全局变量
// extern int globalStaticVar;
return 0;
}4、static修饰成员函数，不与特定的对象相关联，可以通过类名和作用域解析运算符直接调用，虽然仍然可以使用实例化对象调用静态成员函数，但在实际编程中不推荐这样的写法，因为静态成员函数不依赖于具体的对象实例，它是属于整个类的。通常更推荐使用类名直接来调用静态成员函数，如下所示：
MyClass::staticMethod();三、#define 和 typedef
在 C 和 C++ 中，#define 和 typedef 都可以用于给类型取别名，但它们之间存在一些重要的区别。
1、语法和实现机制
#define是预处理器指令，通过简单的文本替换来实现别名定义。#define INT_PTR int*
typedef则是在编译阶段起作用的关键字。typedef int* IntPtr;2、作用域
#define不受作用域限制，在预处理器阶段进行替换，全局有效typedef遵循作用域规则，在其定义的作用域内有效。3、类型检查
#define只是简单的文本替换，没有类型检查。typedef是类型定义，具有类型检查。4、复杂类型处理
- 对于复杂的类型，如指针、数组等，
typedef更清晰和直观。例如，对于指向函数的指针，使用typedef更易理解。typedef int (*FuncPtr)(int);
#define在处理复杂类型时可能会导致混淆和错误。5、可移植性
typedef的行为在不同的编译器中通常更一致，具有更好的可移植性。
总的来说，虽然 #define 和 typedef 都能给类型取别名，但在大多数情况下，特别是对于复杂类型和需要类型检查及良好可移植性的场景，typedef 是更推荐的选择。
四、#define 和 inline
在 C/C++ 中，inline 函数和宏函数都有在代码中进行内联展开以提高性能的作用，但它们之间存在一些显著的区别。
1、语法和定义方式
inline函数是使用inline关键字修饰的正常函数。inline int add(int a, int b) { return a + b; }
- 宏函数则是通过
#define宏定义来实现的，只是在预处理阶段简单的文本替换#define ADD(a, b) ((a) + (b))2、类型检查
inline函数具有严格的类型检查，参数类型必须匹配。- 宏函数只是简单的文本替换，不进行类型检查，可能会导致潜在的类型错误。
3、参数处理
inline函数对参数的处理是按照函数的参数传递规则进行的。- 宏函数如果定义不当可能会出现不符合预期的情况，例如：
#define SQUARE(x) (x * x) int a = 2 + 3; int b = SQUARE(a); // 会被替换为 (2 + 3) * 2 + 3)，结果不符合预期 //正确定义： #define SQUARE(x) ((x) * (x))4、调试
inline函数可以像普通函数一样进行调试，可以设置断点、查看调用栈等。- 宏函数在调试时可能会带来困难，因为它们在预处理阶段就被替换了。
5、代码可读性
inline函数的定义方式更符合函数的常规语法，代码可读性更好。- 宏函数的定义可能会使代码看起来比较复杂，可读性较差。
在大多数情况下，inline 函数由于具有更好的类型安全性、可读性和调试性，是更优的选择。然而，在一些简单且性能关键的场景中，宏函数可能仍然有用。最后一点就是，inline只是对编译器的建议，具体做不做内联，要看编译器的选择。
五、#define 和 const
const和#dfine都可以用来定义常量，#define只是对字面量的文本替换，没有类型检查，预处理器在替换时也不会考虑作用域；const定义的常量是在编译时要进行类型检查的
#define PI 3.14159
const double Pi = 3.14159;六、new 和 malloc
1、new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。
2、使⽤new操作符申请内存分配时⽆须指定内存块的⼤⼩，⽽malloc则需要显式地指出所需内存的尺⼨。
3、opeartor new /operator delete可以被重载，⽽malloc/free并不允许重载。
4、new/delete会调⽤对象的构造函数/析构函数以完成对象的构造/析构。⽽malloc/free则不会
5、malloc与free是C++/C语⾔的标准库函数,new/delete是C++的运算符
6、new会返回申请类型的指针，malloc是返回void*指针，需要强制转换
七、const 和 constexpr
const 和 constexpr 都用于定义常量，const 的值可以在运行时确定，而 constexpr 的值必须在编译时确定。constexpr 对值的确定时间有更严格的要求，并且在一些特定的场景中能提供更好的性能和代码可读性。
八、volatile
volatile 用于告诉编译器，该变量的值可能会被意外地改变，不要进行 volatile修饰的变量，旨在告诉编译器，关闭对这个变量的编译优化，当需要对改变了进行读写和运算时，必须从内存重新装载内容，而不允许读取寄存器中的缓存。
九、extern
extern 用于声明一个在其他文件中定义的全局变量或函数。
十、前置 ++ 和后置 ++
前置++返回已经修改过的对象本身，而后置++返回被修改之前的临时对象，所以后置++的表达式不能作为左值，但前置++可以
int num = 6;
int preIncrement = ++num; // 返回7
int postIncrement = num++; // 返回 6十一、atomic
atomic 用于实现原子操作，确保在多线程环境中的操作是原子性的，不会被其他线程打断。
-
定义
atomic通常用于多线程编程中，用于确保对特定类型的操作是原子性的。
-
用途
- 保证操作的原子性：在多线程环境下，原子操作可以避免数据竞争和不一致性。例如，对一个整数的递增或读取操作，如果使用
atomic类型包装，就能保证在多线程并发访问时不会出现中间状态的错误。
- 保证操作的原子性：在多线程环境下，原子操作可以避免数据竞争和不一致性。例如，对一个整数的递增或读取操作，如果使用
-
示例
#include <atomic> // 定义一个原子整数 std::atomic<int> atomicVar(0); //C++17支持"="初始化 void threadFunction() { atomicVar++; // 原子性的递增操作 } int main() { // 创建多个线程执行 threadFunction return 0; } -
注意事项
- 并非所有的操作都能被原子化，具体取决于所使用的原子类型和编译器的支持。
- 使用
atomic虽然能保证原子性，但可能会带来一定的性能开销。
总之，atomic 是多线程编程中的重要工具，能有效地提高程序在多线程环境下的正确性和稳定性，但需要在性能和正确性之间进行权衡。
十二、struct 和 class
在 C 语言中，struct 主要用于简单地将不同类型的数据组合在一起，形成一个新的数据类型。其成员均为公开的，并且 struct 本身无法包含成员函数，仅仅是纯粹的数据组合。
在 C++ 中，struct 得到了显著的提升，实际上被视为类的一种形式。尽管 struct 的成员默认访问权限为 public，但它也能够像 class 一样显式地指定成员的访问权限为私有或受保护。并且，struct 还可以在其内部声明成员函数，从而实现更为复杂的行为和操作。
以下是 C++ 中 struct 包含成员函数的示例：
struct Student {
std::string name;
int age;
void displayInfo() { // 成员函数
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
};
基于上述特性，在实际编程中，建议采取以下最佳实践：
对于仅仅是数据的简单组合，且希望成员默认具有公共访问权限的情况，使用 struct 是一个不错的选择。例如，当定义一些纯粹用于数据传递或存储的结构体时，struct 能够清晰地表达数据的结构，并且方便数据的访问和操作。
当面对更为复杂的对象，涉及到数据的封装、隐藏以及更丰富的行为和操作时，使用 class 进行定义会更为合适。通过将成员设置为私有，并提供公共的接口函数来控制对象的状态和行为，可以更好地实现面向对象编程中的封装和信息隐藏原则，增强代码的健壮性、可维护性和可扩展性。
