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::n
    static int i;        // 声明 S::i
    inline 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() {}
};