构造函数补充

知识点7【对象数组】

对象数组：本质是数组，每个元素为类的对象。

登录后复制

class Data
{
public:
    int a;
public:
    Data()
    {
        a = 0;
        cout<<"Data的无参构造a="<<a<<endl;
    }
    Data(int a1)
    {
        a = a1;
        cout<<"Data的有参构造a="<<a<<endl;
    }
    ~Data()
    {
        cout<<"Data的析构函数a="<<a<<endl;
    }
};
Data arr[5];//每个元素 调用无参构造

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.

对象数组中的每个元素 都要调用构造函数。

登录后复制

class Data
{
public:
    int a;
    int b;
public:
    Data()
    {
        a = 0;
        b=0;
        cout<<"Data的无参构造a="<<a<<" b="<<b<<endl;
    }
    Data(int a1,int b1)
    {
        a = a1;
        b = b1;
        cout<<"Data的有参构造a="<<a<<" b="<<b<<endl;
    }
    ~Data()
    {
        cout<<"Data的析构函数a="<<a<<" b="<<b<<endl;
    }
};
void test01()
{
    //如果需要初始化 对象数组(建议显示调用有参构造函数初始化)
    //Data arr[5]={10,20,30,40,50};//error
    Data arr[5]={Data(10,11),Data(20,21),Data(30,31),Data(40,41),Data(50,51)};
    cout<<arr[1].a<<" "<<arr[1].b<<endl;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.

知识点8【构造函数隐式转换】

如果类中的某个构造函数 只有一个参数 那么这个构造函数 容易发生 构造函数隐式转换。

如果想避免隐式转换 请使用explicit修饰该构造函数(防止 隐式转换)

登录后复制

class Data2
{
public:
    int a;
    int b;
public:
    Data2()
    {
        b = a=0;
        cout<<"Data2的无参构造a="<<a<<" b="<<b<<endl;
    }
    
    //explicit 防止只有一个参数的构造函数 隐式转换
    //explicit Data2(int a1)
    Data2(int a1)
    {
        b = a=a1;
        cout<<"Data2的有参构造a="<<a<<" b="<<b<<endl;
    }
};
void test02()
{
    //构造函数隐式转换
    Data2 ob1=10;//Data2 ob1(10)
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.

知识点9【new和delete】

new用于申请堆区空间(类似malloc calloc),delete释放堆区空间(类似free).

1、如果给基本类型 申请空间(new delete 和 malloc free没有区别)

登录后复制

void test01()
{
    //int *p = (int *)calloc(1,sizeof(int));
    //不用对new的返回值进行类型强转
    int *p = new int;
    *p = 100;
    cout<<"*p = "<<*p<<endl;

    //free(p)
    delete p;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

new申请空间的时候 可以初始化

登录后复制

void test01()
{
    //int *p = (int *)calloc(1,sizeof(int));
    //不用对new的返回值进行类型强转
    //new可以对申请的堆区空间 进行初始化10
    int *p = new int(10);
    cout<<"*p = "<<*p<<endl;

    //free(p)
    delete p;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

2、new和delete 申请 基本类型数组空间

登录后复制

void test02()
{
    //int *arr = (int *)calloc(5,sizeof(int));
    int *arr = new int[5];


    cout<<arr[0]<<" "<<arr[1]<<" "<<arr[2]<<" "<<arr[3]<<" "<<arr[4]<<endl;
    
    //如果new的时候有[] delete的时候必须有[] 否则只会释放第0个元素空间
    delete [] arr;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

登录后复制

void test02()
{
    //int *arr = (int *)calloc(5,sizeof(int));
    //{}的目的是初始化 堆区数组空间
    int *arr = new int[5]{10,20,30,40,50};

    cout<<arr[0]<<" "<<arr[1]<<" "<<arr[2]<<" "<<arr[3]<<" "<<arr[4]<<endl;

    //如果new的时候有[] delete的时候必须有[] 否则只会释放第0个元素空间
    delete [] arr;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.

3、new和delete申请对象空间

创建对象：申请空间--->调用构造函数

释放对象：调用析构函数--->释放空间

1、c语言的malloc、calloc以及free 特点

malloc、calloc只会申请空间 不会调用构造函数，free只会释放空间 不会调用析构函数(c++不建议使用)

登录后复制

void test03()
{
    Data *p = (Data *)calloc(1,sizeof(Data));
    cout<<"a = "<<p->a<<endl;
    free(p);
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

2、c++建议使用new和delete操作堆区空间的对象

new 能申请空间 并调用构造函数

delete 调用析构函数 并释放空间

4、new和delete申请对象数组空间

登录后复制

void test03()
{
    Data *arr = new Data[5]{Data(10),Data(20),Data(30),Data(40),Data(50)};

    int i=0;
    for(i=0;i<5;i++)
    {
        //cout<<arr[i].a<<" ";
        cout<<(arr+i)->a<<" ";
    }
    cout<<endl;

    delete [] arr;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.

注意：

登录后复制

void *p = new Data;
delete p;//无法调用Data析构函数

• 1.
• 2.