构造与析构（下）

c++中的对象组合：

C++ 中提供了 初始化列表 对成员变量进行初始化

语法规则

Constructor::Contructor():m1(v1), m2(v1,v2), m3(v3)

{

    //some other assignment operation

}

注意：

成员变量的初始化顺序与声明的顺序相关，与在初始化列表中的顺序无关；

初始化列表先于构造函数的函数体执行；

初始化列表的使用：

class Test
{
private:
    const int c;
    M m1;
    M m2;
public:
    Test() : c(1), m2(3), m1(2)
    {
        printf("Test()\n");
    }
    
    void print()
    {
        printf("c = %d, m1.mI = %d, m2.mI = %d\n", c, m1.getI(), m2.getI());
    }
};

类中的 const 成员是肯定会被分配空间的；

类中的 const 成员变量只是一个只读变量；

编译器无法直接得到const成员变量的初始值，因此无法进入符号表成为真正意义上的常量。

初始化与赋值不同

初始化是用已存在的对象或值对 正在创建的对象 进行初值设置；

赋值是用已存在的对象或值对 已经存在的对象 进行值设置；

区别：初始化：被初始化的对象正在创建

赋值：被赋值的对象已经存在

对象的销毁：

生活中存在的对象都是被初始化后才上市的；

生活中的对象被销毁前会做一些清理工作；

一般而言所有被销毁的对象都需要做清理

解决方案

为每个类都提供一个 public 的 destroy 函数

对象不再被需要时立即调用 destroy 函数进行清理

destroy 只是一个普通的函数，必须显示的调用

如果对象销毁前没有做清理，那么很可能造成资源泄漏

在构造函数中申请的资源，需要在对象销毁前释放

c++中的析构函数：

C++ 中的类可以定义一个特殊的成员函数清理对象

这个特殊的成员函数叫做析构函数

定义： ~ ClassName ()

析构函数没有参数也没有任何返回类型的声明

析构函数在对象销毁时自动被调用

Array类的优化：

#include <stdio.h>
#include "Array.h"
int main()
{
    Array a1(10); 
    for(int i=0; i<a1.length(); i++)
    {
        a1.setData(i, i);
    }  
    for(int i=0; i<a1.length(); i++)
    {
        printf("Element %d: %d\n", i, a1.getData(i));
    }  
    Array a2 = a1；    
    for(int i=0; i<a2.length(); i++)
    {
        printf("Element %d: %d\n", i, a2.getData(i));
    } 
    printf("Press any key to continue...");
    getchar();
    return 0;
}

构造与析构：

构造函数与析构函数的调用秩序

当类中有成员变量是其它类的对象时

首先调用成员变量的构造函数

调用顺序与声明顺序相同

之后调用自身类的构造函数

析构函数的调用秩序与对应的构造函数调用秩序相反

构造与析构的调用顺序：

#include <stdio.h>
class Test
{
private:
    int mI;
public:
    Test()
    {
        printf("Test()\n");
        mI = -1;
    }    
    Test(int i)
    {
        printf("Test(int i), i = %d\n", i);
        mI = i;
    }    
    Test(const Test& obj)
    {
        printf("Test(const Test& obj), i = %d\n", obj.mI);
        mI = obj.mI;
    }    
    ~Test()
    {
        printf("~Test(), i = %d\n", mI);
    }
};
void func(Test t)
{
    Test r(1);
}
void run()
{
    Test t(0);
    
    func(t);
}
int main()
{
    run();   
    printf("Press any key to continue...");
    getchar();
    return 0;
}

析构函数是C++中对象销毁时做清理工作的特殊函数

析构函数在对象销毁时自动被调用

析构函数是对象所使用的资源及时释放的保障

析构函数的调用秩序与构造函数相反

可以直接调用构造函数，直接调用构造函数将得到一个临时对象。

#include <stdio.h>
class Test
{
private:
    int mI;
    int mJ;
    const char* mS;
public:
    Test()
    {
        printf("Test()\n");
        
        mI = 0;
        mJ = 0;
    }   
    Test(const char* s)
    {
        printf("Test(const char* s)\n");       
       Test();     
        mS = s;
    }   
    ~Test()
    {
        printf("~Test()\n");
    }    
    void print()
    {
        printf("mI = %d, mJ = %d, mS = %s\n", mI, mJ, mS);
    }
};
void run()
{
    Test t = Test("Delphi Tang"); // Test t("Delphi Tang");    
    t.print();
}
int main()
{
    run();  
    printf("Press any key to continue...");
    getchar();
    return 0;
}