C++类实例化的种类，及 new和不new的区别 (***)

目录

C++类实例化的两种方式：new和不new的区别

C++中类的实例化的方法 **

========================

C++类实例化的两种方式：new和不new的区别
https://zhuanlan.zhihu.com/p/62106872

C++中类的实例化的方法 **

C++中类的实例化的方法

类的实例化按照在分配内存上面的不同大体分为在：栈中的分配内存和堆中的内存的分配，于是分为下面三种方式。

class CEmployee
{
private:
    int age;
    int id;
public:
    CEmployee()
    {
        cout << "这是构造函数" << endl;
    }
    CEmployee(int id)
    {
        this->id = id;
    }
    ~CEmployee()
    {
        cout << "这是析构函数" << endl;
    }
    void OutputName()
    {
        cout << this->id <<endl;
    }
};

一、隐式创建

隐式创建方式在进程虚拟地址空间中的栈中分配内存，它的分配和释放由系统决定，函数内局部变量的存储单元可以在栈上创建，函数执行完毕，系统会自动释放这些存储单元。

int main() {
  CEmployee cEmployee1;   //隐式创建并调用无参构造器
  CEmployee cEmployee2(2); //隐式创建并调用有参构造器
   return 0;
}

二、显式创建

这种创建方式和第一种一样，在进程虚拟地址空间中的栈中分配内存，它的分配和释放由系统决定，函数内局部变量的存储单元可以在栈上创建，函数执行完毕，系统会自动释放这些存储单元。

int main() {
  CEmployee cEmployee1 = CEmployee;   //显式创建并调用无参构造器
  CEmployee cEmployee2 = CEmployee(2); //显式创建并调用有参构造器
  return 0;
}

三、显式new创建

这种方式使用了new关键字，在堆中分配了内存，堆上的内存分配，亦称动态内存分配。程序在运行的期间用malloc申请的内存，这部分内存由程序员自己负责管理，其生存期由开发者决定:在何时分配，分配多少，并在何时用free来释放该内存。

int main() {
    CEmployee *cEmployee1 = new CEmployee; //显式new创建并调用无参构造器
    CEmployee *cEmployee2 = new CEmployee(2); //显式new创建并调用有参构造器
    return 0;
}

new创建的注意事项：

    new创建类对象需要指针接收，一处初始化，多处使用
    new创建类对象使用完需delete销毁
    new创建对象直接使用堆空间，而局部不用new定义类对象则使用栈空间
    new对象指针用途广泛，比如作为函数返回值、函数参数等

    频繁调用场合并不适合new，就像new申请和释放内存一样

下面举一个简单的例子进行解释：

首先创建一个类，如下：

    class Coordinate
    {
    public:
        int m_iX;
        int m_iY;
    };

下面创建一个实例的对象：
（原文链接：https://blog.csdn.net/sun980984305/article/details/52959893
）

void main()
{
   Coordinate coord[3]; //栈上
   coord[1].m_iX=10;
   Coordinate *p=new Coordinate[3]; //堆中
   p[0].m_iX=10;  
   //对于定义一个类指针的方法： A *p = new A; p->成员函数； p->成员变量;
   // 或者 p.成员函数； p.成员变量；
   p->m_iX=10;// 调用成员函数
   delete []p;
   p=NULL;
}

在栈上实例化一个对象数组

Coordinate coord[3]，类名+数组的名称+数组的大小，创建完成后每一个数组元素都可以访问各自的成员，例如用coord[1]来访问数组的第二个元素，后面接点号来访问数据成员，形如coord[1].m_iX=10。这里使用完后内存是自动销毁的。
在堆中实例化一个对象数组

Coordinate *p=new Coordinate[3]，用一个指针指向一段内存，开辟内存用new运算符，这里数组大小为3，则创建时会调用三次构造函数。创建完成后每一个数组元素都可以访问各自的成员，例如p[0].m_iX=10是通过指针接一个索引再加点号和数据成员访问的，也可以通过p->m_iX=10来进行赋值。在这里使用完后，必须要通过delete来销毁这个对象数组，由于是一个对象数组，所以在销毁的时候是调用了多次析构函数的。
证明构造函数和析构函数被多次调用具体程序实例：
如图所示：
在这里插入图片描述

Coordinate.h
    #ifndef  COORDIANTE
    #define  COORDIANTE
    class Coordinate
    {
    public:
        Coordinate();//构造函数
        ~Coordinate();//析构函数
    };
    #endif

Coordinate.cpp
#include<iostream>
#include"Coordinate.h"
using namespace std;
 
Coordinate::Coordinate()
{
   cout<<"Coordinate()"<<endl;
}
 
Coordinate::~Coordinate()
{
    cout<<"~Coordinate()"<<endl;
}

mian.cpp

#include<iostream>
#include "Coordinate.h"
using namespace std;
 
void main()
{
    Coordinate coor[3];//隐式创建
    Coordinate *p=new Coordinate[3];//显式new创建     创建时会调用三次构造函数
    delete []p;//销毁的时候是调用了多次析构函数
    p=NULL;
    system("pause");
}

程序执行的结果：
在这里插入图片描述
感谢博主：sun980984305
————————————————
版权声明：本文为CSDN博主「Lu_gl」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Lu_gl/article/details/105114726