静态创建和动态创建对象的区别

一.区别介绍

静态创建对象指的是在栈上创建对象,比如A a;它会在对象的作用域结束后自动销毁.

动态创建对象指的是在堆上创建对象,然后栈上的指针指向创建的对象.比如A *pa = new A();它需要程序员手动delete掉.如果不进行delete操作,只能等到程序结束后,由OS来回收掉.

代码说明:

#include <iostream>
using namespace std;

class Programmer
{
public:
    int m_nAge;
    string m_sLanguage;

    Programmer(int nAge, string sLanguage)
    {
        m_nAge = nAge;
        m_sLanguage = sLanguage;
    }

    Programmer()
    {
        cout << "Ctor" << endl;
    }

    ~Programmer()
    {
        cout << "Dtor" << endl;
    }
};

int main()
{
    //定义在栈上的对象
    Programmer pro(27, "C++");

    //定义在堆上的对象
    Programmer * pPro = new Programmer(27, "C++");
    delete pPro;
    return 0;
}

二.动态创建对象的好处

上面的例子,我们会有一个疑问,静态创建感觉比动态创建简单,而且效果是一致的,为何还要进行动态创建呢?

其实如果进行返回临时对象的指针操作时,你就能够发现问题了.

两个函数都是返回对象的指针,前者是在栈上定义的对象proTemp,它在出了函数作用域后,会被销毁掉.那么返回的&proTemp指向的对象就不存在了,就变成了一个野指针.这样就会出现问题.

而后者对象是在堆上创建的,就不会存在这个问题.不过记得要及时释放掉对应的内存哦.

//class类中 
    
    Programmer * GetProgrammer(int nAge, string sLanguage)
    {
        Programmer proTemp = Programmer(nAge, sLanguage);
        return &proTemp;
    }

    Programmer * GetProgrammerNew(int nAge, string sLanguage)
    {
        Programmer *proTemp = new Programmer(nAge, sLanguage);
        return proTemp;
    }

//main函数中

    //返回局部对象的指针 //因为所指向的对象已经销毁,所以返回的指针是野指针(所指向的爸爸没了)
    Programmer * pProTemp = pro.GetProgrammer(27, "C++");
    cout << "age:" << pProTemp->m_nAge << endl;
    cout << "Language:" << pProTemp->m_sLanguage << endl;

    //返回堆上对象的指针
    Programmer * pProTempNew = pro.GetProgrammerNew(27, "C++");
    cout << "age:" << pProTempNew->m_nAge << endl;
    cout << "Language:" << pProTempNew->m_sLanguage << endl;
    delete pProTempNew;

文章参考: C++中栈和堆上建立对象的区别 (malloc那块可以不用细看,知道malloc比这new少做了构造)