构造函数析构函数

一个没有实例化的空类，编译器是不会给它生成任何函数的，当实例化一个空类后，编译器会根据需要生成相应的函数

1) 默认构造函数
2) 拷贝构造函数
3) 析构函数
4) 赋值构造函数
5) 取地址运算符函数

class empty
{
public:
    empty(){};
    ~empty(){};
    empty(const empty&){};
    empty& operator=(const empty&){return *this;};
    empty* operator&(){return this;};
    const empty* operator&()const{return this;};
};
View Code

 

构造函数
    1) 构造函数不能有返回值
    2) 缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都初始化为零或空
    3) 创建一个对象时，系统自动调用构造函数

析构函数
    1) 析构函数没有参数，也没有返回值。不能重载，也就是说，一个类中只可能定义一个析构函数

拷贝构造函数
    1) 拷贝构造函数实际上也是构造函数，具有一般构造函数的所有特性，其名字也与所属类名相同。拷贝构造函数中只有一个参数，这个参数是对某个同类对象的引用。调用条件：
        a. 用类的一个已知的对象去初始化该类的另一个对象时；
        b. 函数的形参是类的对象，调用函数进行形参和实参的结合时；
        c. 函数的返回值是类的对象，函数执行完返回调用者。
    2) 如果一个类中没有定义析构函数，系统也会自动生成一个默认的析构函数，为空函数，什么都不做。调用条件：
       a. 在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用
       b.用new运算符动态构建的对象，在使用delete运算符释放它

#include <iostream>
#include <string.h>
using namespace std;

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    A(const A& a)
    {
        n = new int[10];
        memcpy(n, a.n, 10);  //通过按字节拷贝，将堆中一块内存存储到另一块内存
        cout<<"copy constructor is called\n";
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A b = *a;
    delete a;

    b.get();

    return 0;
}
View Code

 赋值构造函数
    1) 将一个参数对象中私有成员赋给一个已经在内存中占据内存的对象的私有成员，赋值构造函数被赋值的对象必须已经在内存中，否则调用的将是拷贝构造函数，当然赋值构造函数也有深拷贝和浅拷贝的问题。当然赋值构造函数必须能够处理自我赋值的问题，因为自我赋值会出现指针指向一个已经释放的内存。还有赋值构造函数必须注意它的函数原型，参数必须是引用类型，返回值也必须是引用类型，否则在传参和返回的时候都会再次调用一次拷贝构造函数

#include <iostream>
#include <string.h>
using namespace std;

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    A(const A& a) //拷贝构造函数的参数一定是引用，不能不是引用，不然会出现无限递归
    {
        n = new int[10];
        memcpy(n, a.n, 10);  //通过按字节拷贝，将堆中一块内存存储到另一块内存
        cout<<"copy constructor is called\n";
    }

    A operator=(const A a)   //传参和返回值设置错误
    {
        if(this == &a)
            return *this;
        if(n != NULL)
        {
            delete n;
            n == NULL;
        }

        n = new int[10];
        memcpy(n, a.n, 10);
        cout<<"assign constructor is called\n";
        return *this;
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A* b =  new A();

    *b = *a;

    delete a;

    b->get();

    while(1)
    {}

    return 0;
}View Code
View Code

构造函数与析构函数的调用顺序
    1) 对象是由“底层向上”开始构造的，当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。因为，构造函数一开始构造时，总是要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时，如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。
    2) 对象成员也遵从先构造后析构的顺序

posted on 2014-10-22 11:37  kangbry  阅读(255)  评论(0)  编辑  收藏  举报

导航