当前位置：首页 > article >正文

侯捷 C++ 课程学习笔记：四个层面基本用法

article 2025/2/25 4:08:46

一、C 语言层面的内存管理

在 C 语言中，内存管理主要通过 malloc 和 free 函数来实现。这些函数是 C 标准库的一部分，也可以在 C++ 中使用。

示例代码：

#include <cstdlib> // 包含 malloc 和 free 的头文件

int main() {
    void* p1 = malloc(512);  // 分配 512 字节的内存
    if (p1 == nullptr) {
        std::cerr << "Memory allocation failed" << std::endl;
        return -1;
    }
    // 使用分配的内存
    free(p1);  // 释放分配的内存
    return 0;
}

malloc：用于分配指定大小的内存块，返回一个 void* 类型的指针。如果分配失败，返回 nullptr。
free：用于释放由 malloc 分配的内存块。传入的指针必须是由 malloc 分配的，否则行为未定义。

二、C++ 表达式层面的内存管理

C++ 提供了 new 和 delete 表达式，用于分配和释放内存。这些表达式不仅分配内存，还会调用对象的构造函数和析构函数。

示例代码：

#include <iostream>

class Complex {
public:
    Complex() { std::cout << "Constructor called" << std::endl; }
    ~Complex() { std::cout << "Destructor called" << std::endl; }
};

int main() {
    Complex* p2 = new Complex();  // 分配一个 Complex 对象
    // 使用分配的对象
    delete p2;  // 释放分配的对象，调用析构函数
    return 0;
}

new：用于分配内存并调用对象的构造函数，返回一个指向对象的指针。如果分配失败，抛出 std::bad_alloc 异常。
delete：用于释放由 new 分配的内存，并调用对象的析构函数。传入的指针必须是由 new 分配的，否则行为未定义。

三、C++ 函数层面的内存管理

C++ 还提供了 ::operator new 和 ::operator delete 函数，用于更细粒度的内存管理。这些函数可以被重载，以实现自定义的内存分配和释放逻辑。

示例代码：

#include <iostream>

void* operator new(size_t size) {
    std::cout << "Custom memory allocation" << std::endl;
    return malloc(size);
}

void operator delete(void* ptr) {
    std::cout << "Custom memory deallocation" << std::endl;
    free(ptr);
}

class Complex {
public:
    Complex() { std::cout << "Constructor called" << std::endl; }
    ~Complex() { std::cout << "Destructor called" << std::endl; }
};

int main() {
    void* p3 = ::operator new(512);  // 使用自定义的 operator new 分配内存
    // 使用分配的内存
    ::operator delete(p3);  // 使用自定义的 operator delete 释放内存
    return 0;
}

::operator new：全局的 new 操作符，用于分配内存。可以被重载以实现自定义的内存分配逻辑。
::operator delete：全局的 delete 操作符，用于释放内存。可以被重载以实现自定义的内存释放逻辑。

四、C++ 标准库层面的内存管理

C++ 标准库提供了 allocator 类，用于更灵活地管理内存。allocator 可以与标准容器（如 vector、list 等）配合使用，提供更高效的内存管理。

示例代码：

#include <iostream>
#include <memory> // 包含 allocator 的头文件

template <typename T>
class MyAllocator {
public:
    using value_type = T;

    MyAllocator() noexcept {}

    template <typename U>
    MyAllocator(const MyAllocator<U>&) noexcept {}

    T* allocate(std::size_t n) {
        std::cout << "Custom allocator: Allocating " << n << " elements" << std::endl;
        return static_cast<T*>(malloc(n * sizeof(T)));
    }

    void deallocate(T* p, std::size_t n) {
        std::cout << "Custom allocator: Deallocating " << n << " elements" << std::endl;
        free(p);
    }
};

int main() {
    MyAllocator<int> alloc;  // 创建自定义分配器
    int* p4 = alloc.allocate(3);  // 分配 3 个 int 对象
    // 使用分配的内存
    alloc.deallocate(p4, 3);  // 释放分配的内存
    return 0;
}

allocator：C++ 标准库中的内存分配器，用于管理内存的分配和释放。可以自定义分配器，以实现特定的内存管理策略。
allocate：分配内存，返回一个指向分配内存的指针。
deallocate：释放内存，传入的指针必须是由 allocate 分配的。

总结

C++ 提供了多个层面的内存管理工具，从 C 语言的 malloc 和 free，到 C++ 的 new 和 delete，再到全局的 ::operator new 和 ::operator delete，以及 C++ 标准库的 allocator。这些工具各有特点，适用于不同的场景。在实际编程中，合理选择和使用这些内存管理工具，可以显著提高程序的性能和可维护性。

查看全文

http://www.kler.cn/a/559831.html