类的默认成员函数

ゝ一世哀愁。 2022-06-08 05:54 325阅读 0赞

大家都知道，在类中有六个默认的成员函数，如下图：  
![这里写图片描述][SouthEast]  
今天就大概的介绍一下这几个成员函数

在说这些成员函数之前，先来介绍一个特殊的指针  
在每一个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，称为**this指针**。它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。

**一、构造函数**  
每个类都分别定义了它的对象被初始化的方式，类通过一个或几个特殊的成员函数来进行对象的初始化过程，这些函数就叫做**构造函数**  
构造函数的作用：  
1、构建函数  
2、初始化对象  
3、类型转换（当构造函数是单个参数时），禁止类型转换时加explicit关键字即可

构造函数是一个特殊的成员函数。没有返回类型，函数名与类名相同。创建类类型对象时，由编译器自动调用，在对象的生命周期内只且只调用一次。来看看具体示例：

class Date
    {
    public:
        Date()//参数列表、函数体为空的构造函数
        {}
        Date(int year, int month, int day)
        {
            _year = year;
            _month = month;
            _day = day;
        }
    private:
        int _year;
        int _month;
        int _day;
    };

除过上面例子中的初始化方式，构造函数也可以通过初始化列表来进行初始化  
**初始化列表**：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个数据 成员后面跟一个放在圆括号中的初始化式。如下:

Date(int year, int month, int day)
            :_year(year)
            , _month(month)
            , _day(day)
        {}

在使用初始化列表的时候要注意以下几点：

*  每个成员在初始化列表中只能出现一次
 *  初始化列表仅用于初始化类的数据成员，数据成员在类中的定义顺序就是在参数列表中的初始化顺序
 *  尽量避免使用成员初始化成员，成员的初始化顺序最好和定义顺序保持一致
    
    以下三种类型的成员必须在初始化列表初始化：  
    1、引用数据成员  
    2、const数据成员  
    3、类类型成员

构造函数的特性：  
\- 函数名和类名相同  
\- 没有返回值  
\- 新对象被创建时，由编译器自动调用，且在对象的生命中只调用一次  
\- 构造函数可以重载，实参决定了调用哪个构造函数  
\- 无参的构造函数和带有缺省值的构造函数都称为缺省构造函数，但是缺省的构造函数只能有一个  
\- 如果没有显示定义时，系统会给一个默认的构造函数  
编译器自动合成默认的构造函数的场景：A类及B类，在B类中有A类的对象，A类有一个缺省的构造函数。B类中没有构造函数，这个时候编译器就会给B类合成一个默认的构造函数。

**二、拷贝构造函数**  
只有单个形参，而且该形参是对本类类型对象的引用，常用const修饰，这样的函数称为**拷贝构造函数**

Date(const Date& d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        //初始化列表的形式
        Date(const Date& d)
            :_year(d._year)
            , _month(d._month)
            , _day(_day)
        {}

调用场景：  
1、用对象构建对象时

Date d1(2017, 9, 17);
        Date d2(d1);

2、传值方式作为函数的参数

void FunTest(const Date d)
    {}

3、传值方式作为函数返回值

Date FunTest()
    {
        Date d;
        return d;
    }

拷贝构造函数的特性：

*  拷贝构造是构造函数的重载
 *  拷贝构造的参数必须使用同类型对象的引用传递（防止一直创建临时对象，不断地调用拷贝构造，变成死循环）
 *  如果没有显示定义，系统会合成一个默认的拷贝构造函数

**三、析构函数**  
析构函数与构造函数的功能相反，在对象被销毁的时候，由编译器自动调用，完成类的一些资源清理和汕尾工作。  
给两个例子

~Date()//这是一个什么都不做的析构函数
        {}
    
    class Array
    {
    public:   
        Array(size_t capacity) :
            _capacity(capacity)       
        { 
            _pData = (int*)malloc(capacity*sizeof (int));                
            _size = 0; 
        }     
        ~Array()        
        { 
            if (NULL != _pData)  //释放开辟的空间              
            { 
                free(_pData);                        
                _pData = NULL;
            }               
            _size = 0;               
            _capacity = 0; 
        }
    private:        
        int* _pData;  
        size_t _size;    
        size_t _capacity;
    };

析构函数的特性：

*  析构函数的函数名是在类名（即构造函数函数名）前加上字符~
 *  析构函数无参数无返回值，所以不能被重载
 *  一个类有且只有一个析构函数，若无显示定义，系统会自动生成缺省的析构函数
 *  对象生命周期结束时，C++编译系统会自动调用析构函数
 *  析构函数体内并不是删除对象，而是做一些清理工作

**四、赋值操作符重载**  
说赋值操作符重载之前，先来说说操作符重载。  
重载操作符本质上是函数，名字由**operator**关键字后面接需要重载的操作符，具有返回值和形参列表，形参数目与操作符的操作数个数相同。如下：  
返回类型  operator  操作符（参数列表）  
来看个具体示例：

Date operator=(const Date d)
        {
            //具体实现过程
        }

注：不是所有的操作符都可以被重载，这里说几个不能被重载的操作符  
**.** 成员选择符  
**.\*** 成员对象选择符  
**::**域解析操作符  
**?:**条件操作符

使用操作符重载函数还需要注意以下几点：

1、不能通过连接其他符号来创建新的操作符

void operator @(){}//错误

2、重载操作符必须有一个类类型或枚举类型的操作数

int operator+(const int num1, const int num2)//报错
    {
        return (num1 + num2);
    }

3、用于内置类型的操作符，其含义不能改变  
4、作为类成员的重载函数，其形参看起来比操作数数目少1（成员函数的操作符有一个默认的形参this，限定为第一个形参）  
5、==和!=操作符一般要成对重载  
6、输入操作符>>和输出操作符<<必须定义为类的**友元函数**

**友元函数** :可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需加friend关键字。  
用输出操作符作为例子：

friend ostream& operator<<(ostream& _cout, const Date& d)

友元函数的特性：

*  可以访问类的私有成员，但不是类的成员函数
 *  不能用const修饰
 *  可以在类内的任何地方声明，不受类访问限定符的限制
 *  一个函数可以是多个类的友元函数
 *  友元函数的调用和普通函数的调用和原理相同