C++创建对象的几种方式

[toc]

一、创建对象的方式

1.1 使用非默认构造函数来创建对象的几种形式

1.1.1 显式调用：方式1

Person person = Person("binny1", 26);

这种方式创建对象，C++标准允许编译器使用两种方式来执行：

1、会创建一个临时对象，然后将临时对象复制到person中，并丢弃临时对象。此时，将为临时对象调用析构函数，正如上面的结果。

编译器肯能立即删除临时对象，也可能过一会儿。

1.1.2 隐式调用：方式2

Person person2("binny2", 27);//会创建临时对象

这种格式更紧凑，它与显示调用等价。

1.1.3 构造函数与new关键字一起使用：方式3

Person *pPerson3 = new Person("binny3", 8);//不会创建临时对象

这条语句创建一个Person对象，将其初始化为参数列表提供的值，并将该对象的地址赋给pPerson指针。

这种情况下对象没有名字，但可以使用指针来管理对象。

1.1.4 列表初始化

如果编译器支持C++11，则可以用时列表初始化。只要提供的大括号列表中的数据与某个构造函数的参数列表匹配就可以。

方式4

Person person4 = {"binny4", 26};//c++11，会创建临时对象

方式5

Person person5{"binny5", 26};//c++11，会创建临时对象

方式6

Person *pPerson6 = new Person{"binny6", 26};//c++11，不会创建临时对象

方式6

Person person{};//与默认构造函数相匹配

1.2 使用默认构造函数来创建对象

1.2.1 显示调用

方式7

Person person = Person();

1.2.2 隐式调用

方式8

Person person;

隐式调用默认构造函数，不要使用圆括号。

拷贝构造函数

当用一个对象去生成(初始化)另一个对象时，编译器并不是调用普通的构造函数生成该对象，而是以位拷贝的方式生成该对象。

X a ;//默认构造函数
X b = a;//拷贝构造函数

二 案例源码

2.1 头文件

//
// Created by Biter on 2019/10/16.
//
#include <iostream>

#ifndef NDK_PERSON_H
#define NDK_PERSON_H

using namespace std;

class Person {

private:
    char *mName;
    int mAge;
public:
    Person();

    Person(int age);

    Person(char *name, int age);

    void setName(char *name);

    void setAge(int age);

    char * getName();

    int getAge();

    ~Person();
};

#endif //NDK_PERSON_H

2.2 头文件的实现

//
// Created by Biter on 2019/10/16.
//

#include "../includes/Person.h"

Person::Person() {
    mName = "biter";
    mAge = 26;
    std::cout<<"默认构造函数"<<std::endl;
}

Person::Person(char *name, int age) {
    mName = name;
    mAge = age;
    cout << "Hello  " << mName << endl;
}

Person::Person(int age) {
    mAge = age;
}

void Person::setName(char *name) {
    mName = name;
}

void Person::setAge(int age) {
    mAge = age;
}

int Person::getAge() {
    return mAge;
}

char *Person::getName() {
    return mName;
}

Person::~Person() {
    cout << "Bey  " << mName << endl;
}```
## 2.3 项目代码

```c
//
// Created by Biter on 2019/10/15.
//
#include <iostream>
#include "includes/Person.h"

int main() {
   Person person0;//补充的
    //第一种创建对象的方式
    Person person1 = Person("binny1,显示调用构造函数", 26);
//    //第二种创建对象的方式
    Person person2("binny2，隐式调用构造函数", 27);
//    //第三种创建对象的方式
    Person *pPerson3 = new Person("binny3，动态创建对象", 8);

    //c++11 列表初始化
    Person person4 = {"binny4，显示列表初始化", 26};
    Person person5{"binny5，隐式列表初始化", 26};
    Person *pPerson6 = new Person{"binny6，动态列表初始化", 26};

    std::cout << "person1 name = " << person1.getName() << std::endl;
    std::cout << "person2 name = " << person2.getName() << std::endl;
    std::cout << "person3 name = " << pPerson3->getName() << std::endl;
    std::cout << "person4 name = " << person4.getName() << std::endl;
    std::cout << "person5 name = " << person5.getName() << std::endl;
    std::cout << "person6 name = " << pPerson6->getName() << std::endl;

    Person person7 = 26;
    person7.setName("p9");
    std::cout << "p9.getAge() = " << person7.getAge() << std::endl;
    return 0;
}

运行结果

可以看到，一个像套娃一样的方式，先创建的后析构。

image.png

C++提供了多种对象的创建方式，每次创建对象时(包括使用new动态分配内存)，C++都是用类的构造函数。

从运行结果看出，动态创建对象的时候，没有调用析构函数。