关于.h里的static void freeMemory(void* ptr, size_t size){只看注释就行。

关于.h里的template<typename T, typename... Args> T* newElement(Args&&... args)里涉及到的new(p) T(std::forward<Args>(args)...);：

这里涉及到的前设基础知识太多太多了~~~~(>_<)~~~~

先说move：

左值string s = "hello";被string s2 = move(s);强转为右值，cout s为空

std::move 唯一作用：把左值强制转换成无名右值引用，仅此一步，不移动资源。如果本身就是右值，没必要用move。

转换后编译器匹配重载优先级：先匹配 T&& 移动函数，不存在则降级匹配 const T& 拷贝函数。 

手写移动专属函数

• 类名(类名&& 源) 移动构造函数

• 类名& operator=(类名&& 源) 移动赋值运算符

二者是自定义移动语义，接管资源，避免深拷贝，必须手动写才会生效

无std::move：左值传入 → 调用拷贝构造 / 拷贝赋值

右值直接匹配移动构造/移动赋值，无需std::move。

std::string是标准库提前写好了移动构造，你直接用才会掏空原对象；自定义类不手写移动函数，move 不会产生资源转移效果。

语法规则： 

• 非const左值引用Test&仅能绑定非const左值，不能绑定右值、const左值。

• const 左值引用 const Test& 万能绑定：普通对象、const 对象、临时对象、亡值全能接住。

• 右值引用（Test&&）只接收临时（非const纯右值） / 被 std::move 转换后的亡值（经过move转来的）

• const Test&&不用，因为要移动你写个屁的const

实参传给形参，形参带引用，比如T&/const T&/T&&，这个传递过程就叫绑定，而没引用的实参传递给形参，不叫绑定，只发生拷贝，不存在绑定。

T&&是右值引用，是实现移动语义的基础，仅负责绑定右值，但不等同于移动语义，移动语义依靠T&&形参的移动构造 / 移动赋值，转移资源而非拷贝。

临时对象不能用非 const 左值引用接收，比如Test x = Test{"123"};中Test{"123"};是无名的临时对象，如果Test写成

Test& Test(Test& t){ 
    t.buf = "改了内容"; 
}

就错了因为不可以传递给无const拷贝构造，只能

Test(const Test& t){
    std::string temp = t.buf; 
}

别问东问西，临时对象马上销毁，尽管传递给构造的时候没销毁，但就是死命禁止任何修改。

Q：绑定是啥意思？我咋感觉像赋值呢？

A：

Test b = a：b 是刚造出来的新东西，这一步叫造新对象（初始化），不是赋值。赋值是东西本来就有，后来改内容。

绑定（不可换绑）：调用拷贝构造函数时，拿 a 去填函数括号里的参数 Test& t，把 a 和这个参数拴在一起，这个拴住的动作就叫绑定，跟复制内容两码事。

复制内容：拴好之后，函数内部再把 a 里面的数据抄给 b，这一步看着像赋值，但只是复制数据。

看个代码：

查看代码

#include <utility>
#include <string>
struct Test {
    std::string buf;

    Test(std::string s) : buf(std::move(s)) {}

    // 手写移动构造
    Test(Test&& t) noexcept : buf(std::move(t.buf)) {}
    
    // 手写移动赋值
    Test& operator=(Test&& t) noexcept {
        buf = std::move(t.buf);
        return *this;
    }
    
    // 拷贝构造
    Test(const Test& t) : buf(t.buf) {}
};

int main() {
    Test a{"123"};
    Test b = a; // 左值，调用拷贝构造
    Test c = std::move(a); // move转右值，调用手写移动构造
}

Test(std::string s) : buf(std::move(s)) {} 接收字符串参数来构造对象，

字面量匹配值参数为std::string时，先隐式转换生成临时右值std::string，再拷贝一份值传递给s，这就是局部的左值s，std::move(s)将s转为右值，

即std::move(s)强制转换成std::string&&（纯右值）类型，

然后由于写了重载的移动构造，又写了move，即buf(move(s))，buf调用std::string移动构造接管字符内存（无深拷贝），刚刚的局部形参s生命周期结束自动析构，此时s为空字符串，无资源释放冲突。

练手：

查看代码

#include <iostream>
#include <string>
#include <utility>
using namespace std;

struct MyStr {
    string data;
    // 新增普通构造
    MyStr(const string& s) : data(s) {}
    
    // 拷贝构造:初始化列表直接拿other.data构造成员
    MyStr(const MyStr& other) : data(other.data) {}
    
};

int main() {
    MyStr a{"test"};
    MyStr b = move(a);
    cout << a.data << endl; // 仍输出test，走拷贝无移动
}

1、MyStr a{"test"};：

"test" 是 const char[5]，隐式转换为 const char*，结构体没有入参为 const char* 的构造函数，仅存在 MyStr(const string& s)，编译器利用 const char* 隐式生成临时 string("test")，临时 string 绑定到 const string& s，初始化列表 data(s) 调用 string 的拷贝构造，复制字符串内容

2、MyStr b = move(a);：

std::move(a) 将左值 a 转换成类型为 MyStr&& 的亡值，结构体只定义了拷贝构造 MyStr(const MyStr& other)，不存在移动构造 MyStr(MyStr&& other)，const MyStr& 可以绑定亡值，重载匹配拷贝构造函数，初始化列表 data(other.data) 复制 other.data 的字符串数据，不转移内存资源

3、cout << a.data << endl;：

a 内部 string 的堆内存没有被转移，对象原有数据保留，打印结果为 test。

进阶完善追问：

查看代码

// 无数次实践发现，学错的思考错的为什么错(指针部分)
// 学仿佛超纲钻牛角尖一句一句问的下面这个，真的把所有需要掌握的东西灵活的起来了，真会了
#include <utility>
#include <string>
#include<iostream>
using namespace std;

struct Test {
    std::string buf;
    
    Test(std::string s) : buf(std::move(s)) {cout<<"string"<<endl;} // 接收 string 参数的转换构造，移动传入字符串

    Test(Test& t) : buf(t.buf) {cout<<"无const左值拷贝构造"<<endl;} // 无 const 的左值拷贝构造，仅能拷贝非 const 对象
    //buf(t.buf)会新建独立字符内存，属于深拷贝
    //所有值传递:内置类型：int、char、double、bool等基础原生类型，无堆内存，所以无深浅拷贝区分，仅复制变量本身数值，不存在额外堆空间，谈不上深拷贝
    //但自定义类对象值传递会触发深拷贝      
    //深拷贝各自独立堆内存，不会双重释放；浅拷贝共用同一块堆内存才会双重释放
    //编译器默认生成的拷贝构造 / 赋值运算符，直接逐成员复制指针，共用堆内存，属于浅拷贝，所以只要涉及到堆，用了默认的浅拷贝共享堆内存，析构时重复释放直接崩溃
 
    Test(Test&& t) noexcept : buf(std::move(t.buf)) {cout<<"移动构造"<<endl;} // 移动构造，接管源对象字符串资源

    Test(const Test& t) : buf(t.buf) {cout<<"新增"<<endl;}//拷贝构造
};

int main() {
    cout<<endl;
    
    // 场景1 正常
    Test a{"123"}; // 先拿字面量构造std::string临时，再传入构造函数调用 Test(std::string s) : buf(std::move(s)) {} 。等价含义写法：Test a = std::string("123");，但属于拷贝初始化，Test a{"123"};属于直接初始化
    Test b = a; // a 是非 const 左值，优先匹配 Test(Test& t) 拷贝构造，若删掉该重载，才会选用 Test(const Test&)，引用绑定规则允许非const绑定到const，但 const 不可以绑定到非const
    cout<<endl;



    // 场景2
    // Test t4="ss";
    // "123"、"ss" 字面量类型：const char[N]，属于字符数组,
    // const char[3]（字面量数组）→ const char*：数组自动退化，无代价、内置转换，随时能转，不占用自定义转换的名额次数(数组名作为右值使用时，自动退化为首元素指针)
    // const char* → const char[3]：不能隐式转换，指针只是存地址，没有数组长度信息，编译器做不到自动转回数组。
    // 编译器尝试转换链：
    // 第一层：const char[3] 内置退化 const char* → 临时std::string，即内部偷偷 string __temp("ss") ， 使得 "ss" 变为 std::string("ss")
    // 第二层：临时std::string → Test（你写的构造函数，用户自定义隐式转换），使得 std::string("ss") 变为 Test (std::string ("ss"))
    // 最后用Test (std::string ("ss")) 去初始化 t4 : Test t4 (std::string ("ss")) ，但 C++ 硬性规则：一次初始化表达式，最多允许 1 次自定义隐式转换
    // 想过编译必须加 const char* 构造函数 Test(const char* s) : buf(s) {}，这样"ss"构造成 Test ，属于1次隐式，合法、


    // 场景3，
    const Test t1{"abc"};// 调用 Test(std::string s) 构造函数，临时 std::string 右值匹配该构造，生成 const Test 对象，类型为const Test
    Test t2 = t1; 
    // 编译器会在 Test 类中匹配参数能接收 t1(const Test左值) 的构造函数
    // Test(std::string s)参数是std::string
    // 拷贝构造 Test(Test& t),形参类型Test&（非 const 左值引用，Test&&才叫右值引用）,C++ 语法规则：const 左值不能绑定到非 const 左值引用
    // 移动构造 Test(Test&& t)，形参是右值引用Test&&，仅能绑定纯右值 / 亡值。t1 是左值，匹配失败
    // 想编译过必须加个新增的 Test(const Test& t) 拷贝构造
    cout<<endl;  



    // 场景4，
    Test t3 = Test{"xyz"};
    // 未命名临时对象，属于纯右值
    // 构造 1，Test(std::string s) 类型不匹配，因为等号右边是Test临时类型
    // 拷贝构造Test(Test& t)：形参非 const 左值引用，不能绑定右值，匹配失败
    // 移动构造Test(Test&& t)：右值引用可绑定纯右值，匹配成功，
    // 但 C++11/14 要么生成临时再移动，要么直接原地构造。
    // C++17直接原地构造，直接走 t3 里搞 string，没临时
    // 复制省略（拷贝消除）：编译器跳过拷贝/移动构造，直接把临时对象建在目标变量内存，省去复制资源开销。

    cout<<endl;
}

关于string：

std::string内部写了好多重载，

一、赋值运算符（已有对象覆盖内容时调用）

1、C 字符串字面量赋值

string& operator=(const char*);

str = "abc" 这是人类简写语法，对应string& operator=(const char* cstr)，编译器会自动翻译成成员函数调用：str.operator=("abc")

• 左边str. = 调用对象

• operator= = 函数名

• 括号("abc")里的"abc" = 传入函数的实参

string& operator=(const string&);
//string& 是整体返回值类型，&都写在右侧

示例：b = a;

• string&：返回当前对象引用，支持连续赋值x=y=z

• operator=：赋值函数名

• const string&：参数，接收另一个字符串左值

• b=a等价b.operator=(a)，a 匹配形参 const string&，调用该拷贝赋值重载，函数内部把 a 的数据复制给 b，返回 *this（b 自身引用），实现 x=y=z 连续赋值

1、拷贝构造

2、移动构造

string(string&&) noexcept;

示例：string b(move(a));

懂了move继续说为啥要引入forward，先看个代码：

查看代码

#include <utility>
#include <iostream>
using namespace std;
struct Data {
    int a;
    Data() { std::cout << "默认构造\n"; }
    Data(const Data&) { std::cout << "拷贝构造\n"; }
    Data(Data&&) { std::cout << "移动构造\n"; }
};

template<typename T>
void badTransfer(T val) {
    cout<<"@"<<endl;
    Data d(std::move(val));// 调用移动构造, val是函数内局部左值, std::move库函数内部固定是转为Data&& 匹配移动构造函数参数Data&&
cout<<"——结束——"<<endl;
}

int main() {
    Data a;
    cout<<"#"<<a.a<<endl;
        
    badTransfer(a);  
    // 调用上面的模板，函数实例化后等价于普通函数：
    // void badTransfer(Data val) {
    //     Data d(std::move(val));
    // }
    // 执行逻辑：把变量 a 拷贝一份给形参 val(触发 Data 拷贝构造)，函数内部再 move val

    cout<<"——开始下面——"<<endl;
    badTransfer(Data{});
    // Data{}是临时右值，类型还是Data，推导T = Data
    // 实例化后和上面完全一样的函数，先拷贝临时对象到 val，再 move val
}

这里Data{} 是列表初始化（值初始化），构造一个无名临时 Data 对象（纯右值）。

无任何用户自定义构造，编译器自动生默认构造

• Data a;命名左值对象，生命周期到作用域结束；无初始化，内置成员脏值

• Data a{} 值初始化，内置成员置 0

• 不用Data a()因为会被编译器解析成函数声明：名叫 a、无参数、返回 Data 的函数，不是定义局部对象。

• Data{} ：创建临时对象，内置成员置为 0

• Data()：同上，但 C++11 后推荐 {} 形式，

存在自定义无参构造时，全部只执行你的构造，成员是否清零完全看你构造内赋值（前提你有成员）

这个看似没问题，但失去的原生左右值属性， 如果改成

template<typename T>
void badTransfer2(T&& val) {
    Data d(std::move(val));
}

a 是外部左值，std::move(val) 直接把外部 a 转为右值，触发移动构造，外部 a 资源被掏空，后续使用 a 会产生未定义行为。这就是单纯 move 最大的坑：不分场景强制右值，会误移动外部左值对象。

所以要引入完整正确转发模板：

template<typename T>
void goodTransfer(T&& val) {
    //T&& val 是万能引用，不是单纯右值引用
    //非模板固定类型（如 Data&&、int&&）：单纯右值引用，只能接收右值，不能接左值。
    Data d(std::forward<T>(val));
}
//注意运算符都写在右侧

std::forward<T>(val) 依赖万能引用推导规则：

1. 传入左值 Data a，推导 T=Data&，forward 输出左值引用，调用拷贝构造；

2. 传入右值 Data{}，推导 T=Data，forward 输出右值引用，调用移动构造；

模板形参是 T&& val（万能引用）

• 实参是左值：编译器强制给 T 推成 类型&

• 实参是纯右值 / 亡值：编译器直接推 T 为原生裸类型（不带任何 &）

逻辑：传右值临时 Data{}，它本身没有左值属性，不需要给 T 附加左值引用标记，所以 T=Data

由于模板是 T&& val：

1. 传左值，把推导的 T = Data&代入得到Data& && val，符号全部贴在类型 Data 右侧，再引用折叠 → Data& val

2. 传右值，把推导的 T = Data代入得到：Data&& val

只要里面出现左值引用符号 &，结果一定是左值引用 &；

对比两套模板，一眼看出 move 的局限性

方案 1：只 move（值参 badTransfer）

• 左值 a：拷贝副本→move 副本，外部 a 安全，但右值传参多一次拷贝；

• 临时 Data {}：先拷贝临时生成 val，再 move，冗余拷贝。

方案 2：万能引用 + move（badTransfer2）

template<typename T>
void badTransfer2(T&& data) {
    Data tmp = std::move(data); // 致命问题在这里
}

• 临时 Data {}：直接移动，无冗余；

• 左值 a：传左值a，T推导成Data&，展开后T&& = Data& &&，折叠为Data&，所以是左值引用，直接 move 外部对象，掏空外部变量，严重逻辑 bug。

方案 3：万能引用 + forward（标准完美转发）

• 左值 a：仅拷贝，不改动外部；

• 临时右值：直接移动，无多余拷贝；

  同时兼顾安全与性能。

懂了语法开始说涉及到forward的代码：

if ((p = reinterpret_cast<T*>(HashBucket::useMemory(sizeof(T)))) != nullptr)

• sizeof(T)：计算你要创建的对象 T 自身占用多少字节； 

• • 只拿裸内存（不用创建对象，仅一片原始内存），调用 HashBucket::useMemory / HashBucket::freeMemory，手动传入要分配的字节大小 size，

    // 分配16字节裸内存
    void* buf = Kama_memoryPool::HashBucket::useMemory(16);
    // 回收，必须传入当初分配的size
    Kama_memoryPool::HashBucket::freeMemory(buf,16);

分配并创建 C++ 对象（自动构造 + 自动析构）

• • 调用模板 newElement<T> / deleteElement<T>，填类型 T，不用手动算 sizeof，参数直接传给类构造函数

    struct Test{ int a; Test(int x):a(x){} };
    // 分配内存+执行Test构造函数
    Test* t = Kama_memoryPool::newElement<Test>(10);
    // 先调用~Test析构，再回收内存
    Kama_memoryPool::deleteElement(t);

newElement/deleteElement 是对 useMemory/freeMemory 的上层封装，专门给有构造析构的类对象使用；

useMemory/freeMemory 是底层裸内存接口，面向无类型缓冲区

• HashBucket::useMemory(入参)：就是你前面看懂的静态分配接口，内部逻辑：判断大小选内存池 / 原生 operator new，返回一块无类型裸内存地址；

• reinterpret_cast<T*>(裸内存地址)：把接口返回的无类型内存指针，强制转换成 T 类型指针，方便后续在这块内存创建对象；

HashBucket::useMemory 返回值类型是 void*（无类型裸内存指针），void* 特点：编译器不知道这块内存存的是什么东西，不能直接调用构造函数、不能当 T 对象使用。

reinterpret_cast<T*>(地址)：强制类型转换，单纯修改编译器对这块内存的解读类型，不会修改内存本身、不会拷贝数据。

只能把 void * 裸内存转成 T*，让编译器认可这块内存是用来存放 T 类型对象的，后面才能执行 new(p) T(...) 定位 new 构造对象，比如：

void* rawMem = HashBucket::useMemory(sizeof(TestObj));

TestObj* p = reinterpret_cast<TestObj*>(rawMem);强转成TestObj*，告诉编译器这块内存存TestObj，

现在p是T类型指针，可以执行构造new(p) TestObj(1,2);，在已经分配好内存的p指向的那块空间上，原地创建TestObj对象并调用构造函数传入参数1、2，不重新分配堆内存。

reinterpret_cast转换后的TestObj *指针作为地址执行定位new，如果不做这个转换直接拿void *去定位new，编译器会报语法错误，不允许操作。

• p = 转换后的指针：把转换完的地址赋值给 p；

• != nullptr：判断内存分配是否成功，分配成功才执行内部构造逻辑。

new(p) T(std::forward<Args>(args)...);

• new(p)：定位 new 语法，不会向系统申请新内存，只会在 p 指向的已有内存上执行构造；

• std::forward<Args>(args)...：完美转发，把调用 newElement 时传入的所有构造参数，原封不动传递给 T 的构造函数，支持左值、右值参数；

• T(...)：调用类型 T 对应的构造函数，在分配好的内存上初始化对象。

return p;：把已经完成内存分配 + 对象构造的 T 指针返回给调用者，外部就能正常使用这个对象。

省略号：

• typename... Args、 typename ... Args 、typename...Args都等价，...修饰Args，中间空格仅排版分隔，代表 Args 是一组可变类型集合包，意思是可以存任意多个不同类型参数（模板尖括号里填的int、float这类种类叫类型参数，叫参数是因为它是传给模板的输入值，和函数括号传数字参数逻辑一样，只是传的是类型而非数据）

• Args&&... args：省略号修饰左边的Args&&，作用是给参数包里每一种类型都套上万能引用，叫函数形参，即函数括号里变量的数据类型（int、万能引用Args&&这类）。

• 末尾的...修饰它左边完整表达式std::forward<Args>(args)，参数包展开符，作用：把 args 里打包的所有参数逐个拆开，分别转发给构造函数。

定义类型包：typename就是一个类型，类似int，... 修饰右侧类型名 Args

参数带限定符（&&/* 等）：... 修饰左侧带限定符的完整类型片段

比如：

查看代码

#include <iostream>

// int... N：整型参数包，只能接收常量整数，不是变量类型包
template<int... N>
void PrintNums(){
    // 展开参数包
    (std::cout << N << " ", ...);
    std::cout << "\n";
}

int main(){
    PrintNums<1, 3, 5, 7>();
    PrintNums<10,20>();
}

懂了这些突然发现个事，模板具体使用情况划分：

首先

template<typename T>
T f() { return 1; }

然后调用int a = f<int>(); ，这里f<int>()后模板实例化出等价代码：int f() { return 1; }。

那模板都有哪些？大部分形式分为：

#include <iostream>
template<typename A, typename B, typename... C>
void test(C&&... args){
    std::cout << sizeof(A) << " " << sizeof(B) << "\n";
    ((std::cout << args << " "), ...);
}
int main(){
    test<int,double>(10, "abc", 3.14);
}

A、B是两个普通模板类型占位符，只在函数内部用来计算内存占用大小，没有出现在函数的形参列表里，无法通过圆括号传入的值自动推导，调用时必须在尖括号手动指定类型。后面的3.14可以自动推导，不需要写在<>里。

打包的全是形参：

查看代码

#include <iostream>
#include <string>

template<typename... B>
void func(B&&... args){
    ((std::cout << args << " "), ...);
    std::cout << "\n";
}

int main(){
    // 自动推导，省略尖括号
    func(10, "test", 3.14);

    // 手动显式指定全部包内类型
    func<int, std::string, double>(20, "demo", 6.66);
}

查看代码

template<typename T, typename Arg>
T* newElement(Arg args){
    T* p = reinterpret_cast<T*>(malloc(sizeof(T)));
    if(p) 
        new(p) T(args);
    return p;
}

struct A{ 
    A(int x){} 
};

A* ptr = newElement<A>(10);

调用 newElement<A>(10)，模板参数 T=A，形参 Arg=int，传入实参 10

进入函数内部：

• 执行 malloc(sizeof(A))：向系统堆申请一块等于 A 对象占用字节大小的原始空白内存，返回 void * 裸地址

• reinterpret_cast<T*>：把 malloc 返回的无类型指针强制转换成 A 类型指针，赋值给局部变量p

判断 if(p)：校验内存分配是否成功（malloc 失败返回空指针，不会走构造逻辑）

定位 new new(p) A(args)：

• 不在堆上新开内存，直接复用p指向的 malloc 内存

• 调用结构体 A 的构造函数，把传入参数args=10传给构造函数入参x，完成对象初始化

返回指针p：该指针指向已经分配内存 + 完成构造的 A 实例，赋值给外部变量ptr

A 这里写成了对象，那就是返回值是对象类型，然后 B 打包的可以推导，不用写<>里

查看代码

#include <iostream>
#include <utility>
#include <string>
#include <cstdlib>

template<typename A, typename... B>
A* newElement(B&&... args){
    A* p = nullptr;
    if (p = reinterpret_cast<A*>(malloc(sizeof(A))))//防止malloc分配内存失败返回空指针，空地址上调用定位new会程序崩溃
        new(p) A(std::forward<B>(args)...);
    return p;
}
struct Person {
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
}; 

int main(){
    Person* man = newElement<Person>("张三", 22);
    std::cout << man->name << " " << man->age;
    free(man);
}

1. newElement<Person>("张三",22) 先确定模板 T=Person，推导 Args 参数包类型；

2. 编译器生成专属 Person 版本 newElement 函数。

运行期不再看Person函数了，直接看专属那个函数：

1、"张三"、22 作为实参传入函数形参 Args&&...；

2、malloc 分配 Person 大小内存；

3、定位 new + forward 展开参数调用 Person 构造；

• • new(p) T(...)叫定位新建，含义：不在堆上新开内存，直接用已有地址 p 这块内存调用构造函数初始化对象；std::forward+...把外面传进来所有参数原封不动传给 T 的构造函数。

  • 普通new Person会自动 malloc 内存 + 构造，这段代码要手动管控内存（模拟内存池），内存已经手动 malloc 拿到了，不能再用普通 new 重复分配内存，只能用定位新建原地构造。

Q：这他妈不就是new Person吗？为啥不直接new一步到位啊？

A：失去了内存池的意义

标准new底层本来就分两步：分配内存、定位new构造对象，内存池就是把分配内存那一步接管自己实现，等于复刻了原生new的底层拆分逻辑。这么造轮子是因为：

• • • 系统 malloc/free 频繁调用存在锁竞争、内存碎片，高并发服务性能差；内存池一次性批量申请大块内存，后续取用归还无系统调用，大幅提速。

    • 自有内存块可做内存复用，减少频繁向操作系统申请释放内存的内核开销。

    • 适配自定义对齐、连续内存缓存场景，提升 CPU 缓存命中率，高性能服务必需。

C++默认对齐规则：对象起始地址必须是类内最大基础变量字节数的整数倍，防止硬件读取出错。

普通 new 场景：

• • • • 结构体 Person 内部只有一个 long long 变量，这个变量占 8 字节，规定只按照类里最大成员对齐，系统自带 new 分配出来的对象，存放地址只能是 0、8、16、24、32、40、48、56、64 这类 8 的倍数。Person 整个结构体大小 16 字节，比如 56 刚好空闲，把对象放在地址 56 处：占用 56、57、58、59、60、61、62、63、64、65、66、67、68、69、70、71。CPU 缓存每一块固定 64 字节，第一块范围 0~63，第二块 64~127。这个对象前 8 字节落在第一块缓存，后 8 字节落在第二块缓存。

内存池自定义对齐场景：

• • • • 同样的 Person 结构体，手动规定对象地址必须是 64 的倍数。只能放在 0、64、128、192 这类地址。地址 64 存放对象：占用 64 到 79，整块数据全部处于 64~127 这一块缓存里。

默认8字节对齐可能让对象跨两块缓存读取变慢，内存池强制64字节对齐让对象只占一块缓存读取更快（主流CPU硬件缓存行固定就是64字节，所以统一按64对齐刚好贴合硬件标准）

4、返回对象指针；

5、main 打印，手动析构，free 释放内存。