【类和对象】构造函数、析构函数、运算符重载、日期类实现

已于 2022-03-06 16:28:32 修改
阅读量199 收藏 1
点赞数 7
分类专栏： C++ 文章标签： c++ 开发语言 后端
于 2022-02-19 20:02:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57018588/article/details/122978615
版权

目录


秃头侠们好呀，今天咱们继续来聊聊 类和对象

本章重点

  1. 类的6个默认成员函数
  2. 构造函数
  3. 析构函数
  4. 拷贝构造函数
  5. 赋值操作符重载
  6. 默认拷贝构造与赋值运算符重载的问题
  7. const成员函数
  8. 取地址及const取地址操作符重载

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数

在这里插入图片描述

构造函数

class Date
{
public:
	void SetDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1, d2;
	d1.SetDate(2018, 5, 1);
	d1.Display();
	Date d2;
	d2.SetDate(2018, 7, 1);
	d2.Display();
	return 0;
}

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

特性

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

其特征如下：

  1. 函数名与类名相同
  2. 无返回值
  3. 对象实例化时编译器自动调用对应的构造函数
  4. 构造函数可以重载
class Date
{
public:
	// 1.无参构造函数
	Date()
	{
	    _year=1;
	    _month=1;
	    _day=1;
	}
	// 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(2015, 1, 1); // 调用带参的构造函数
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3();
}
  1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
class Date
{
public:
	/*
	// 如果用户显式定义了构造函数，编译器将不再生成
	Date (int year, int month, int day)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	*/
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	Date d;
}
  1. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
// 默认构造函数
class Date
{
public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{
	Date d1;
}

解答：
语法上，无参和全缺省可同时存在，但如果存在无参调用，会存在二义性。
这里推荐实现全缺省或半缺省，因为比较好用，想传参就传，不想就用缺省的。

  1. C++把类型分为两类：内置类型（int/char/double），自定义类型（struct/class/union）
    我们不写编译器默认生成的构造函数，对于内置类型不做初始化处理，对于自定义类型会去调用它的默认构造函数（不用参数就可以调的）
class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}

析构函数

概念

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

特性

析构函数是特殊的成员函数
其特征如下：

  1. 析构函数名是在类名前加上字符 ~
  2. 无参数无返回值
  3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
typedef int DataType;
class SeqList
{
public:
	SeqList(int capacity = 10)
	{
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
	~SeqList()
	{
		if (_pData)
		{
			free(_pData); // 释放堆上的空间
			_pData = NULL; // 将指针置为空
			_capacity = 0;
			_size = 0;
		}
	}
private:
	int* _pData;
	size_t _size;
	size_t _capacity;
};
  1. 编译器生成的默认析构函数，与构造函数相似，对内置类型成员变量不管，对自定类型成员调用它的析构函数。

拷贝构造函数

概念

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

特征

拷贝构造函数也是特殊的成员函数，其特征如下：

  1. 拷贝构造函数是构造函数的一个重载形式
  2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
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;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

在这里插入图片描述
3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝
1、对内置类型，完成按字节序的浅拷贝
2、对自定义类型成员会去调用它的拷贝构造

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	// 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
	Date d2(d1);
	return 0;
}

4.那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？

class String
{
public:
	String(const char* str = "jack")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
	}
private:
	char* _str;
};
int main()
{
	String s1("hello");
	String s2(s1);
}

这里会发现下面的程序会崩溃掉，因为当我们自己不写拷贝构造的时候，编译器会自动生成默认拷贝构造，而默认的拷贝构造是浅拷贝，对于日期类的这种可以使用浅拷贝，但是对于上述代码这种，使用浅拷贝的时候是直接全部拷贝，s1和s2的_str地址是相同的，指向同一块堆上的空间，生命周期结束的时候会先把s2 free，然后s1又要free，但是不能释放同一块空间两次，所以崩溃。

赋值运算符重载

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

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

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

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@
  • 重载操作符必须有一个类类型或者枚举类型的操作数
  • 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
  • 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参
  • .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。
#define _CRT_SECURE_NO_WARNINGS 1
// 全局的operator==
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year;
	&& d1._month == d2._month
		&& d1._day == d2._day;
}
void Test()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl;
}

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// bool operator==(Date* this, const Date& d2)
	// 这里需要注意的是，左操作数是this指向的调用函数的对象
	bool operator==(const Date& d2)
	{
		return _year == d2._year;
		&& _month == d2._month
			&& _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl;
}

赋值运算符重载

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;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};

赋值运算符需要注意：

  1. 参数类型
  2. 返回值
  3. 检测是否自己给自己赋值
  4. 返回*this
  5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝

赋值拷贝和拷贝构造类似，对于内置类型会完成字节序值拷贝（浅拷贝），对于自定义类型，会调用它的赋值拷贝函数。对于日期类的可以用默认生成的，但对于像动态分配的问题，跟拷贝构造一样需要自己去实现深赋值拷贝。

Date d1(2000,8,8);
Date d2=d1;//这样属于拷贝构造，d2是要被初始化的，不是原先存在的

Date d3(2001,5,27);
d3=d2;//这样属于赋值拷贝，是两个已存在的对象之间的赋值

日期类实现

日期类实现源码

const成员

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
在这里插入图片描述

class Date
{
public:
	void Display()
	{
		cout << "Display ()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
	void Display() const
	{
		cout << "Display () const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
void Test()
{
	Date d1;
	d1.Display();
	const Date d2;
	d2.Display();
}

1、const对象只能调用const成员函数、不能调用非const成员函数；
2、非const对象可以调用const成员函数。

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

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

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况才需要重载，比如想让别人获取到指定的内容。

⭐感谢阅读，我们下期再见
如有错 欢迎提出一起交流

周周汪
关注
  • 7
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
c++ 中. 和 ->，波浪号 ~ 符号怎么用
ditigao0965的博客
04-12 1957
1、 用在类中的析构函数之前，表示该函数是析构函数。如类A的析构函数 classA { //... ~A(){}//析构函数 }; 2、 用于数字或者整形变量之前，表示对该数取反操作，其规则是~0=1, ~1=0, 如二进制0101 0101取反后就是1010 1010 C++之类的析构函数 简单说说类的析构函数，它是类的一个成员函数，名字由波...
【类和对象】——构造函数与析构函数
qq_43412060的博客
03-24 428
1、深入理解构造函数和析构函数 1.1 构造函数 1.2 析构函数 1.3 其他特性 1.4构造函数和析构函数的区别 2、构造函数的初始化列表 2.1 实现一个商品类 2.2 构造函数的初始化列表和当前类类型构造函数体的区别 2.3 构造函数的初始化列表练习 3、不同对象的生命周期
[C++] 类与对象（中）6大默认成员函数：构造、析构、拷贝构造、赋值操作符重载、const修饰符等
giturtle's blog
06-27 308
类与对象思维导图1. 构造函数2. 析构函数3. 拷贝构造函数4. 赋值运算符重载函数5. 普通对象取地址重载函数6. const对象度地址重载函数 思维导图 1. 构造函数 对于Date类，可以通过SetDate()公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？ 构造函数是一个特殊的成员函数，名字与类名相同,创建类...
C#类
孤夜的博客
03-21 2129
一:类 前言: 对于类的理解这个太熟悉不过了，从入门的第一个程序HelloWord，中第一句代码就是[访问权限] Class 类名{…},可以看出类无处不在，如果把项目比作房子，那么类可以说就是这个房子的每一块砖瓦，而程序员就是这个添砖JAVA的人(搬砖，搬砖)，类是自己定义数据类型的蓝图，规定该类对象执行什么操作，存放什么数据类型,所以它十分重要，犹如你的内裤一般，所以请不要随便偷看别人的内...
关于C++的类详细解析（学习笔记）
Cser_zhu的博客
07-17 1415
类的定义 class 类型名 { 数据成员 成员函数 }; 这里类型名相当于一种数据类型，用来定义对象。 公共、私有和保护 private 只有该类的成员函数和友元函数才能访问这些成员 public 所有的函数都可以访问这些函数 protected 在具有private特性的同时，可以由派生类（通过继承而生成的类中的成员函数来访问 数据成员和成员函数 成员函数的使用 首先定义一个类的对象，格式为： 类名 对象名 有了对象之后，就可以用对象来访问类中的成员函数了。可以用句点或者指针形式，定义一个
C++类&对象
STATICHIT静砸的博客
02-25 120
C++ 在 C 语言的基础上增加了面向对象编程，类是 C++ 的核心特性，通常被称为用户定义的类型。 类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。 类的定义 定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。 类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟.
【类和对象】——拷贝构造函数和赋值运算符重载函数
qq_43412060的博客
07-14 512
1、类中6个默认成员函数 2、拷贝构造函数 1.1深拷贝、浅拷贝、写时拷贝 1.2拷贝构造函数详解 3、赋值运算符重载
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
12-31
 编写类String 的构造函数、析构函数和赋值函数，已知类String 的原型为： class String { public: String(const char *str = NULL); // 普通构造函数 String(const String &other); // 拷贝构造函数 ~ String...
C++语法详解之封装、构造函数、析构函数
12-20
在C++编程语言中，封装、构造函数和析构函数是面向对象编程的重要概念，它们在构建类和对象时起到关键作用。 封装是面向对象编程的核心原则之一，它指的是将数据（成员变量）和操作这些数据的方法（成员函数）捆绑...
编写strcpy函数和类String的构造函数、析构函数、赋值函数和重载运算符函数[文].pdf
10-12
strcpy 函数和类 String 的构造函数、析构函数、赋值函数和重载运算符函数都是软件开发中最基本的知识点，它们的实现需要注意内存的分配和释放、字符串的复制和赋值、运算符的语义和边界条件等多方面的考虑。
编写类String 的构造函数、析构函数和赋值函数.docx
06-27
本题主要考察的是如何为一个名为`String`的类编写构造函数、拷贝构造函数、析构函数以及赋值运算符。下面将详细解释这些函数的作用以及如何实现它们。 1. **构造函数**： - `String(const char *str = NULL)` 是一...
编写strcpy函数和类String的构造函数、析构函数、赋值函数和重载运算符函数
11-06
主要包含了strcpy函数和类String的构造函数、析构函数、赋值函数和重载运算符函数等代码实现。
C++ 学习十四 析构函数
hyyjiushiliangxing的博客
06-23 232
析构函数： 对象过期时自动调用的特殊成员函数 析构函数一般用来完成清理工作 析构函数的名称是在类名前加上~ 析构函数没有参数，只能有一个 注意： 析构函数用来释放对象使用的资源，并销毁对象的非static数据成员 无论何时一个对象被销毁，都会自动调用其析构函数（隐式析构） 释放是栈内存中的对象 用析构函数就可以 但是当对象是堆内存中时，使用完毕时，记得delete ，释放内存。 ...
C++入门学习：类与对象：基础篇
m0_52414540的博客
06-03 1192
类与对象 理解： （作用上） 类就是实体在计算机世界的存在， 数据表示实体的属性， 实体的行为则表示为数据的处理函数， 只要是同类型的实体，都可以用一个类来处理； （使用上） 一个类相当于一个用户自定义的数据类型， 有自己的类型变量，即对象； 例如：int a; 类相当于int 对象相当于a； 通过实例来理解（基本） 在这里插入代码片 ...
java 栈帧与类的关系_Java-JVM 栈帧（Stack Frame）
weixin_39661345的博客
03-02 167
一、概述栈帧位置JVM 执行 Java 程序时需要装载各种数据到内存中，不同的数据存放在不同的内存区中(逻辑上)，这些数据内存区称作运行时数据区(Run-Time Data Areas)。其中 JVM Stack(Stack 或虚拟机栈、线程栈、栈)中存放的就是 StackFrame(Frame 或栈帧、方法栈)。对应关系一个线程对应一个JVM Stack。JVM Stack 中包含一组St...
C++命名规范
chouci9270的博客
11-07 389
在软件开发这一高度抽象而且十分复杂的活动中，命名规则的重要性更显得尤为突出。一套定义良好并且完整的、在整个项目中统一使用的命名规范将大大提升源代码的可读性和软件的可维护性。 在引入细节之前，先说明一下命名规范的整体原则： 同一性 在编写一...
C++析构函数（类的前面加上一个~）
皮皮#2500
03-27 1904
C++析构函数析构函数介绍：示例：参考链接     析构函数是类的另一个特殊成员函数，它的作用与构造函数相反，C++规定析构函数的名字是类的前面加上一个波浪号 (～)。     析构函数不返回任何值，没有返回类型，也没有函数参数。由于没有函数参数，因此它不能被重载。换言之，一个类可以有多个构造函数，但是只能有一个析构函数。 析构函数介绍： 1.析构函数(destructor) 与构造函数相反，当对...
C++类与对象—默认成员函数
weixin_42357849的博客
11-16 158
一、默认成员函数。 如图所示： 当我们自己定义的类中没有下列函数的时候，编译器调用系统自动生成的下列函数，因此，了解这些函数就很重要。 二、构造函数。 定义： 构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。 构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
最新发布
qq_44962949的博客
07-17 244
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

周周汪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值