类的默认成员函数

类的6个默认成员函数

如果一个类中什么成员都没有 , 简称为空类 . 但空类中并不是什么都没有 , 而是会

自动生成6个默认成员函数 .

1 . 构造函数主要完成初始化工作 ;

2 . 析构函数主要完成清理工作 ;

3 . 拷贝构造是使用同类对象初始化创建对象 ;

4 . 赋值重载主要是把一个对象赋值给另一个对象 ; 

5 .                                                                    

 

类的6个默认成员函数

如果一个类中什么成员都没有 , 简称为空类 . 但空类中并不是什么都没有 , 而是会

自动生成6个默认成员函数 .

1 . 构造函数主要完成初始化工作 ;

2 . 析构函数主要完成清理工作 ;                                                                                      

3 . 拷贝构造是使用同类对象初始化创建对象 ;

4 . 赋值重载主要是把一个对象赋值给另一个对象 ; 

5 . 主要是普通对象和const对象取地址 .     

 

构造函数 :

构造函数是特殊的成员函数 , 构造函数的主要任务并不是开空间创建对象,而是初始化对象 .

   特征 :                                                                                                                                         

     1 . 函数名与类名相同 ;

     2 . 无返回值 ;

     3 . 对象实例化时编译器自动调用对应的构造函数 ; 

     4 . 构造函数可以重载 . 

 

创建对象时 , 编译器自动调用构造函数 , 不能显式调用 ;

如果没有显式定义构造 , 则编译器自动生成无参构造 ;

默认构造 : 只能有一个

                 无参构造 / 全缺省

如果有自定义成员 , 则构造函数会自动调用自定义成员的默认构造 .

#include<stdio.h>
#include<iostream>

using namespace std;

class A{
public:
    int _a;
    A(int a=10){
        _a = a;
        cout << "A()" << endl;
    }
};

class Date{
public:
    //无参的默认构造
    Date(){
        cout << "Date()" << endl;
    }

    //有参的构造函数
    Date(int year, int month, int day){
        _year = year;
        _month = month;
        _day = day;
        cout << "Date(int int int)" << endl;
    }

    //全缺省:也是默认构造
    /*Date(int year = 1, int month = 1, int day = 1){
        _year = year;
        _month = month;
        _day = day;
        cout << "Date(int int int)" << endl;
    }*/

private:
    int _year;
    int _month;
    int _day;

    //自定义类型成员
    A _a;
};


void test(){
    /*任何一个构造函数(包括编译器自动生成的)都会自动调用
        自定义成员的默认构造,如果没有默认构造,编译器会报错*/

    /*当前类的构造函数会自动调用自定义成员的默认构造;
    完成自定义成员的初始化;*/
    /*只能调用一个默认构造,*/
    Date d;

    Date d2(2021, 4, 23);

}

int main(){
    test();
    system("pause");
    return 0;
}

 

析构函数 : 

是一个特殊的成员函数.

    特征 :

     1.析构函数名是在类名的前面加上字符 ~  ;

     2.无参数无返回值 ;

     3.一个类有且只有一个析构函数 , 若未显式定义 , 系统会自动生成默认的析构函数 ;

     4.对象生命周期结束时 , C++编译系统自动调用析构函数 .  

如果当前对象中没有资源需要清理可以不写析构函数

#include<stdio.h>
#include<iostream>

using namespace std;

typedef int DataType;

class SeqList{
public:
    SeqList(int capacity = 10){
        _pData = (DataType*)malloc(capacity*sizeof(DataType));

        _size = 0;
        _capacity = capacity;
        cout << "malloc" << endl;
    }

    ~SeqList(){
        if (_pData){
            free(_pData);
            _pData = NULL;
            _size = 0;
            _capacity = 0;
        }
        cout << "~SeqList" << endl;
    }


    int* _pData;
    size_t _size;
    size_t _capacity;

};


void test(){
    SeqList sq(10);
    cout << sizeof(sq) << endl;
}

int main(){
    test();
    system("pause");
    return 0;
}

 

拷贝构造函数 :

用已存在的类型对象创建新对象时由编译器自动调试 , 只有单个形参 , 该形参是对本类类型对象的引用(一般常用const修饰) .

编译器自动生成的拷贝构造 : 完成对象内容的拷贝 , 或者称为字节序的拷贝 , 这种情况我们称为浅拷贝(不会拷贝对象的资源) .

有资源的类 , 必须显示定义拷贝构造 ;  

      特征 : 

      1.拷贝构造函数是构造函数的一个重载形式 ;

      2.拷贝构造函数的参数只有一个且必须使用 引用 传参 , 使用值传参会引发无穷递归调用 .       

#include<stdio.h>
#include<iostream>

using namespace std;

class data{
public:
    data(int year = 1, int month = 1, int day = 1){
        _year = year;
        _month = month;
        _day = day;
        cout << "data(int int int)" << endl;
    }

    //如果不显式定义拷贝构造,编译器会自动生成
    data(const data& d){
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

private:
    int _year;
    int _month;
    int _day;
};
void test(){
    data d(2021, 4, 23);
    data copy(d);
}

int main(){ 
    test();
    system("pause");
    return 0;
}