C++开发基础之对象的生存周期和内存管理方式（堆内存和栈内存）

在C++中，对象的生存周期和内存管理方式（堆内存和栈内存）之间存在着密切的关系。

一、如何识别堆栈对象

在C++中，可以通过以下几种方法来识别对象是在堆上还是在栈上：

1. 关键字new和delete的使用：
   • 如果在代码中使用了new关键字来创建对象，则该对象是在堆上分配的。
   • 使用了delete关键字来手动释放内存，则该对象是在堆上分配的。

举例说明：

// 在堆上分配对象
MyObject *obj = new MyObject();
// 手动释放内存
delete obj;

2. 指针操作：
   • 如果需要使用指针来操作对象，并且需要手动释放内存，则该对象很可能是在堆上分配的。

举例说明：

// 在堆上分配对象
MyObject *ptr = new MyObject();
// 使用指针操作对象
ptr->doSomething();
// 手动释放内存
delete ptr;

3. 作用域：
   • 如果对象在函数内部声明并在函数结束时自动销毁，则该对象是在栈上分配的。
   • 如果对象在函数外部声明并持续存在到程序结束，则该对象是在全局数据区或静态数据区分配的。

举例说明：

void function() {
    // 对象在栈上分配
    MyObject obj;
    // ...
} // 函数结束时对象自动销毁

4、IDE工具查看
对比查看堆上的地址和栈上的地址。

二、理解堆栈对象的生存周期

1. 栈上的对象

当对象在栈上创建时，它的生命周期与其所在作用域的范围相对应。一旦超出该作用域范围，对象会被自动销毁，释放其占用的内存空间。一个简单的C++示例来说明这一点：

#include <iostream>

void functionA() {
    int num = 10; // 在 functionA 函数中创建一个整型变量 num
    std::cout << "Inside functionA, num is: " << num << std::endl;
} // 当 functionA 函数执行完毕时，num 对象超出作用域范围，会被销毁

int main() {
    functionA(); // 调用 functionA 函数
    // 此处不能再访问 num 对象，因为它已经被销毁

    // 在 main 函数中创建一个字符串对象
    std::string str = "Hello, World!";
    std::cout << "Inside main, str is: " << str << std::endl;

    // str 对象仍然在作用域内，可以继续使用

    return 0;
} // 当 main 函数执行完毕时，str 对象超出作用域范围，会被销毁

在上面的示例中，函数functionA内部创建的整型变量num以及main函数内部创建的字符串对象str都是在栈上分配的。当函数functionA执行完毕后，整型变量num超出了其作用域范围，因此会被销毁并释放内存；同样地，当main函数执行完毕后，字符串对象str也会被销毁。

这种自动管理栈上对象生命周期的机制使得在函数调用结束时不需要显式释放内存，从而简化了程序员的工作，并且避免了内存泄漏等问题。

2. 堆上的对象

通过new运算符在堆上动态分配的对象，其生命周期不会受限于作用域范围，直到显式调用delete操作符来手动释放内存或程序结束时才会被销毁。这种在堆上分配内存的方式称为动态内存分配，允许在需要时动态地创建和管理对象，而不受作用域的限制。一个简单的C++示例来说明在堆上创建对象并手动释放内存的过程：

#include <iostream>
int main() {
    // 在堆上动态分配一个整型对象
    int *ptr = new int(5);
    std::cout << "Value of dynamically allocated integer: " << *ptr << std::endl;
    // 手动释放内存，防止内存泄漏
    delete ptr;    
    // 将指针置为空，以避免成为野指针
    ptr = nullptr;
    return 0;
} // 程序结束时，动态分配的整型对象被手动释放

在上述示例中，通过new运算符在堆上动态分配了一个整型对象，并使用指针ptr进行管理。这个整型对象的生命周期不受限于作用域范围，只有在调用delete操作符手动释放内存后，对象才会被销毁。在实际开发中，动态内存分配需要谨慎使用，确保及时释放内存，以避免内存泄漏等问题。

三、那些容易混淆地方

在C++中，识别对象是在堆上还是在栈上时，有一些容易混淆的地方需要特别注意：

1. 指针的传递：

指针的传递：即使对象是在堆上分配的，当以指针或引用的方式传递给其他函数时，可能会产生误解。因为函数内部无法直接判断这个指针所指向的对象是在堆上还是在栈上分配的。

#include <iostream>
class MyClass {
public:
    void print() {
        std::cout << "Printing from MyClass" << std::endl;
    }
};
void func(MyClass* obj) {
    obj->print();
}

int main() {
    // 在堆上分配对象
    MyClass* ptr = new MyClass();
    // 通过指针传递给函数
    func(ptr);
    // 虽然对象在堆上，函数内无法准确判断对象位置
    delete ptr; // 但需要手动释放内存
    return 0;
}

2. 复杂的类关系：

复杂的类关系：在面向对象编程中，类之间存在继承、多态等关系，对象的实际分配位置可能会变得更加复杂。例如，派生类可能通过基类的指针在堆上分配空间，这种情况下也需要格外小心地管理内存。

#include <iostream>
class Base {
public:
    virtual void print() {
        std::cout << "Printing from Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() override {
        std::cout << "Printing from Derived" << std::endl;
    }
};
void func(Base* obj) {
    obj->print();
}

int main() {
    // 在堆上分配派生类对象
    Base* ptr = new Derived();
    // 通过基类指针传递给函数
    func(ptr);
    // 虽然对象在堆上，但通过基类指针调用函数
    delete ptr; // 需要手动释放内存
    return 0;
}

3. 智能指针的使用：

智能指针的使用：使用智能指针（如std::shared_ptr、std::unique_ptr）可以帮助减少手动管理内存的负担，但是如果不清楚其内部实现机制，也可能导致对对象所在位置的误解。

#include <memory>
#include <iostream>

class MyClass {
public:
    void print() {
        std::cout << "Printing from MyClass" << std::endl;
    }
};

int main() {
    // 使用std::shared_ptr在堆上分配对象
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    // 使用智能指针传递给函数
    ptr->print(); // 智能指针会自动管理内存
    return 0;
}

4. 内存泄漏和悬空指针：

内存泄漏和悬空指针：在动态内存管理过程中，存在内存泄漏和悬空指针等问题，这些问题可能会混淆对象是在堆上还是在栈上的分配位置。

#include <iostream>

class MyClass {
public:
    void print() {
        std::cout << "Printing from MyClass" << std::endl;
    }
};

int main() {
    // 在堆上分配对象
    MyClass* ptr = new MyClass();
    // 未释放内存导致内存泄漏
    // delete ptr;
    
    // 悬空指针
    MyClass* danglingPtr = nullptr;
    danglingPtr->print(); // 访问空指针会导致未定义行为
    return 0;
}

这些示例展示了在实际编程中容易混淆对象分配位置的情况，需要特别注意正确处理内存管理以及指针的传递。在实际编码过程中，需要结合代码风格规范、注释和文档、静态代码分析工具等手段来尽量避免以上容易混淆的情况，以确保对对象分配位置的准确理解。

四、堆栈管理：

1. 栈内存：栈内存是一种自动分配和释放内存的机制，由编译器自动管理。每当进入一个新的作用域时，栈会为局部变量分配内存空间；当作用域结束时，这些局部变量所占用的内存会被自动释放。栈内存的操作效率高，但大小有限。

• 栈内存的大小限制：栈内存大小通常比堆内存小得多。在大多数情况下，栈的大小受限于操作系统或编程语言的设定，如果尝试分配超出栈大小的内存，可能会导致栈溢出。

• 数据的临时性：栈上的数据是临时的，当函数执行完毕或作用域结束时，栈上的局部变量就会被销毁。因此，在栈上分配的内存不能在函数外部访问。

• 创建对象的消耗：在栈上创建对象的开销通常比在堆上更小，因为不涉及动态内存管理的复杂性。这使得栈上分配对象的速度更快。

• 递归调用：栈内存也用于存储函数调用的上下文信息。在递归调用中，每次函数调用都会占用一定的栈空间，如果递归层级过深，可能会导致栈溢出。

2. 堆内存：堆内存则是一种动态分配的内存空间，大小不受限制，需要手动分配和释放。在堆上分配内存可以使得对象的生存期更长，并且可以通过指针在不同作用域之间共享对象。但是堆内存的分配和释放需要手动管理，容易出现内存泄漏或者内存访问错误。

• 手动管理：在堆上分配内存需要使用特定的函数（如C++中的new操作符或者malloc函数），同时也需要手动释放分配的内存（使用delete或free）。如果忘记释放分配的内存，就会导致内存泄漏，程序占用的内存会持续增加而不会被释放。

• 内存碎片：频繁的堆内存分配和释放可能会导致内存出现碎片化，使得大块的连续内存难以获得。这可能会影响性能，特别是在需要大块连续内存的情况下（比如动态数组或复杂的数据结构）。

• 多线程安全：在多线程环境下，堆内存的分配和释放需要考虑线程安全性，避免出现多个线程同时操作同一块内存引发的问题。通常需要使用同步机制来保证堆内存的安全分配和释放。

• 智能指针：为了简化堆内存的管理，现代C++推荐使用智能指针（如std::shared_ptr和std::unique_ptr），它们可以自动管理对象的内存释放，避免手动释放内存带来的问题。

五、区别总结：

• 栈内存适合用于管理局部变量和短期对象，自动分配和释放，速度快，但大小受限；
• 堆内存适合用于动态分配内存，对象生存期需要延长或者大小不确定的情况，需要手动管理内存，速度较慢，容易出现内存泄漏问题。