C++入门，类和对象（中）

yoouuung_

已于 2023-07-13 11:48:08 修改

阅读量138

点赞数 2

分类专栏： C++ 文章标签：数据结构算法 leetcode c++

于 2023-07-13 11:47:33 首次发布

本文链接：https://blog.csdn.net/jolly0514/article/details/131249286

版权

C++ 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

文章目录

1.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中并非什么都没有。任何类在什么都不写的时候，编译器会自动生成一下6个成员函数。这6个成员函数称作默认成员函数，用户没有显示实现，由编译器生成的成员函数。

2.构造函数

`2.1概念`

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

2.2特性

构造函数是特殊的成员函数，构造函数虽然名字叫做构造，但是构造函数的主要任务不是开空间创建对象，而是初始化对象。

其特征如下：

函数名与类名相同
无返回值
对象实例化时编译器自动调用对应的构造函数
构造函数可以重载
class Date
{
    public:
    //1.无参构造函数
    Date()
    {
    }
    
    //2.带参构造函数
    Date (int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    private:
        int _year;
        int _month;
        int _day;
}

void TestDate()
{
    Date d1; //调用无参构造函数  后面不要加括号，否则就成了函数声明
    Date d2(2023,6,16);  //调用有参构造函数
}
5.如果类中没有显示定义构造函数，c++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义，编译器不再生成。

6.关于编译器的默认成员函数，有时候对象初始化为一些随机值，看起来似乎没什么用，但是：C++把类型分为内置类型（基本类型）和自定义类型，内置类型就是语言提供的数据类型：int/char...，自定义类型就是我们使用class/struct/union自己定义的类型。内置类型不处理，可以在声明的时候给缺省值。自定义类型初始化为0.

7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造，全缺省构造函数，我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

3.析构函数

`3.1概念`

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

3.2 析构函数的特性

析构函数名是在类名前加上字符 ~
无参数，无返回值类型
一个类只能有一个析构函数。如果未显示定义，系统会自动生成默认的析构函数。析构函数不能重载
对象声明周期结束时，c++编译系统自动调用析构函数
如果类中没有申请资源，析构函数可以不写，直接使用编译器生成的默认析构函数；有资源申请时，一定要写，否则会造成资源泄露。

4.拷贝构造函数

4.1拷贝构造函数概念

创建对象时，创建一个与已经存在对象一模一样的新对象（ctrl c v)。拷贝构造函数：只有单个形参，该形参是对类类型对象的引用（一般使用const修饰，防止原对象被修改），在用已存在的类类型对象创建对象时由编译器自动调用。

4.2拷贝函数特性

拷贝构造函数是构造函数的一个重载形式
class Date()
{
    public:
        Date(int year,int month,int day)
        {
            _year = year;
            ...
        }
    
        //拷贝构造 
        //不允许传值构造
       // Date(Date d)  内置类型可以直接拷贝，因为编译器无法拷贝自定义类型，自定义类型拷贝需要调用拷贝构造，具体的见下方代码 栈的拷贝
    //所以按照传值传参，d1去调用拷贝构造，新出现的拷贝构造函数中的形参，又要去拷贝构造
        Date(Date& d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
    
    private:
        int _year;
        int _month;
        int _day;
};


//自定义类型 栈
stack :int* a ,capacity,size 如果按照浅拷贝（按字节拷贝） 会出现两个指针指向同一个空间
如果析构stack s1, s2就无法析构，因为同一块空间无法析构两次，会出现问题。
拷贝构造函数的参数只有一个，且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
若未显示定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按照内存存储字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝

注：类中如果没有涉及资源申请的时候，拷贝构造函数是否写都可以；一旦涉及到资源申请，拷贝构造函数一定要写，否则就是浅拷贝。

拷贝构造的典型使用场景：

      1.使用已存在对象创建新对象

      2.函数参数类型为类类型对象

      3.函数返回值类型为类类型对象

5.赋值运算符重载

5.1 运算符重载

c++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通函数类似

函数名字为:关键字operator后面接需要重载的运算符符号

函数原型：返回值类型 operator 操作符（参数列表）

不能通过连接其他符号来创建新的操作符，比如operator @
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变
作为类成员函数重载时，其形参看起来比操作数目少1，因为成员函数的第一个参数为隐藏的this
.* :: sizeof ?: .以上5个运算符不能重载

class Date
{
    public:
        Date(int year = 1900, int month = 1, int day = 1)
        {
            _year = year;
            _month = month;
            _day = day;
        }

        Date(const Date& d)
        {
            _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;
        }
    
       //左操作数d1 形参this 指向调用函数的对象 右操作数d2 使用引用
       bool operator==(const Date &d2)
       {
            return _year == d2._year && _month == d2._month && _day ==d2._day;

        private:
            int _year;
            int _month;
            int _day;
};

5.2赋值运算符重载

参数类型使用 const D& 传递引用可以提高传参的效率
返回值类型使用 T&，返回引用可以提高返回的效率，有返回值的目的是支持连续赋值
检测是否自己给自己赋值
返回*this,要符合连续赋值的含义

class Date
{
    pubilc:
        Date(int year = 2000, int mmonth = 1, int day = 1)
        {
            _year = year;
            _month = month;
            _day = day;
        }

        Date(const Date &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }

        // d1 = d2 d1为左操作数 this 
        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;
    };

赋值运算符只能重载类的成员函数，不能重载全局函数，因为重载成全局函数时候没有this指针，需要给两个参数。并且给两个参数也会编译失败，赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户在类外实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突，故赋值运算符重载只能是类的成员函数。

用户没有显示实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝（浅拷贝）。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。但是，如果类中涉及到资源管理，必须要自己实现赋值运算符重载，比如：栈，栈中需要开辟一个数组空间，如果以浅拷贝的方式，会指向同一块空间，那么在后续的增删查改以及析构都会出现问题。

5.3前置++和后置++重载

默认的实现为前置++，后置++需要去调用拷贝构造，所以后置++效率较慢，且++的时候使用形参来区分到底调用哪个，这里编译器默认传int类型的一个数值，不需要显示写入

//前置++ 返回+1之后的结果
//注意 this指向的对象函数结束后不会销毁，所以使用引用方式返回提高效率

Date& operator++()
{
    _day += 1;
    return _this;
}

//后置++
//C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
//后置++  返回+1之前的值，所以需要调用拷贝构造一个临时变量
//因为是临时变量 出了作用域被销毁 所以只能以值的方式返回 不能返回引用

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

6.实现一个日期类

Date.h:

#pragma once
#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1);
	void Print();
	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);
	Date& operator=(const Date& d);
	Date& operator+=(int day);
	Date operator+(int day);
	int operator-(const Date& d);   //两个日期相减
	Date& operator++();    //前置和后置++  默认是前置
	Date operator++(int); //后置
private:
	int _year;
	int _month;
	int _day;

};


Date.cpp:
//判断日期是否合法
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 = 1900,int month = 1,int day = 1)
{
    if(month >0 && month < 13
       && (day >0 && day<= GetMonthDat(_year,_month)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    else
        cout<<"false"<<endl;
}

bool Date::operator==(const Date& d)
{
	return this->_year == d._year &&
		this->_month == d._month &&
		this->_day == d._day;
}
bool  Date::operator<(const Date& d)
{
	if (_year < d._year)
		return true;
	else if (_year == d._year && _month < d._month)
		return true;
	else if (_year == d._year && _month == d._month && _day < d._day)
		return true;
	else
		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);
}
bool Date:: operator!=(const Date& d)
{
	return (*this == d);
}

Date& Date::operator=(const Date& d)
{
	//为了避免自己给自己赋值
	if (this != &d)  //取地址
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}


Date& Date:: operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month));
		_month++;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

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

Date& Date::operator++()
//前置和后置++  默认是前置
{
	*this += 1;
	return *this;
}

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

7.const成员函数

将const修饰的成员函数称为const成员函数，const修饰类成员函数，实际上是修饰该成员函数隐藏的this指针，表面在该成员函数中，不能对类的任何成员进行修改。

8.取地址及const取地址操作符函数

这两个默认成员函数一般不用重新定义，编译器会默认生成

Date * operator&()
{
    return this;
}

const Date * operator() const 
{
    return this;
}

总结

本文主要介绍了类中的6个默认成员函数，技术有限，如有错误请指正。

yoouuung_

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录