第10节 构造与析构 - 下

-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删.

第一:

C++ 中的对象组合

C++ 中的类可以使用其它类定义成员变量

class M
{
private:
    int mI;
public:
    M(int i)
    {
        printf("M(int i), i = %d\n", i);
        mI = i;
    }
    
    int getI()
    {
        return mI;
    }
};

class Test
{
private:
    const int c;
    M m1;
    M m2;
public:
    //对成员变量进行初始化
    Test() : c(1), m2(3), m1(2)
    {
        printf("Test()\n");
    }
    
};


int main()
{    
    Test t1;
    Test t2 = Test();
    
    return 0;
}

 

 C++ 中提供了 初始化列表 对成员变量进行初始化
  语法规则
Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
{
     // some other assignment operation
}

注意：
 成员变量的初始化顺序与声明的顺序相关，与在初始化列表中的顺序无关
初始化列表先于构造函数的函数体执行

#include <stdio.h>

class M
{
private:
    int mI;
public:
    M(int i)
    {
        printf("M(int i), i = %d\n", i);
        mI = i;
    }
    
    int getI()
    {
        return mI;
    }
};

class Test
{
private:
    //成员变量声明顺序
    const int c;//初始化时编译器得不到c的值,则c是只读变量
    M m1;
    M m2;
public:
    //const变量可以被初始化,但是不能被赋值
    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());
    }
};

void run()
{
    Test t1;
    
    t1.print();
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    
    return 0;
}

第二：

小插曲

 类中的const 成员是肯定会被分配空间的
 类中的const 成员变量只是一个只读变量

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

 

  初始化与赋值不同
  初始化是用已存在的对象或值对 正在创建的对象 进行初值设置
  赋值是用已存在的对象或值对 已经存在的对象 进行值设置

区别：
 初始化：被初始化的对象正在创建
 赋值：被赋值的对象已经存在

 

第三：

对象的销毁

  生活中存在的对象都是被初始化后才上市的
  生活中的对象被销毁前会做一些清理工作

  一般而言所有被销毁的对象都需要做清理
  解决方案
     为每个类都提供一个 public 的 destroy 函数
     对象不再被需要时立即调用 destroy函数进行清理

  destroy 只是一个普通的函数，必须显示的调用
  如果对象销毁前没有做清理，那么很可能造成资源泄漏
     在构造函数中申请的资源，需要在对象销毁前释放

 

第四:

C++ 中的析构函数

 C++ 中的类可以定义一个特殊的成员函数清理对象
  这个特殊的成员函数叫做析构函数
     定义：~ClassName()
  析构函数没有参数也没有任何返回类型的声明
  析构函数在对象销毁时自动被调用

#include <stdio.h>

class Test
{
private:
    int mI;
public:
    Test(int i) : mI(i)
    {
        printf("Test(), mI = %d\n", mI);
    }
    
    ~Test()//析构函数
    {
        printf("~Test(), mI = %d\n", mI);
    }
};

void run()
{
    //自动调用构造函数
    Test t1(1);
    Test t2(2);

    //自动调用析构函数
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    
    return 0;
}

 

第五:

Array 类的进化

#ifndef _ARRAY_H_
#define _ARRAY_H_

class Array
{
private:
    int mLength;
    int* mSpace;

public:
    Array(int length);
    Array(const Array& obj);
    int length();
    void setData(int index, int value);
    int getData(int index);
    ~Array();//改成析构函数
};

#endif

#include "Array.h"

Array::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    
    mLength = length;
    mSpace = new int[mLength];
}

Array::Array(const Array& obj)
{
    mLength = obj.mLength;
    
    mSpace = new int[mLength];
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

int Array::length()
{
    return mLength;
}

void Array::setData(int index, int value)
{
    mSpace[index] = value;
}

int Array::getData(int index)
{
    return mSpace[index];
}

Array::~Array()//修改成析构函数
{
    mLength = -1;
    delete[] mSpace;
}

 

#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));
    }

   // a1.destory();
   // a2.destory();
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

 

第六:

构造与析构

  构造函数与析构函数的调用秩序
        当类中有成员变量是其它类的对象时
              首先调用成员变量的构造函数
                    调用顺序与声明顺序相同
              之后调用自身类的构造函数
         析构函数的调用秩序与对应的构造函数调用秩序相反

 

第七:

构造与析构的调用秩序

#include <stdio.h>

class Test//定义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);// Test(int i)
}

void run()
{
    Test t(0);// Test(int i)
    
    func(t);//func(Test t)  实参初始化形参 -->  Test(const Test& obj)
}

int main()
{
    run();
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

 

第八:

可以直接调用构造函数吗？
如果可以，直接调用构造函数会有什么情况发生呢？

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

不要在构造函数里面调用构造函数!!!

#include <stdio.h>

class Test
{
private:
    int mI;
    int mJ;
    const char* mS;//字符指针
public:
    //构造函数
    Test()
    {
        printf("Test()\n");
        //将mI mJ 赋值为0
        mI = 0;
        mJ = 0;
    }
    
    //构造函数
    Test(const char* s)
    {
        printf("Test(const char* s)\n");
        
        //直接调用构造函数，直接调用构造函数将得到一个临时对象,这一行执行完后临时对象立即被销毁,mI mJ 不会赋值为0
        Test();//调用上面的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;
}

小结

  析构函数是 C++ 中对象销毁时做清理工作的特殊函数
  析构函数在对象销毁时自动被调用
  析构函数是对象所使用的资源及时释放的保障
  析构函数的调用秩序与构造函数相反