1
2
3
4
5
6
7

// 找到指定元素
std::sort(v.begin(), v.end());
auto it = std::find(v.begin(), v.end(), 4);

// std::ranges
std::ranges::sort(v);
auto it = std::ranges::find(v, 4);

1
2
3
4

auto cmp = [](const T left, const T right) {
    return left > right;  // 小根堆，与排序相反，比较返回true时默认left节点下沉
};
std::priority_queue<T, std::vector<T>, decltype(cmp)> heap;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

vector<int> vec = {3, 1, 5, 2};
// 构建大根堆
make_heap(vec.begin(), vec.end());
// 插入新元素
vec.push_back(6);
push_heap(vec.begin(), vec.end());
// 弹出堆顶
pop_heap(vec.begin(), vec.end());
vec.pop_back();
// ...

1

// TODO

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251

#include <cstring>
#include <iostream>
#include <algorithm>
#include <stdexcept>

class MyString {
public:
	using iterator = char*;
	using const_iterator = const char*;
	static const size_t npos = static_cast<size_t>(-1);

	MyString()
		: m_data(new char[1])
		, m_size(0)
		, m_capacity(0)
	{
		m_data[0] = '\0';
	}

	MyString(const char* str)
	{
		if (str == nullptr) 
		{
			m_size = 0;
			m_capacity = 0;
			m_data = new char[1];
			m_data[0] = '\0';
		}
		else
		{
			m_size = std::strlen(str);
			m_capacity = m_size;
			m_data = new char[m_capacity + 1];
			std::memcpy(m_data, str, m_size + 1);
		}
	}

	MyString(size_t count, char ch)
		: m_data(new char[count + 1])
		, m_size(count)
		, m_capacity(count)
	{
		std::memset(m_data, ch, count);
		m_data[m_size] = '\0';
	}

	~MyString()
	{
		delete[] m_data;
	}

	// 拷贝构造
	MyString(const MyString& other)
		: m_data(new char[other.m_size + 1])
		, m_size(other.m_size)
		, m_capacity(other.m_size)
	{
		std::memcpy(m_data, other.m_data, m_size + 1);
	}

	// 移动构造
	MyString(MyString&& other) noexcept
		: m_data(other.m_data)
		, m_size(other.m_size)
		, m_capacity(other.m_capacity)
	{
		other.m_data = new char[1];
		other.m_data[0] = '\0';
		other.m_size = 0;
		other.m_capacity = 0;
	}

	MyString& operator=(MyString other) noexcept
	{
		swap(other);
		return *this;
	}

	// 容量相关
	size_t size()     const noexcept { return m_size; }
	size_t length()   const noexcept { return m_size; }
	size_t capacity() const noexcept { return m_capacity; }
	bool   empty()    const noexcept { return m_size == 0; }

	// c_str()
	const char* c_str()  const noexcept { return m_data; }
	const char* data()   const noexcept { return m_data; }

	// 预分配容量
	void reserve(size_t newCap)
	{
		if (newCap <= m_capacity) return;

		char* newData = new char[newCap + 1];
		std::memcpy(newData, m_data, m_size + 1);
		delete[] m_data;
		m_data = newData;
		m_capacity = newCap;
	}

	void clear() noexcept
	{
		m_size = 0;
		m_data[0] = '\0';
	}

	// operator[]
	char& operator[](size_t pos) { return m_data[pos]; }
	const char& operator[](size_t pos) const { return m_data[pos]; }

	// at() 做越界检查，抛 std::out_of_range
	char& at(size_t pos)
	{
		if (pos >= m_size) throw std::out_of_range("MyString::at");
		return m_data[pos];
	}
	const char& at(size_t pos) const
	{
		if (pos >= m_size) throw std::out_of_range("MyString::at");
		return m_data[pos];
	}

	char& front() { return m_data[0]; }
	const char& front() const { return m_data[0]; }
	char& back() { return m_data[m_size - 1]; }
	const char& back()  const { return m_data[m_size - 1]; }
	
	// 修改
	MyString& operator+=(const MyString& rhs)
	{
		append(rhs.m_data, rhs.m_size);
		return *this;
	}

	MyString& operator+=(const char* str)
	{
		append(str, std::strlen(str));
		return *this;
	}

	MyString& operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}

	// 2 倍扩容
	void push_back(char ch)
	{
		if (m_size == m_capacity) {
			reserve(m_capacity == 0 ? 1 : m_capacity * 2);
		}
		m_data[m_size++] = ch;
		m_data[m_size] = '\0';
	}

	void pop_back()
	{
		if (m_size > 0) {
			m_data[--m_size] = '\0';
		}
	}

	size_t find(const char* target, size_t pos = 0) const
	{
		if (pos > m_size) return npos;
		const char* found = std::strstr(m_data + pos, target);
		return found ? static_cast<size_t>(found - m_data) : npos;
	}

	size_t find(char ch, size_t pos = 0) const
	{
		for (size_t i = pos; i < m_size; ++i) {
			if (m_data[i] == ch) return i;
		}
		return npos;
	}

	size_t find(const MyString& str, size_t pos = 0) const
	{
		return find(str.m_data, pos);
	}

	MyString substr(size_t pos = 0, size_t count = npos) const
	{
		if (pos > m_size) throw std::out_of_range("MyString::substr");
		size_t len = std::min(count, m_size - pos);
		MyString result;
		result.reserve(len);
		result.m_size = len;
		std::memcpy(result.m_data, m_data + pos, len);
		result.m_data[len] = '\0';
		return result;
	}

	void swap(MyString& other) noexcept
	{
		std::swap(m_data, other.m_data);
		std::swap(m_size, other.m_size);
		std::swap(m_capacity, other.m_capacity);
	}

	int compare(const MyString& other) const noexcept
	{
		return std::strcmp(m_data, other.m_data);
	}

	iterator       begin()        noexcept { return m_data; }
	iterator       end()          noexcept { return m_data + m_size; }
	const_iterator begin()  const noexcept { return m_data; }
	const_iterator end()    const noexcept { return m_data + m_size; }
	const_iterator cbegin() const noexcept { return m_data; }
	const_iterator cend()   const noexcept { return m_data + m_size; }

	// operator+
	friend MyString operator+(const MyString& lhs, const MyString& rhs)
	{
		MyString result;
		result.reserve(lhs.m_size + rhs.m_size);
		result.append(lhs.m_data, lhs.m_size);
		result.append(rhs.m_data, rhs.m_size);
		return result;
	}

	// 比较运算符：先比 size 做短路优化
	friend bool operator==(const MyString& a, const MyString& b) noexcept
	{
		return a.m_size == b.m_size && std::memcmp(a.m_data, b.m_data, a.m_size) == 0;
	}
	friend bool operator!=(const MyString& a, const MyString& b) noexcept { return !(a == b); }
	friend bool operator< (const MyString& a, const MyString& b) noexcept { return a.compare(b) < 0; }
	friend bool operator<=(const MyString& a, const MyString& b) noexcept { return a.compare(b) <= 0; }
	friend bool operator> (const MyString& a, const MyString& b) noexcept { return a.compare(b) > 0; }
	friend bool operator>=(const MyString& a, const MyString& b) noexcept { return a.compare(b) >= 0; }

private:
	// 追加 len 个字符到末尾
	void append(const char* str, size_t len)
	{
		if (m_size + len > m_capacity) {
			reserve(std::max(m_capacity * 2, m_size + len));
		}
		std::memcpy(m_data + m_size, str, len);
		m_size += len;
		m_data[m_size] = '\0';
	}

	char* m_data;
	size_t m_size;
	size_t m_capacity;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <compare>
// ...
friend bool operator==(const MyString& a, const MyString& b) noexcept
{
    return a.m_size == b.m_size && std::memcmp(a.m_data, b.m_data, a.m_size) == 0;
}

friend std::strong_ordering operator<=>(const MyString& a, const MyString& b) noexcept
{
    int result = std::strcmp(a.m_data, b.m_data);
    if (result < 0) return std::strong_ordering::less;
    if (result > 0) return std::strong_ordering::greater;
    return std::strong_ordering::equal;
}

1
2
3

std::strong_ordering	// ：强排序，equal时两个值完全相同，可以相互替换（枚举、字符串、Point值类型等）
std::weak_ordering		// ：弱排序，equal时两个值不一定完全相同，仅仅在判断时表示相同
std::partial_ordering   // ：部分排序，相比于weak_ordering，还多了一个 unordered 状态，表示两个值无法比较大小

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Object {
public:
	Object(size_t size) : m_size(size) {}
    // 在类体内部直接定义
    friend bool operator==(const Object& a, const Object& b) noexcept
    {
        return a.m_size == b.m_size;
    }
private:
    size_t m_size;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Object {
public:
	Object(size_t size) : m_size(size) {}
	friend bool operator==(const Object& a, const Object& b) noexcept;  // 声明
private:
    size_t m_size;
};

// 在类外部定义
friend bool operator==(const Object& a, const Object& b) noexcept
{
    return a.m_size == b.m_size;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Object {
public:
	Object(size_t size) : m_size(size) {}
	friend class OtherClass;
private:
    size_t m_size;
};

class OtherClass {
public:
    void print(const Object& obj) {
        std::cout << obj.m_size << std::endl;  // 可以访问对方的私有成员，且单向访问
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class B; // 前向声明

class A {
public:
    void inspect(const B& b);  // 需要访问 B 的私有成员
};

class B {
    friend void A::inspect(const B& b);  // 只授权 A 的这一个函数
private:
    int m_secret = 42;
};

void A::inspect(const B& b) {
    std::cout << b.m_secret;  // 可以访问对方的私有成员，且单向访问
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 快速排序
int _Partition(std::vector<int>& arr, int first, int last)
{
	if (first == last) return first;

	int posVal = arr[last];
	int i = first;
	for (int j = first; j < last; j++)
	{
		if (arr[j] < posVal)
			std::swap(arr[i++], arr[j]);
	}
	std::swap(arr[i], arr[last]);
	return i;
}

void QuickSort(std::vector<int>& arr, int first, int last)
{
	if (first >= last) return;
	int pos = _Partition(arr, first, last);
	QuickSort(arr, first, pos - 1);
	QuickSort(arr, pos + 1, last);
}

1

std::vector<int> arr{1, 2, 3, 4, 5, 6, 7};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

int _Partition2(std::vector<int>& arr, int first, int last)
{
	int pivot = arr[last];
	int left = first;
	int right = last - 1;
	while (true)
	{
		while (left <= right && arr[left] < pivot) {
			left++;
		}

		while (left <= right && arr[right] >= pivot) {
			right--;
		}

		if (left >= right) {
			break;
		}

		std::swap(arr[left], arr[right]);
		left++;
		right--;
	}

	std::swap(arr[left], arr[last]);
	return left;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

template <typename RandomIt, typename Compare = std::less<typename std::iterator_traits<RandomIt>::value_type>>
RandomIt partition(RandomIt first, RandomIt last, Compare comp = Compare{}) {
	if (first == last) return first;

	auto pivot_it = std::prev(last);
	auto& pivot_val = *pivot_it;
	auto store = first;

	for (auto it = first; it != pivot_it; ++it) {
		if (comp(*it, pivot_val)) {
			std::swap(*it, *store);
			++store;
		}
	}
	std::swap(*store, *pivot_it);
	return store;
}

template <typename RandomIt, typename Compare = std::less<typename std::iterator_traits<RandomIt>::value_type>>
void quick_sort(RandomIt first, RandomIt last, Compare comp = Compare{}) {
	if (std::distance(first, last) <= 1) return;

	auto pivot_pos = ::partition(first, last, comp);
	quick_sort(first, pivot_pos, comp);
	quick_sort(std::next(pivot_pos), last, comp);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

void _MergeRecursive(std::vector<int>& arr, std::vector<int>& temp, int first, int mid, int last)
{
	int tempIndex = first;
	int i = first, j = mid + 1;
	while (i <= mid && j <= last)
	{
		if (arr[i] <= arr[j])
			temp[tempIndex++] = arr[i++];
		else
			temp[tempIndex++] = arr[j++];
	}
	while (i <= mid) temp[tempIndex++] = arr[i++];
	while (j <= last) temp[tempIndex++] = arr[j++];

	for (int k = first; k <= last; k++)
		arr[k] = temp[k];
}

void MergeSortImpl(std::vector<int>& arr, std::vector<int>& temp, int first, int last)
{
	if (first >= last) return;
	int mid = first + (last - first) / 2;
	MergeSortImpl(arr, temp, first, mid);
	MergeSortImpl(arr, temp, mid + 1, last);
	_MergeRecursive(arr, temp, first, mid, last);
}

void MergeSort(std::vector<int>& arr, int first, int last)
{
	std::vector<int> temp(arr);  // 复用数组
	MergeSortImpl(arr, temp, first, last);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class UnionFind {
    std::vector<int> parent, rank;
    int components; // 连通分量数

public:
    explicit UnionFind(int n) : parent(n), rank(n, 0), components(n) {
        std::iota(parent.begin(), parent.end(), 0); // parent[i] = i
    }

    int find(int x) {
        while (parent[x] != x) {
            parent[x] = parent[parent[x]]; // 路径压缩（隔代压缩）
            x = parent[x];
        }
        return x;
    }

    bool unite(int x, int y) {
        int rx = find(x), ry = find(y);
        if (rx == ry) return false; // 已在同一集合
        // 按秩合并：矮树挂到高树下
        if (rank[rx] < rank[ry]) std::swap(rx, ry);
        parent[ry] = rx;
        if (rank[rx] == rank[ry]) ++rank[rx];
        --components;
        return true;
    }

    bool connected(int x, int y) { return find(x) == find(y); }
    int count() const { return components; }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

class Trie {
    struct Node {
        std::array<int, 26> children{}; // 子节点索引, 0 表示空
        int prefixCount = 0;            // 经过此节点的单词数
        int endCount = 0;               // 以此节点结尾的单词数
    };
    std::vector<Node> nodes;

    static int idx(char c) { return c - 'a'; }

public:
    Trie() : nodes(1) {} // nodes[0] 为根节点

    void insert(std::string_view word) {
        int cur = 0;
        for (char c : word) {
            int i = idx(c);
            if (!nodes[cur].children[i]) {
                nodes[cur].children[i] = static_cast<int>(nodes.size());
                nodes.emplace_back();
            }
            cur = nodes[cur].children[i];
            ++nodes[cur].prefixCount;
        }
        ++nodes[cur].endCount;
    }

    bool search(std::string_view word) const {
        int cur = 0;
        for (char c : word) {
            int i = idx(c);
            if (!nodes[cur].children[i]) return false;
            cur = nodes[cur].children[i];
        }
        return nodes[cur].endCount > 0;
    }

    bool startsWith(std::string_view prefix) const {
        int cur = 0;
        for (char c : prefix) {
            int i = idx(c);
            if (!nodes[cur].children[i]) return false;
            cur = nodes[cur].children[i];
        }
        return true;
    }

    // 统计以 prefix 为前缀的单词数量
    int countPrefix(std::string_view prefix) const {
        int cur = 0;
        for (char c : prefix) {
            int i = idx(c);
            if (!nodes[cur].children[i]) return 0;
            cur = nodes[cur].children[i];
        }
        return nodes[cur].prefixCount;
    }

    // 删除单词(不负责检查单词是否存在)
    void erase(std::string_view word) {
        int cur = 0;
        for (char c : word) {
            cur = nodes[cur].children[idx(c)];
            --nodes[cur].prefixCount;
        }
        --nodes[cur].endCount;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// LRU
class LRUCache {
	using ListNode = std::pair<int, int>;
public:
	LRUCache(int capacity) :cap(capacity) {}

	int get(int key) {
        int value = -1;
        if (map.find(key) != map.end()) 
        {
            value = map[key]->second;
            lists.splice(lists.begin(), lists, map[key]);
            map[key] = lists.begin();
        }
        return value;
	}

	void put(int key, int value) {
        if (map.find(key) != map.end())
        {
            map[key]->second = value;
            lists.splice(lists.begin(), lists, map[key]);
            map[key] = lists.begin();
        }
        else
        {
            lists.push_front({key, value});
            if (lists.size() > cap)
            {
                auto it = lists.back();
                map.erase(it.first);
                lists.pop_back();
            }
            map[key] = lists.begin();
        }
	}

private:
	int cap;
	std::list<ListNode> lists;
	std::unordered_map<int, std::list<ListNode>::iterator> map;
};

// TODO LRU-K

1
2
3
4

; 假设全局变量 g_count 被编译器分配在地址 0x00404000
; 非 PIC 代码：直接使用绝对地址
mov eax, [0x00404000]     ; 读取 g_count 的值
call 0x00401200           ; 调用函数 foo()，绝对地址

1
2
3

; PIC 代码：使用 RIP 相对寻址 (x86-64)
mov eax, [rip + 0x2A30]   ; g_count 在"当前指令地址 + 0x2A30"处
call [rip + 0x1B00]       ; foo() 在"当前指令地址 + 0x1B00"处

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

   代码段 (.text)                    数据段 (.got)
   只读，多进程共享                   可写，每进程私有拷贝

┌──────────────────┐            ┌────────────────────┐
│ mov rax,         │           │ GOT[0]: 0x0        │ ← 加载前为空
│     [rip + X]    │──(rip+X)─>│ GOT[1]: 0x0        │
│ mov eax, [rax]   │           │ GOT[2]: 0x0        │
└──────────────────┘            └────────────────────┘
  不含任何绝对地址                 动态链接器(ld-linux.so)
  可以被多个进程共享               在加载时填入真实地址
       同一份物理内存                      │
                                          ▼
                                ┌────────────────────┐
                                │ GOT[0]: 0x7F3A2010 │ ← 某外部变量的真实地址
                                │ GOT[1]: 0x7F3B4088 │
                                │ GOT[2]: 0x7F3C10A0 │
                                └────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

第一次调用 printf():

app 代码          PLT stub               GOT 条目            动态链接器
  │                │                       │                    │
  │  call PLT[n]   │                       │                    │
  │───────────────>│  jmp *GOT[n]          │                    │
  │                │──────────────────────>│ (初始值: 指向       │
  │                │                       │  resolver stub)    │
  │                │                       │──────────────────> │ _dl_runtime_resolve
  │                │                       │                    │ 1. 查找 printf 地址
  │                │                       │                    │ 2. 写入 GOT[n]
  │                │                       │  GOT[n] = 真实地址 │ 3. 跳转到 printf
  │                │                       │<──────────────────│
  
第二次调用 printf():

app 代码          PLT stub               GOT 条目            printf()
  │                │                       │                    │
  │  call PLT[n]   │                       │                    │
  │───────────────>│  jmp *GOT[n]          │                    │
  │                │──────────────────────>│ (已填入真实地址)    │
  │                │                       │──────────────────>│ 直接执行
                                            无需再次解析

1
2
3
4
5
6
7

PE Header:
  ImageBase: 0x10000000       ← 链接器假定该 DLL 将加载到此地址
  .reloc section:             ← 重定位表，记录所有绝对地址引用的位置
    偏移 0x1042: 需要修正
    偏移 0x1067: 需要修正
    偏移 0x10A3: 需要修正
    ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 编译器在构造函数中隐式插入的伪代码
Derived::Derived() {
    // 1. 先调用基类构造函数
    Base::Base();  // 此时 vptr 指向 Base::vtable

    // 2. 编译器插入：将 vptr 更新为 Derived 的 vtable
    this->vptr = &Derived::vtable;

    // 3. 执行 Derived 构造函数体
    ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Base1 {
public:
    virtual void func1() { std::cout << "Base1::func1()" << std::endl; }
    virtual void func2() { std::cout << "Base1::func2()" << std::endl; }
    int base1_data = 0x11;
};

class Base2 {
public:
    virtual void func3() { std::cout << "Base2::func3()" << std::endl; }
    virtual void func4() { std::cout << "Base2::func4()" << std::endl; }
    int base2_data = 0x22;
};

class Derived : public Base1, public Base2 {
public:
    // 重写 Base1 的 func1
    void func1() override { std::cout << "Derived::func1()" << std::endl; }
    // 重写 Base2 的 func3
    void func3() override { std::cout << "Derived::func3()" << std::endl; }
    // Derived 自己的虚函数
    virtual void func5() { std::cout << "Derived::func5()" << std::endl; }
    int derived_data = 0x33;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Derived* pDerived = &d;
// vptr1: 位于对象起始位置（Base1 子对象的 vptr）
uintptr_t* vptr1_addr = reinterpret_cast<uintptr_t*>(pDerived);
uintptr_t* vtable1 = reinterpret_cast<uintptr_t*>(*vptr1_addr);

// vptr2: 位于 Base2 子对象起始位置
uintptr_t* vptr2_addr = reinterpret_cast<uintptr_t*>(pBase2);
uintptr_t* vtable2 = reinterpret_cast<uintptr_t*>(*vptr2_addr);

std::cout << "--- vtable 指针 ---" << std::endl;
printf("vptr1 (Base1/Derived 主表) 地址: %p, 值: %p\n", (void*)vptr1_addr, (void*)vtable1);
printf("vptr2 (Base2 子表)         地址: %p, 值: %p\n", (void*)vptr2_addr, (void*)vtable2);
std::cout << std::endl;

// ----------------------------------------------------------
// 3. 通过 vtable 手动调用虚函数
// ----------------------------------------------------------
std::cout << "--- 通过 vtable1 (主表) 调用函数 ---" << std::endl;

// vtable1 布局 (GCC/Clang, MSVC 类似但细节不同):
//   [0] -> Derived::func1()  (重写了 Base1::func1)
//   [1] -> Base1::func2()    (未重写，继承)
//   [2] -> Derived::func5()  (Derived 自己的虚函数，追加到主表末尾)

std::cout << "vtable1[0]: ";
printf("地址=%p  ", (void*)vtable1[0]);
// 用成员函数指针的方式调用（需要 this 指针）
using MemFunc = void(*)(Derived*);
MemFunc fn;

fn = reinterpret_cast<MemFunc>(vtable1[0]);
fn(pDerived);  // 应该输出 Derived::func1()

std::cout << "vtable1[1]: ";
printf("地址=%p  ", (void*)vtable1[1]);
fn = reinterpret_cast<MemFunc>(vtable1[1]);
fn(pDerived);  // 应该输出 Base1::func2()

// 输出：
// --- vtable 指针 ---
// vptr1 (Base1/Derived 主表) 地址: 00000034CE74F6D8, 值: 00007FF63665BE50
// vptr2 (Base2 子表)         地址: 00000034CE74F6E8, 值: 00007FF63665BE78

// --- 通过 vtable1 (主表) 调用函数 ---
// vtable1[0]: 地址=00007FF6366511D1  Derived::func1()
// vtable1[1]: 地址=00007FF636651168  Base1::func2()
// vtable1[2]: 地址=00007FF636651046  Derived::func5()