c++类与对象（二）类的六大默认成员函数及其日期类实现

mastercoder--

已于 2023-11-29 15:34:36 修改

阅读量1k

点赞数 24

文章标签： c++ 开发语言

于 2023-11-29 15:25:49 首次发布

本文链接：https://blog.csdn.net/mastershooter/article/details/134642376

版权

本章我们来学习六个默认成员函数，随后通过学习的内容来模拟实现一个日期类。

六个默认成员函数

如果一个类中什么成员都没有，简称为空类。

class Date{};//空类

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员

函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数

概念：构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个函数成员都有一个合适的初始值，并且在对象的整个生命周期内只调用一次

在以下的Date类里就写好了构造函数，代码如下：

class Date {
public:
    //1.无参的构造函数
    Date() {

    }
    //2.带参数的构造函数
    Date(int year, int month, int day) {
        _year = year;
        _month = month;
        _day = day;
    }
    //3.自定义带参的构造函数(与1会冲突，只能二选一)
    Date(int year = 0, int month = 1, int day = 1) {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};


int main() {
    Date d1;//调用1/3的默认构造函数
    Date d2(2015, 1, 1);//已经输入了参数，则会调用2的构造函数
}

特性：由上述代码可得构造函数的主要任务是初始化对象

1.函数名与类名相同

2.无返回值（注意，是真的无返回值，并不是平常所指的void类型）

3.对象实例化时编译器会自动调用相应的构造函数，例如输入参数则会调用带参构造函数

4.构造函数可以重载

需要注意的是，如果通过无参构造函数创建对象时，对象后面不需要括号，不然就变成了函数声明

因为是默认成员函数，所以即使不写也会自动调用默认的函数

再看看以下代码：

class Date {
public:
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};


int main() {
    Date d1;
    d1.Print();
    return 0;
}

运行结果：

有同学可能会好奇，不写构造函数时，编译器生成的默认构造函数初始化的值还是为随机值，貌似没什么用？

编译器自动生成的构造函数机制：
1、编译器自动生成的构造函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

总结一下：虽然在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数。

析构函数

概念：析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象的销毁工作是由编译器完成的，而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

就好比，创建了对象d1，当d1销毁时，d1的所有局部变量都会随着d1的销毁而销毁，但是此时还没用到析构函数，一旦d1内有动态开辟的空间，那么d1销毁时，这些空间并不会跟着一起销毁，这时候析构函数的作用就体现出来了。

特性：

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

class Date
{
public:
	Date()// 构造函数
	{}
	~Date()// 析构函数
	{}
private:
	int _year;
	int _month;
	int _day;
};

2.无参数无返回值类型。

3.一个类只能有一个析构函数。若没有显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

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

在c语言中，我们会经常开辟空间，但是老是会忘记释放，这时候析构函数的作用就体现出来了。

在构造函数和析构函数之中：

因为对象是定义在函数中，而函数调用会建立栈帧，所以对象的构造和析构也要符合先后顺序。

拷贝构造函数

概念：在创建对象中，时常会创建一个与已存在的对象一样的新对象，所以就有了拷贝构造函数：只有单个形参，该形参是由本类类型对象的引用（一般不会对已有变量进行修改，所以常用const修饰）：在用已存在的类类型对象创建新对象时由编译器自动调用。

class Date {
public:
     Date(int year , int month , int day ) {//构造函数
        _year = year;
        _month = month;
        _day = day;
    }
     Date(const Date& d)// 拷贝构造函数
     {
         _year = d._year;
         _month = d._month;
         _day = d._day;
     }
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};


int main() {
    Date d1(2023,11,27);//调用1/3的默认构造函数
    Date d2(d1);//用已经存在的对象d1创建新对象d2
    d1.Print();
    d2.Print();
    return 0;
}

特性：

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

2.拷贝构造函数的参数只有一个，且必须是类类型对象的引用，使用传值方式编译器会报错，因为会引发无穷递归调用（无限调用拷贝构造函数）

要调用拷贝构造函数就需要先传参，若传参使用传值传参，那么在传参过程中又需要进行对象的拷贝构造，如此循环往复，最终引发无穷递归调用。

一般在自定义类型的对象进行函数传参时，一般推荐使用引用传参。使用传值传参也可以，但每次传参时都会调用拷贝构造函数。

3.若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象会按内存存储按字节序完成拷贝，这种拷贝也叫做浅拷贝（值拷贝）

#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)// 构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 5, 30);
	Date d2(d1); // 用已存在的对象d1创建对象d2
	d1.Print();
	d2.Print();
	return 0;
}

运行结果如下：

这里说说浅拷贝：浅拷贝只是单纯的将表面的值给复制过去，一旦我们浅拷贝的是栈空间地址或者别的地址，这样的话就会出大问题

例如我们创建了stack1，然后用stack1拷贝构造了stack2，这时stack1 2 都指向同一个空间，假如我们销毁了stack1（或者析构），那么此时stack2也会收到影响，因为一块空间不能析构两次，会导致程序崩溃。

所以在Date类可以使用浅拷贝，一旦在类似于stack类的时候，就不能使用浅拷贝了。

赋值运算符重载函数

运算符重载

概念：C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，其目的就是让自定义类型可以像内置类型一样可以直接使用运算符进行操作。

d1 == d2;// 可读性高（书写简单）
IsSame(d1, d2);// 可读性差（书写麻烦）

运算符重载函数也具有自己的返回值类型，函数名字以及参数列表。其返回值类型和参数列表与普通函数类似。
运算符重载函数名为：关键字operator后面接需要重载的操作符符号。
函数原型：返回值 operator运算符(参数列表)

特性：

1.不能通过连接其他符号来创建新的操作符：比如operator@

2.重载操作符必须由一个类类型参数

3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

4.作为类成员函数重载时，其形参看起来比操作数数目少一个，因为成员函数的第一个参数为隐藏的this

5. * :: sizeof ?: 、以上5个运算符不能重载。（注意：经常会在笔试选择题中出现）

#include<iostream>
using namespace std;

class Date {
public:
     Date(int year = 0, int month = 1, int day = 1) {
        _year = year;
        _month = month;
        _day = day;
    }
     
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
    bool operator==(const Date& d) {//运算符重载函数
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d1(2023,11,27);//调用1/3的默认构造函数
    Date d2(2023,11,26);//用已经存在的对象d1创建新对象d2
    d1.Print();
    d2.Print();
    cout << (d1 == d2) << endl;
    return 0;
}

运行结果如下：

另外，也可以在类外面放置运算符重载函数，但是如果在类外的话就不能访问到类内的private的成员变量，这时候就需要将成员变量从private变成public或者变成友元函数。并且也没有了this指针，所以参数变成两个，从单一的d2变成d1与d2。

赋值符重载

1.参数类型：const T&，传递引用可以提高传参效率

赋值运算符重载函数的第一个形参默认是this指针，第二个形参是我们赋值运算符的右操作数。
由于是自定义类型传参，我们若是使用传值传参，会额外调用一次拷贝构造函数，所以函数的第二个参数最好使用引用传参（第一个参数是默认的this指针，我们管不了）。
其次，第二个参数，即赋值运算符的右操作数，我们在函数体内不会对其进行修改，所以最好加上const进行修饰。

2.返回值类型：T&,返回引用可以提高返回的效率，有返回值的目的是为了支持连续赋值

实际上，我们若是只以d2 = d1这种方式使用赋值运算符，赋值运算符重载函数就没必要有返回值，因为在函数体内已经通过this指针对d2进行了修改。但是为了支持连续赋值，即d3 = d2 = d1，我们就需要为函数设置一个返回值了，而且很明显，返回值应该是赋值运算符的左操作数，即this指针指向的对象。
和使用引用传参的道理一样，为了避免不必要的拷贝，我们最好还是使用引用返回，因为此时出了函数作用域this指针指向的对象并没有被销毁，所以可以使用引用返回。

3.检查是否自己给自己赋值

若是出现d1 = d1，我们不必进行赋值操作，因为自己赋值给自己是没有必要进行的。所以在进行赋值操作前可以先判断是否是给自己赋值，避免不必要的赋值操作。

4.返回*this

赋值操作进行完毕时，我们应该返回赋值运算符的左操作数，而在函数体内我们只能通过this指针访问到左操作数，所以要返回左操作数就只能返回*this。

这里以 = 为例子

#include<iostream>
using namespace std;

class Date {
public:
     Date(int year = 0, int month = 1, int day = 1) {
        _year = year;
        _month = month;
        _day = day;
    }
     
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
    bool operator==(const Date& d) {//运算符重载函数
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
    Date& operator=(const Date& d)//赋值运算符重载函数
    {
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }

        return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d1(2023,11,27);//调用1/3的默认构造函数
    Date d2;//用已经存在的对象d1创建新对象d2
    d1.Print();
    d2.Print();
    d2 = d1;
    d2.Print();
    return 0;
}

运行结果如下：

看看下面代码

	Date d1(2021, 6, 1);
	Date d2(d1);
	Date d3 = d1;

第三句话是拷贝构造函数还是赋值函数呢？

答案是：拷贝构造函数

因为赋值函数只允许两个已经存在的变量，而拷贝构造函数则是一个已经存在的变量去创建一个新的变量，而代码中的d3则是还未创建的。

const成员函数

我们将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰的是类成员函数隐含的this指针，表明在该成员函数中不能对this指针指向的对象进行修改。

例如，我们可以对类成员函数中的打印函数进行const修饰，避免在函数体内不小心修改了对象：

	void Print()const// cosnt修饰的打印函数
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

思考下面几个问题（经典面试题）：
1.const对象可以调用非const成员函数吗？
2.非const对象可以调用const成员函数吗？
3.const成员函数内可以调用其他的非const成员函数吗？
4.非cosnt成员函数内可以调用其他的cosnt成员函数吗？

答案是：不可以、可以、不可以、可以
解释如下：
1.非const成员函数，即成员函数的this指针没有被const所修饰，我们传入一个被const修饰的对象，用没有被const修饰的this指针进行接收，属于权限的放大，函数调用失败。
2.const成员函数，即成员函数的this指针被const所修饰，我们传入一个没有被const修饰的对象，用被const修饰的this指针进行接收，属于权限的缩小，函数调用成功。
3.在一个被const所修饰的成员函数中调用其他没有被const所修饰的成员函数，也就是将一个被const修饰的this指针的值赋值给一个没有被const修饰的this指针，属于权限的放大，函数调用失败。
4.在一个没有被const所修饰的成员函数中调用其他被const所修饰的成员函数，也就是将一个没有被const修饰的this指针的值赋值给一个被const修饰的this指针，属于权限的缩小，函数调用成功。

取地址及const取地址操作符重载

取地址操作符重载和const取地址操作符重载，这两个默认成员函数一般不用自己重新定义，使用编译器自动生成的就行了：

class Date
{
public:
	Date* operator&()// 取地址操作符重载
	{
		return this;
	}
	const Date* operator&()const// const取地址操作符重载
	{
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};

日期类实现

需要注意的是，当函数内部返回值在函数结束时没有被销毁的话，则可以使用引用返回，这样可以避免拷贝构造，当返回值在函数结束时被销毁的时候，就直接传值返回就好了。

这是基本的代码：

class Date {
public:
    Date(int year = 0, int month = 1, int day = 1);
    void Print()const;
    int getmonthday(int year, int month);
    bool operator==(const Date& d);
    bool operator!=(const Date& d);
    bool operator<(const Date& d);
    bool operator<=(const Date& d);
    bool operator>(const Date& d);
    bool operator>=(const Date& d);
    int operator-(const Date& d);//d1-d2
    Date& operator+=(int day);
    Date operator+(int day);
    Date& operator-=(int day);
    Date operator-(int day);
    Date& operator++();//++d1
    Date operator++(int);//d1++
    Date& operator--();//--d1
    Date operator--(int);//d1--
private:
    int _year;
    int _month;
    int _day;
};

此外，还需要用的一个获取该年该月所对应的日期函数getmonthday

int Date::getmonthday(int year, int month) {
    assert(month > 0 && month < 13);
    int montharray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400) == 0)) {
        return 29;
    }
    else
    {
        return montharray[month];
    }
}

还需要判断输入的月日是否符合标准

Date::Date(int year, int month, int day) {
    if (month > 0 && month < 13 && (day > 0 && day <= getmonthday(year, month))) {
        _year = year;
        _month = month;
        _day = day;
    }
    else
    {
        cout << "日期非法" << endl;
    }

}

日期+=天数

本质上等于 d1 = d1 + day，只改变自身的值

Date& Date::operator+=(int day) { 
    if (day < 0) {//当day为负数时，直接调用相反的函数
        *this -= -day;
        return *this;
    }
    _day += day;
    while (_day > getmonthday(_year, _month)) {
        _day -= getmonthday(_year, _month);
        _month++;
        if (_month == 13) {
            ++_year;
            _month = 1;
        }
    }
    return *this;
}

日期+天数

诸如d3 = d1+d2时需要有返回值，所以需要临时变量

Date Date::operator+(int day) {
    Date tmp(*this);
    tmp += day;
    return tmp;
}

日期-=天数

同+=重载函数类似

Date& Date::operator-=(int day) {
    if (day < 0) {
        *this += -day;
        return *this;
    }
    _day -= day;
    while (_day <= 0) {
        --_month;
        if (_month == 0) {
            --_year;
            _month = 12;
        }
        _day += getmonthday(_year, _month);
    }
    return *this;
}

日期-天数

同+重载函数类似

Date Date::operator-(int day) {
    Date tmp(*this);
    tmp -= day;
    return tmp;
}

需要注意到：前置++/--和后置++/--的重载函数都相同，区别是后置++/--需要写入int类型参数，但是此参数不需要具体传值，只是为了区分前置和后置的区别

++日期

这里直接复用+=就好了

Date& Date::operator++() {
    *this += 1;
    return *this;
}

日期++

后置++需要用到改变前的值，所以这里需要返回相加之前的原值，所以需要临时变量

Date Date::operator++(int) {
    Date tmp(*this);
    *this += 1;
    return tmp;
}

--日期

同前置++类似

Date& Date::operator--() {
    *this -= 1;
    return *this;
}

日期--

同后置++类似

Date Date::operator--(int) {
    Date tmp(*this);
    *this -= 1;
    return tmp;
}

==

只需要返回年月日都相同的结果就好了

bool Date::operator==(const Date& d) {
    return _year == d._year
        && _month == d._month
        && _day == d._day;
}

!=

这个很简单，直接判断==函数就好了

bool Date::operator!=(const Date& d)
{
    return !(*this == d);
}

>

先从年，再从月，最后从日进行比较

bool Date::operator>(const Date& d) 
{
    if (_year > d._year)
    {
        return true;
    }
    else if (_year == d._year)
    {
        if (_month > d._month)
        {
            return true;
        }
        else if (_month == d._month)
        {
            if (_day > d._day)
            {
                return true;
            }
        }
    }
    return false;
}

>=

直接返回 >函数与 ==函数相或的结果就好了

bool Date::operator>=(const Date& d) 
{
    return *this > d || *this == d;
}

<

直接复用>=的结果

bool Date::operator<(const Date& d) 
{
    return !(*this >= d);
}

<=

直接复用>的结果

bool Date::operator<=(const Date& d) 
{
    return !(*this > d);
}

日期-日期

int Date::operator-(const Date& d)
{
    Date max = *this;// 假设第一个日期较大
    Date min = d;// 假设第二个日期较小
    int flag = 1;// 此时结果应该为正值
    if (*this < d)
    {
        // 假设错误，更正
        max = d;
        min = *this;
        flag = -1;// 此时结果应该为负值
    }
    int n = 0;// 记录所加的总天数
    while (min != max)
    {
        ++min;// 较小的日期++
        ++n;// 总天数++
    }
    return n * flag;
}