【C++特殊工具与技术】优化内存分配(三)：operator new函数和opertor delete函数

已于 2025-06-08 09:19:54 修改
阅读量888 收藏 17
点赞数 32
分类专栏： # C++深度探索与实战专栏 文章标签： c++ 开发语言
于 2025-06-08 09:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37800531/article/details/148439122
版权

目录

一、基础概念：operator new与operator delete的本质

1.1 标准库提供的operator new接口

1.2 标准库operator delete的接口

1.3 关键特性总结

二、new表达式与operator new的调用链解析

2.1 new表达式的底层步骤

2.2 示例：观察new表达式的调用过程

三、自定义operator new与operator delete

3.1 自定义的动机与场景

3.2 类特定的operator new重载

3.3 全局operator new的重载

四、对齐内存分配与 C++17 的align_val_t

4.1 对齐的重要性

4.2 对齐operator new的重载

五、常见陷阱与最佳实践

5.1 陷阱 1：内存分配失败的处理

5.2 陷阱 2：operator delete的参数匹配

5.3 最佳实践：与智能指针配合

5.4 最佳实践：性能优化建议

六、总结

内存管理是 C++ 的核心能力之一，而operator new和operator delete作为内存分配的底层接口，是理解 C++ 对象生命周期的关键。

一、基础概念：operator new与operator delete的本质

在 C++ 中，new和delete有两层含义：

  1. 表达式：如int* p = new int(10);，负责内存分配 + 对象构造（或delete p;负责对象析构 + 内存释放）。
  2. 操作符函数：即operator new和operator delete，是new/delete表达式调用的底层内存分配 / 释放函数。

核心关系：new表达式的执行流程是：

  1. 调用operator new分配原始内存；
  2. 调用对象的构造函数（若为类类型）；
    反之，delete表达式的流程是：
  3. 调用对象的析构函数（若为类类型）；
  4. 调用operator delete释放内存。

1.1 标准库提供的operator new接口

C++ 标准库定义了多组operator new和operator delete的重载形式，覆盖不同场景的内存分配需求。以下是最核心的 4 种形式（以 64 位系统为例）：

①普通内存分配（抛出异常）

// 分配size字节的原始内存，失败时抛出std::bad_alloc异常
void* operator new(std::size_t size);
void* operator new[](std::size_t size); // 数组版本

②不抛出异常的分配（nothrow 版本） 

// 分配失败时返回nullptr，不抛出异常
void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;

③定位分配（placement new） 

// 在已分配的内存地址ptr处构造对象（不分配内存）
void* operator new(std::size_t, void* ptr) noexcept;
void* operator new[](std::size_t, void* ptr) noexcept;

1.2 标准库operator delete的接口

operator delete的职责是释放operator new分配的内存，其接口与operator new一一对应： 

// 普通释放（与普通operator new配对）
void operator delete(void* ptr) noexcept;
void operator delete[](void* ptr) noexcept;

// 与nothrow版本配对的释放函数
void operator delete(void* ptr, const std::nothrow_t&) noexcept;
void operator delete[](void* ptr, const std::nothrow_t&) noexcept;

// 与对齐分配配对的释放函数（C++17）
void operator delete(void* ptr, std::align_val_t align) noexcept;
void operator delete[](void* ptr, std::align_val_t align) noexcept;

1.3 关键特性总结

特性说明
全局默认实现标准库提供的operator new底层调用malloc，operator delete调用free
异常行为普通版本分配失败抛std::bad_alloc，nothrow 版本返回nullptr
内存对齐普通版本保证至少alignof(std::max_align_t)（通常为 16 字节）的对齐
数组与标量差异operator new[]和operator delete[]用于数组，实现上可能多分配额外空间存储数组大小

二、new表达式与operator new的调用链解析

要理解operator new的作用，必须明确new表达式的完整执行流程。以类对象为例： 

class MyClass { 
public: 
    MyClass(int x) : val(x) {} 
private: 
    int val; 
};

MyClass* obj = new MyClass(10); // new表达式

2.1 new表达式的底层步骤

  1. 调用operator new：分配足够大的内存（大小为sizeof(MyClass)）。
  2. 调用构造函数：在分配的内存地址上调用MyClass::MyClass(int)。
  3. 返回对象指针：若构造成功，返回指向对象的指针；若构造或分配失败，释放已分配的内存并抛出异常。

2.2 示例：观察new表达式的调用过程

通过重载全局operator new并添加日志，可以验证上述流程： 

#include <iostream>
#include <new>
#include <cstdlib>

// 重载全局operator new（普通版本）
void* operator new(std::size_t size) {
    std::cout << "全局operator new被调用，分配大小：" << size << "字节" << std::endl;
    void* ptr = std::malloc(size); // 调用malloc分配内存
    if (!ptr) throw std::bad_alloc{};
    return ptr;
}

// 重载全局operator delete（普通版本）
void operator delete(void* ptr) noexcept {
    std::cout << "全局operator delete被调用" << std::endl;
    std::free(ptr); // 调用free释放内存
}

class MyClass {
public:
    MyClass(int x) : val(x) { std::cout << "MyClass构造函数被调用" << std::endl; }
    ~MyClass() { std::cout << "MyClass析构函数被调用" << std::endl; }
private:
    int val;
};

int main() {
    MyClass* obj = new MyClass(10); // new表达式
    delete obj;                     // delete表达式
    return 0;
}

输出结果：

 

  • new表达式先调用operator new分配内存，再调用构造函数；
  • delete表达式先调用析构函数，再调用operator delete释放内存；
  • 分配的内存大小等于对象类型的大小（sizeof(MyClass)=4，因int val占 4 字节）。

三、自定义operator new与operator delete

标准库的operator new基于malloc实现，虽然通用但可能在特定场景下效率不足（如高频小对象分配导致内存碎片）。通过自定义operator new，可以实现内存池、对齐优化、性能监控等高级功能。

3.1 自定义的动机与场景

场景自定义方案
减少内存碎片实现小对象内存池（如每 8 字节为一个块，预分配连续内存）
提升分配速度绕过malloc的全局锁，使用线程本地内存池
内存对齐优化为特定类型（如图像数据、SIMD 指令数据）提供更高对齐的内存
内存泄漏检测在分配时记录内存地址，释放时检查是否重复释放
调试与监控统计各类型的内存使用量，定位内存分配热点

3.2 类特定的operator new重载

最常见的自定义方式是为某个类单独重载operator new和operator delete，使该类的所有对象分配都使用自定义逻辑。

示例：为类实现内存池

以下代码为SmallObject类实现一个简单的内存池，用于管理高频分配的小对象（假设对象大小≤64 字节）：

#include <iostream>
#include <vector>
#include <cstddef>
#include <cstdlib>

class SmallObject {
public:
    static void* operator new(std::size_t size);
    static void operator delete(void* ptr, std::size_t size);

    // 测试用构造函数
    SmallObject(int x) : value(x) {}
    int value;
};

// 内存池实现（简化版）
class MemoryPool {
private:
    static constexpr std::size_t BLOCK_SIZE = 4096;    // 每个内存块大小（4KB）
    static constexpr std::size_t OBJECT_SIZE = 64;     // 最大小对象大小
    std::vector<char*> blocks;                         // 已分配的内存块
    char* currentBlock = nullptr;                      // 当前块指针
    char* currentPos = nullptr;                        // 当前分配位置

public:
    MemoryPool() { allocateNewBlock(); }

    void* allocate(std::size_t size) {
        if (size > OBJECT_SIZE) {
            return std::malloc(size); // 大对象直接调用malloc
        }
        if (currentPos + size > currentBlock + BLOCK_SIZE) {
            allocateNewBlock(); // 当前块不足，分配新块
        }
        void* ptr = currentPos;
        currentPos += size;
        return ptr;
    }

    void deallocate(void* ptr, std::size_t size) {
        if (size > OBJECT_SIZE) {
            std::free(ptr); // 大对象直接调用free
            return;
        }
        // 简单内存池不回收单个对象，实际可扩展为空闲链表
    }

private:
    void allocateNewBlock() {
        currentBlock = static_cast<char*>(std::malloc(BLOCK_SIZE));
        if (!currentBlock) throw std::bad_alloc{};
        blocks.push_back(currentBlock);
        currentPos = currentBlock;
        std::cout << "分配新内存块，地址：" << static_cast<void*>(currentBlock) << std::endl;
    }
};

// 静态内存池实例
static MemoryPool smallObjectPool;

// 类特定的operator new
void* SmallObject::operator new(std::size_t size) {
    return smallObjectPool.allocate(size);
}

// 类特定的operator delete
void SmallObject::operator delete(void* ptr, std::size_t size) {
    smallObjectPool.deallocate(ptr, size);
}

int main() {
    // 测试小对象分配
    SmallObject* obj1 = new SmallObject(10);
    SmallObject* obj2 = new SmallObject(20);
    std::cout << "obj1地址：" << obj1 << std::endl;
    std::cout << "obj2地址：" << obj2 << std::endl;

    delete obj1;
    delete obj2;

    return 0;
}

输出结果：

注意：两个对象地址连续，间隔4字节（int大小）
  • 内存池预分配 4KB 的内存块，小对象分配时直接从块中划分，避免频繁调用malloc；
  • operator new和operator delete通过静态MemoryPool实例管理内存；
  • 实际生产环境中，内存池需要实现空闲链表（free list）来回收释放的内存，避免内存浪费。

3.3 全局operator new的重载

全局重载会影响所有未显式定义类特定operator new的类型，需谨慎使用。常见场景是实现全局内存监控或调试工具。

示例：全局内存分配监控

通过全局重载operator new和operator delete，记录每次分配的内存大小和地址，用于检测内存泄漏： 

#include <iostream>
#include <new>
#include <unordered_map>
#include <mutex>

// 全局内存分配统计
static std::unordered_map<void*, std::size_t> allocatedMemory;
static std::mutex mtx;

// 重载全局operator new（普通版本）
void* operator new(std::size_t size) {
    void* ptr = std::malloc(size);
    if (!ptr) throw std::bad_alloc{};

    std::lock_guard<std::mutex> lock(mtx);
    allocatedMemory[ptr] = size; // 记录分配的内存地址和大小
    std::cout << "分配内存：地址=" << ptr << "，大小=" << size << "字节" << std::endl;
    return ptr;
}

// 重载全局operator delete（普通版本）
void operator delete(void* ptr) noexcept {
    std::lock_guard<std::mutex> lock(mtx);
    if (allocatedMemory.count(ptr)) {
        std::size_t size = allocatedMemory[ptr];
        allocatedMemory.erase(ptr);
        std::cout << "释放内存：地址=" << ptr << "，大小=" << size << "字节" << std::endl;
    }
    std::free(ptr);
}

int main() {
    int* p1 = new int(10);
    int* p2 = new int[5]; // 调用operator new[]

    delete p1;
    // 注意：delete[]调用operator delete[]，这里未重载，使用标准库版本（不会触发监控）
    // 实际使用中需同时重载operator new[]和operator delete[]

    // 程序结束前检查未释放的内存
    std::lock_guard<std::mutex> lock(mtx);
    if (!allocatedMemory.empty()) {
        std::cout << "检测到内存泄漏，未释放的内存块数：" << allocatedMemory.size() << std::endl;
        for (auto& [ptr, size] : allocatedMemory) {
            std::cout << "泄漏地址：" << ptr << "，大小：" << size << "字节" << std::endl;
        }
    }
    return 0;
}
  • 全局重载会影响所有未自定义operator new的类型；
  • 需同时重载operator new[]和operator delete[]以支持数组分配；
  • 通过统计allocatedMemory可以检测内存泄漏，但实际工具（如 Valgrind）更高效。

四、对齐内存分配与 C++17 的align_val_t

对于需要高对齐的场景（如 SIMD 指令处理、GPU 数据传输），C++17 引入了align_val_t类型，允许自定义对齐的内存分配。

4.1 对齐的重要性

现代 CPU 对内存对齐有严格要求：

  • 访问未对齐的内存可能导致性能下降（如 x86）或硬件异常（如 ARM）；
  • SIMD 指令（如 AVX-512）要求数据按 32/64 字节对齐；
  • GPU 纹理数据通常要求按 256 字节对齐。

4.2 对齐operator new的重载

C++17 允许通过align_val_t参数重载operator new，处理特定对齐需求： 

#include <iostream>
#include <new>
#include <cstdalign>

// 重载对齐版本的operator new（C++17）
void* operator new(std::size_t size, std::align_val_t align) {
    std::cout << "对齐分配：大小=" << size << "，对齐=" << static_cast<std::size_t>(align) << "字节" << std::endl;
    void* ptr = std::aligned_alloc(static_cast<std::size_t>(align), size);
    if (!ptr) throw std::bad_alloc{};
    return ptr;
}

// 重载对齐版本的operator delete（C++17）
void operator delete(void* ptr, std::align_val_t align) noexcept {
    std::cout << "对齐释放：地址=" << ptr << "，对齐=" << static_cast<std::size_t>(align) << "字节" << std::endl;
    std::free(ptr); // aligned_alloc分配的内存可用free释放
}

// 定义需要32字节对齐的类（C++11 alignas关键字）
class AlignedData {
public:
    alignas(32) int data[8]; // 32字节对齐的int数组（8个int占32字节）
};

int main() {
    AlignedData* data = new AlignedData();
    std::cout << "对象地址：" << data << std::endl;
    std::cout << "地址对齐验证：" << (reinterpret_cast<uintptr_t>(data) % 32 == 0 ? "符合" : "不符合") << std::endl;
    delete data;
    return 0;
}
  • alignas(32)指定类的对齐要求，new表达式会调用对齐版本的operator new；
  • std::aligned_alloc是 C11 提供的对齐内存分配函数，C++17 起可用；
  • 对齐分配的内存必须用对应的operator delete释放。

五、常见陷阱与最佳实践

5.1 陷阱 1：内存分配失败的处理

标准库operator new在分配失败时抛std::bad_alloc，但自定义实现需显式处理失败场景：

// 错误示例：未检查malloc返回值
void* operator new(std::size_t size) {
    return std::malloc(size); // malloc失败返回nullptr，但未抛异常，违反标准行为
}

// 正确示例：
void* operator new(std::size_t size) {
    void* ptr = std::malloc(size);
    if (!ptr) throw std::bad_alloc{}; // 必须抛异常或符合nothrow语义
    return ptr;
}

5.2 陷阱 2：operator delete的参数匹配

operator delete的size参数（C++14 起可选）必须与operator new的分配大小一致，否则可能导致未定义行为：

class MyClass {
public:
    static void* operator new(std::size_t size) {
        return std::malloc(size + 8); // 多分配8字节用于额外数据
    }
    static void operator delete(void* ptr, std::size_t size) {
        std::free(ptr); // 错误：释放的内存大小应为size+8，但传入的size是sizeof(MyClass)
    }
};

解决方案：若自定义operator new多分配了内存，需在operator delete中手动调整指针（如存储额外数据到多分配的空间中）。

5.3 最佳实践：与智能指针配合

std::unique_ptr和std::shared_ptr支持自定义删除器，可与自定义operator delete结合： 

#include <memory>

class CustomAllocator {
public:
    static void* allocate(std::size_t size) { /* 自定义分配 */ }
    static void deallocate(void* ptr) { /* 自定义释放 */ }
};

// 使用unique_ptr管理自定义分配的内存
std::unique_ptr<int, decltype(&CustomAllocator::deallocate)> 
    ptr(static_cast<int*>(CustomAllocator::allocate(sizeof(int))), CustomAllocator::deallocate);

5.4 最佳实践：性能优化建议

  • 小对象使用内存池：减少malloc调用次数，降低内存碎片；
  • 线程安全：多线程环境下，内存池需加锁或使用线程本地存储（TLS）；
  • 对齐优先：对需要高对齐的类型（如图像、SIMD 数据），显式使用对齐operator new；
  • 避免全局重载：全局重载影响范围广，优先使用类特定重载。 

六、总结

operator new和operator delete是 C++ 内存管理的 "基础设施"，通过自定义实现可以：

  • 优化高频小对象的分配效率；
  • 实现高对齐内存的精准控制；
  • 监控内存使用，检测泄漏；
  • 与特定场景（如游戏、嵌入式）的内存策略深度整合。

掌握这对操作符的核心逻辑，是成为高级 C++ 开发者的必经之路。在实际项目中，建议结合性能分析工具（如 Perf、Valgrind）验证自定义分配器的效果，避免为优化而引入复杂性。

2.STL之::operator new()的理解
107
06-23 1万+
STL之operator new的理解1.new运算符和operator new()2.new和operator new之间的关系3.如何限制对象只能建立在堆上或者栈上3.1建立类只能建立在堆上(设置析构函数为Protected)3.2只能建立在栈上(重载new函数设为私有) 1.new运算符和operator new() new：指我们在C++里通常用到的运算符，比如A* a = new A; 对于new来说，有new和::new之分，前者位于std operator new()：指对new的重
重载operator new/delete/new[]/delete[]
peanWang的博客
10-06 2490
Abstact 之前看侯捷老师的C++面向对象开发上。老师讲了一个知识点，如下图： 在他的C++面向对象高级编程（下）课程中，侯捷老师讲了重载operator new，operator delete。这篇blog主要实现重载operator new/delete。并进行验证上图。Let`s go Code: 下面是相应的代码。重载了operator new/delete/new[]/delet...
四万字长文说operator new & operator delete
liugan528的博客
07-03 1746
关于operator new & operator delete搞懂这一篇，对绝大多数人的C++生涯足够用了吧......
C++ 浅谈new/delete， operator new/operator delete，malloc/free和new/delete的区别 ，内存泄漏
HanMeng的博客
04-18 1583
文章目录：1. C/C++内存分布2. C语言中动态内存管理方式3. C++内存管理方式3.1 new/delete操作内置类型3.2 new和delete操作自定义类型 1. C/C++内存分布 (1) 栈又叫堆栈，非静态局部变量/函数参数/返回值等等都在栈上，栈是向下增长的 (2)内存映射段是高效I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信 (3)堆用于程序运行时动态内存分配，堆是向上增长的 (4)数据段–存储全局数据和静态数据 (变量) (5)代
C/C++ 内存分配 new 操作符：剖析new操作符的实现机制和使用技巧
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
03-19 2096
C/C++ new操作符
C++性能优化（六）——动态内存管理
天山老妖
02-21 1539
一、new/delete操作符 C++实现通过全局new/new []和delete/delete []来提高动态内存的访问和管理。operator new可以是类的成员函数或全局函数，通常C++运行库提供了默认的全局new/new []和delete/delete []实现，应用程序也可以用自定义实现代替C++运行库提供的默认实现，但一个程序最多只能有一个自定义实现。 C++标准中new/new []和delete/delete []声明定义如下： namespacestd { class..
c++this指针 友元类 虚函数 static new和delete 定位new表达式
weixin_45726063的博客
08-30 270
1，this指针 this指针是成员函数第一个隐含的指针形参，一般情况下由编译器通过exc寄存器自动传递，不需要用户传递 寄存器：eax ebx ecx edx ebp esp… 空间小 速度快 离cpu近的存储空间 一般情况下内存中的数据要进行计算，基本上都是先将数据放到寄存器中，然后再来进行运算 this指针的类型： *const 只有在类的非静态成员函数中才可以使用this指针，其他任何函数都不可以 this指针的特点： 1.全局函数静态函数都不能使用this指针，实际上成员函数默认第一个参数是
operator new和operator delete->优化内存分配
晴天的专栏
08-18 992
为什么有必要写自己的operator new和operator delete？ 答案通常是：为了效率。 缺省版本的operator new是一种通用型的内存分配器，它必须可以分配任意大小的内存块。同样，operator delete也要可以释放任意大小的内存块。operator delete想弄清它要释放的内存有多大，就必须知道当初operator new分配的内存有多大。有一种常用的方法可以
C++ 学习笔记 (6) 最好不要重载全局 operator new 和 operator delete
07-29 297
自从尝试重载 new操作符，也算是见了眼界——原来 new是不可以重载的。 一般使用的分配内存的 new就是一个操作符，不可改变，不可重载 可以重载的是 operator new和 placement new ( placement new重载了 operator new ) ...
【C++从入门到踹门】第五篇：new与delete
qq_43041053的博客
02-20 764
目录1. C/C++的内存分布2. C++的内存管理方式2.1 new和delete操作内置类型2.2 new和delete操作自定义类型4.operator new 和operator delete函数4.1 ``new`` 和 ``operator new``4.2 operator new的三种重载形式4.3 operator delete5.new和delete的实现原理5.1 内置类型5.2 自定义类型6 operator new /operator delete的类专属重载 与 定位new（
《深度探索C++对象模型》(二)C++，new，delete，构造/析构，临时对象
郭晓东的专栏
05-18 2669
前期blog请点击 《深度探索C++对象模型》侯捷译——笔记（一）  即使父类的析构函数设置为虚函数，那么当父类指针指向子类对象的时候，也有不能够正确析构的情况。比如Point* ptr = new Point3d[10]; 六、执行期语意学 该章节三个知识点比较重要：第一对象的构造和析构，第二new和delete运算符 第三个是：临时变量。 ---》C++支持栈上的对象，所以栈上的变量的
【C++】深入解析C++智能指针：从auto_ptr到unique_ptr与shared_ptr
Colorful___的博客
05-26 1278
随着C++语言的发展，智能指针作为现代C++编程中管理动态分配内存的一种重要工具，越来越受到开发者的青睐。智能指针不仅简化了内存管理，还有助于避免内存泄漏等常见问题。本文将深入探讨智能指针的使用及其原理，从C++98标准库中的auto_ptr开始，逐步过渡到C++11中更为强大和灵活的智能指针类型，如unique_ptr和shared_ptr。此外，文章还将讨论循环引用问题、内存泄漏的原因及其危害，并提供相应的解决方案。通过本文的学习，读者将能够更好地理解和运用智能指针，编写出更安全、更高效的C++代码。
Pimpl中的unique_ptr编译错误及解决方法
Sunrise的专栏
12-26 1504
C++ impl
【C++初阶】string类讲解：含常用接口使用及原理模拟实现
twlw13的博客
03-16 1266
1、C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。2、在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。
C#和C++在编译过程中的文件区分
weixin_50600749的博客
06-04 272
示例： math_utils.cpp --编译--> math_utils.lib。示例： math_utils.cpp --编译--> math_utils.dll。3. 创建类库项目，定义，实现后编译，就生成了.dll文件，如MyLib.dll。2. .cpp是源文件（Source File）2. .cs编译后生成一个.dll文件。把.cpp文件编译成 .lib文件。把.cpp文件编译成 .dll文件。静态库是“编译时拷进程序里的”3.2 动态库 .dll。3.1 静态库 .lib。
STL 库基础概念与示例
2302_76213070的博客
06-04 324
自动去重并按字符 ASCII 值排序，插入重复元素无效。按插入顺序存储，需手动排序，支持下标和迭代器遍历。简化值的修改，键唯一（重复插入同一键会更新值）。
C/C++ 面试复习笔记（4）
最新发布
apolloyhl的博客
06-06 903
内存颠簸是指系统在频繁地进行内存页的换入换出操作，导致大量的磁盘 I/O，系统性能急剧下降的现象。当系统的物理内存不足，而进程对内存的需求又不断变化时，就容易出现内存颠簸。例如，一个进程频繁地访问不同的内存页，而这些页在内存中频繁地被换出和换入。在 Linux 系统中，可以通过以下方法避免或解决内存颠簸问题：增加物理内存：如果物理内存不足是导致内存颠簸的主要原因，增加内存条可以直接提 高系统的可用内存，减少页交换操作。
极限复习c++
2302_76213070的博客
06-05 2066
快速过一遍必背代码（类、多态、模板）和简答题答案，强化肌肉记忆！祝考试顺利，代码全 AC！
c++ openssl 使用 DES（数据加密标准）进行加密和解密的基本操作
qq_43420088的博客
06-05 931
使用 DES（数据加密标准）进行加密和解密的基本操作，重点展示了 ECB 和 CBC 模式，并且通过篡改密文的方式来进行攻击。下面是对每个部分的详细解析。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

byte轻骑兵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值