Modern C++（一）基本概念

1、基本概念

1.1、注释

注释在翻译阶段3会被替换为单个空白字符从程序中移除

1.2、名字与标识符

标识符是一个由数字、下划线、大小写字符组成的任意长度序列。有效的标识符首个字符必须是以A-Z、a-z、下划线开头，。有效的标识符其他字符可以是0-9、A-Z、a-z、下划线。

标识符可以用来命名对象、引用、函数、枚举项、类型、类成员、命名空间、模板、模板特化、形参包(C++11 起)、goto 标号，以及其他实体。

1.3、类型

C++类型系统由以下类型组成：

• 基础类型
  • void
  • std::nullptr_t
  • 算数类型
    • bool
    • 字符类型：char、signed char、unsigned char、char16_t、char32_t、wchar_t
    • 有符号整数类型：signed char、short int、int、long int、long long int
    • 无符号整数类型：
    • 浮点数类型：float、double、long double
• 复合类型
  • 引用类型：
    • 左值引用类型
    • 右值引用类型
    • 指针类型
    • 指向成员的指针（成员指针）类型
    • 数组类型
    • 函数类型
    • 枚举类型（有/无作用域）
    • 类类型（非联合/联合体类型）

标量类型：标量类型变量一次仅存储一个值。算术类型、枚举类型、指针类型、成员指针类型、std::nullptr_t都是标量类型

1.3.1、隐式生存期类型

隐式生存期类型是C++20引入的概念，无需显式调用构造函数或使用new表达式，对象的生存期（lifetime）可以隐式开始。

普通生存期类型：

class Person {
public:Person(const std::string& name) : name_(name) {std::cout << "构造: " << name_.c_str() << std::endl;}~Person() {std::cout << "析构: " << name_.c_str() << std::endl;}std::string name_;
};int main()
{void *mem = malloc(sizeof(Person));// 未定义行为！必须先构造再使用// static_cast<Person*>(mem)->name_ = "Alice";Person* p = new (mem) Person("Alice");  // 调用构造函数p->~Person();  // 显式调用析构函数std::free(mem);  // 释放内存
}

隐式生存期类型：

struct Point {int x;int y;
};int main()
{void* memory = std::malloc(sizeof(Point));  // 分配内存// 可以直接使用，无需构造！Point* p = static_cast<Point*>(memory);p->x = 10;  // 合法：内存已被视为Point对象p->y = 20;free(memory); // 释放内存（自动析构，无需显式调用析构函数）
}

隐式生存期类型允许：直接操作未构造的内存，无需显式销毁对象，可直接覆盖内存。优点是预先分配大块内存（内存池），按需创建对象。避免频繁调用构造 / 析构函数，提升内存操作效率。

隐式生存期类型：

• 标量类型
• 结构体 / 类需满足：无用户定义的构造函数、析构函数。所有成员和基类都是隐式生存期类型。

1.3.2、静态类型

静态类型（Static Typing）是一种编程语言特性，它要求在编译时明确每个变量、表达式和函数的类型。

1.3.3、动态类型

动态类型（Dynamic Typing）是一个相对概念，主要指程序在运行时确定对象的实际类型，而非编译时。C++ 作为静态类型语言，其核心类型系统是静态的（编译时确定类型），有以下几个机制提供了有限的动态类型特性：

• 多态：基类指针指向派生类对象
• RTTI（运行时类型信息）

1.4、对象

1.4.1、对齐

每个对象类型都具有被称为对齐要求的性质，它是一个非负整数（类型是 std::size_t，总是 2 的幂），可以使用alignof和std::alignment_of查询类型的对齐要求，也可以使用alignas要求对齐数。

class Person {
public:Person(const std::string& name) : name_(name) {}
private:std::string name_;
};int main()
{cout << alignof(Person) << endl;cout << std::alignment_of<Person>::value << endl;
}

1.4.2、声明点

声明点（Point of Declaration）是一个编译期概念，它指定了标识符（如变量、函数、类等）在代码中正式生效的位置。

• 对于变量和函数参数：声明点位于标识符名称之后，初始化表达式（如果有）之前

#include <iostream>int main(int argc, char **argv) {int x = 1;const int y = 2;{int x = x;      // 内部x的作用域在初始化器之前就开始了，所以内部x不能被外部x的值初始化std::cout << "x = " << x << std::endl;int y[y] = {};    // 内部y的作用域在y[y]之后，所以内部的y是一个包含2个int的数组}return 0;
}

• 类和类模板，枚举的声明点位于该标识符之后：

struct S : public A{ // S 的作用域从冒号开始}enum E : int // E 的作用域从冒号开始，因此内部可以使用枚举类型E
{A = sizeof(E)
};

• 类型别名或别名模板声明的声明点紧随该别名代表的类型标识之后

using T = int; // 外部 T 的作用域从分号开始
{using T = T*; // 内部 T 的作用域从分号开始，// 但分号前还在外部 T 的作用域中，// 因此等同于 T = int*
}

• 对于函数：声明点位于函数名称之后，形参列表之前

void func(int x) {  // func的声明点在此处// 函数体中可使用func（如递归调用）
}

1.4.3、生存期

对象的生存期（Lifetime） 是指对象从创建（存储被分配且初始化完成）到销毁（存储被释放或重用）的时间段。理解对象生存期对于避免内存泄漏、悬空指针和资源管理至关重要。

生存期：当对象获取存储并初始化完成后生存期开始。对象的生存期在以下几个时刻结束：

• 非类类型：销毁该对象时
• 类类型：析构函数调用开始时
• 对象占据的存储被释放，或者被其他对象重用

#include <iostream>class A {
public:A() {a = 10;}~A(){}void print() {std::cout << "A: a = "<< a << std::endl;}int a;
};class B {
public:int c;B() {c = 1;}
};void func() {A a;a.~A();new (&a) B;a.print();
}int main(int argc, char **argv) {func();std::cout << "test" << std::endl;return 0;
}

在上述代码func函数里，我们手动调用了a的析构函数，对象a的生命周期结束了，该对象占用的存储还在，但它已经不再是一个有效的对象，后续的print调用实际上时一个未定义的行为。

栈上的内存回收是由操作系统自动完成的，当对象的生命周期结束时，操作系统并不会立即将该对象所占用的内存标记为可用，而是等到整个栈帧（通常对应一个函数调用）结束时才会回收栈上的内存。因此，在对象的生命周期结束后，其所在的内存仍然存在，只是该内存已经不再属于一个有效的对象。

所以析构函数调用后，我们还可以重用a的内存。

生存期分类：

• 自动生存期：局部变量（非static），从定义处开始，到离开作用域时结束。
• 静态生存期：全局变量、static局部变量、static成员，从程序启动开始，到程序结束结束。
• 动态生存期：通过new/new[]分配的对象，从new成功开始，到delete/delete[]结束。
• 线程局部生存期：thread_local变量，与线程绑定（线程启动时开始，线程结束时结束）。

访问生存期外的对象 或者 重用存储前未结束生存期会导致未定义行为（UB）。

int* p = new int(10);
delete p;
*p = 20; // UB：p指向的对象已销毁struct S { ~S() {} };
S* s = new S;
new (s) S; // UB：原S的生存期未显式结束（需先调用析构）

1.5、声明与定义

声明（Declaration） 和 定义（Definition） 是两个核心概念，它们的区别直接影响代码的编译和链接过程。

1.5.1、声明

声明的主要作用是向编译器介绍某个标识符（如变量、函数、类等）的存在，告知编译器该标识符的名称、类型和一些基本属性，但并不为其分配内存或实现具体的功能。

声明的用途是解决编译时的符号引用。

以下情况是声明

• 变量声明：用extern关键字且不带初始化器

extern const int a;

• 类定义中的非 inline(C++17 起) 静态数据成员的声明

struct S
{int n;               // 定义 S::nstatic int i;        // 声明 S::iinline static int x; // 定义 S::x
};                       // 定义 S
int S::i;                // 定义 S::i

• 函数声明：仅提供签名

void foo(int a);

• 类/类型声明：

class MyClass;
enum Color : int;

• typedef 声明，using 声明

typedef S S2;   // 声明但不定义 S2（S 可以是不完整类型）
using S2 = S;   // 声明但不定义 S2（S 可以是不完整类型）
using N::d;     // 声明，引入一个已存在的名称，所以N::d必须已经被声明

重要：声明可多次重复（同一作用域内允许多次声明），但是声明必须完全一致

extern int x;     // 声明1
extern double x;  // 错误：类型不一致

函数声明可能分散在多个头文件中，最终在源文件中定义

// utils.h
void helper();// math.h
void helper(); // 重复声明（合法）// utils.cpp
void helper() {} // 唯一定义

1.5.2、定义

定义是为标识符分配存储空间或提供完整实现。每个标识符必须有且仅有一个定义（One Definition Rule, ODR）。

定义的用途是解决链接时的具体实现。

• 变量定义：

int x = 42; // 定义并初始化x（分配内存）

• 函数定义

void foo(int a) { // 函数定义std::cout << a;
}

• 类定义：完整描述成员和方法。

class MyClass {
public:void method() {}
};