C++静态分配和动态分配-CSDN博客

本文链接：https://blog.csdn.net/zwy123987/article/details/141823993

C++中堆和栈的区别

堆和栈是计算机科学中两个重要的概念，它们都与数据存储相关。

1.栈（Stack）：

- 栈是一个后进先出（LIFO）的数据结构。

- 栈中的数据是一种有序集合，只能在一端进行插入或删除操作。

- 在C++中，栈是用于存储局部变量和函数调用的地方。

- 栈是由编译器自动管理的。

2.堆（Heap）：

- 堆是一个特殊的树形数据结构，通常用于分配动态内存。
- 堆是一个无序的数据结构，它可以在任何位置分配或删除数据。

- 堆的主要操作是插入（分配内存）和删除（释放内存）。

- 堆是由程序员手动管理的。

#include <iostream>
#include <malloc.h> // 使用 malloc 和 free 需要包含这个头文件
 
int main() {
    // 栈
    int a; // 局部变量，存储在栈上
    a = 10;
 
    // 堆
    int* b = (int*)malloc(sizeof(int)); // 分配堆内存
    *b = 20;
 
    std::cout << "Local variable 'a' on stack: " << a << std::endl;
    std::cout << "Memory on heap: " << *b << std::endl;
 
    free(b); // 释放堆内存
    return 0;
}

区别概括：

存储类型：栈存储局部变量和函数调用，堆用于动态内存分配。
管理方式：栈通常是自动管理的，堆需要手动分配和释放。
生命周期：栈的数据会在其定义的块（如函数）结束时消失，堆的数据直到被显式释放为止。
分配方式：栈是向下分配内存，堆是向上分配内存。
分配效率：栈操作通常很快，而堆操作可能较慢，因为需要搜索足够大的内存块。
分配大小：栈的大小通常是固定的，而堆的大小可以非常大或小，取决于需求。

对象的存储方式和生命周期管理

1. 内存管理

XYZ* ptr = new XYZ();
- 动态分配：对象是在堆上分配内存，生命周期由程序员管理。
- 内存泄漏：如果你忘记调用 delete ptr;，会导致内存泄漏。
- 灵活性：可以在函数或对象之间传递指针，适用于需要动态创建对象的情况。
XYZ ptr;
- 栈分配：对象是在栈上分配内存，生命周期由作用域决定。
- 自动销毁：对象在离开作用域时自动销毁，不需要手动释放内存。
- 简单安全：避免了手动内存管理的复杂性和风险。

1. 函数间传递指针

假设你有一个类 MyClass，它有一个成员函数 initialize()，可以动态分配一个对象并将其指针传递给函数进行初始化。

#include <iostream>

class MyClass {
public:
    void initialize() {
        std::cout << "MyClass initialized." << std::endl;
    }
};

void setupObject(MyClass* obj) {
    // Initialize the object
    obj->initialize();
}

int main() {
    // Dynamically allocate MyClass object
    MyClass* myObject = new MyClass();
    
    // Pass the pointer to the function
    setupObject(myObject);
    
    // Clean up
    delete myObject;
    return 0;
}

setupObject 函数接收一个 MyClass 指针作为参数，初始化对象。在 main 函数中，我们动态分配一个 MyClass 对象，将其指针传递给 setupObject 函数，最后记得释放内存。

2. 对象间传递指针

考虑一个场景，Container 类需要存储 Item 对象，并且允许添加和访问这些对象。

#include <iostream>
#include <vector>

class Item {
public:
    Item(int value) : value(value) {}
    void display() const {
        std::cout << "Item value: " << value << std::endl;
    }
private:
    int value;
};

class Container {
public:
    void addItem(Item* item) {
        items.push_back(item);
    }
    
    void showItems() const {
        for (const auto& item : items) {
            item->display();
        }
    }
    
    ~Container() {
        // Clean up dynamically allocated Items
        for (auto item : items) {
            delete item;
        }
    }
private:
    std::vector<Item*> items;
};

int main() {
    Container container;
    
    // Dynamically allocate Items and add to Container
    container.addItem(new Item(1));
    container.addItem(new Item(2));
    container.addItem(new Item(3));
    
    // Display all Items
    container.showItems();
    
    // Container destructor will clean up dynamically allocated Items
    return 0;
}

Container 类管理一个 Item 对象的动态数组。addItem 方法将动态分配的 Item 对象添加到 Container 中，showItems 方法显示所有存储的 Item 对象。Container 的析构函数确保在销毁时释放所有动态分配的 Item 对象。

3. 函数返回指针

让函数返回一个指向动态分配对象的指针。例如，创建一个工厂函数来返回一个动态分配的对象。

#include <iostream>

class MyClass {
public:
    MyClass(int value) : value(value) {}
    void show() const {
        std::cout << "MyClass value: " << value << std::endl;
    }
private:
    int value;
};

MyClass* createObject(int value) {
    return new MyClass(value);
}

int main() {
    // Create a new MyClass object using the factory function
    MyClass* obj = createObject(42);
    
    // Use the object
    obj->show();
    
    // Clean up
    delete obj;
    return 0;
}

createObject 函数动态分配一个 MyClass 对象，并返回其指针。main 函数调用 createObject，然后使用返回的指针，最后释放内存。

2. 对象生命周期和作用域

动态分配 (XYZ* ptr = new XYZ();)：
- 生命周期长短：对象的生命周期不受作用域限制，直到显式调用 delete。
- 传递：对象可以被传递到其他函数或对象中而不会在作用域结束时自动销毁。
栈分配 (XYZ ptr;)：
- 生命周期短暂：对象的生命周期仅限于其所在的作用域，作用域结束时自动销毁。
- 函数传递：如果需要将对象传递给其他函数，通常会进行拷贝或传递引用/指针，这可能会带来性能开销。

3. 对象的创建和销毁成本

动态分配：
- 开销：new 和 delete 操作通常比栈分配慢，因为涉及到堆内存管理。
- 管理复杂性：需要处理对象创建和销毁的代码，增加了出错的可能性。
栈分配：
- 开销：栈分配和销毁通常比堆分配快。
- 管理简单：不需要显式的内存管理，减少了出错的可能性。

4. 对象传递

通过指针传递：
- 灵活性：可以传递指针到函数中，函数可以修改对象的状态，适合大对象或需要修改对象的场景。
- 共享：多个指针可以指向同一个对象，适合需要多个实体共享同一对象的情况。
通过值传递：
- 拷贝开销：如果对象较大，复制对象可能会带来性能开销。可以通过引用或指针避免不必要的拷贝。
- 独立性：每个对象都是独立的，不会影响到其他对象，适合需要对象独立存在的场景。