Lesson 02 类与对象 (下)

最新推荐文章于 2024-09-27 11:26:03 发布
最新推荐文章于 2024-09-27 11:26:03 发布
阅读量234 收藏
点赞数 12
分类专栏： Class 养成{C++}； 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/callmeggyh/article/details/134345311
版权

C++：渴望力量吗，少年？

文章目录

一、赋值运算符重载

1. 运算符重载

  C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
（1）函数名字为：关键字operator后面接需要重载的运算符符号。
（2）函数原型：返回值类型 operator操作符 (参数列表)
但是要注意的是：
（3）不能通过连接其他符号来创建新的操作符：比如operator@
（4）重载操作符必须有一个类类型参数
（5）作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this指针
（6）.*   ::  sizeof  ? :  .  注意以上5个运算符不能重载。

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

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	 //d1 < d2  或者  d1.operator<(d2)
	bool operator<(const Date& d)//列表隐含了第一个参数this，在这里d1就是this，d2就是d
	{ //可以把这个重载定义在类中，这样可以解决private成员无法在类外使用的问题
		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;
		}
	}

private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 7, 21);
	Date d2(2022, 8, 21);
	cout << (d1 < d2) << endl;//这两条语句等价
	cout << (d1.operator<(d2)) << endl;

	return 0;
}

2. 赋值运算符重载

（1）赋值运算符重载格式
  a. 参数类型：const T&，传递引用可以提高传参效率
  b. 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  c. 检测是否自己给自己赋值
  d. 返回*this ：要符合连续赋值的含义

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

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	// d1 < d2  
	// d1.operator<(d2)
	bool 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 operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}

	// d1 <= d2:this就是d1，d就是d2
	bool operator<=(const Date& d)
	{
		return *this < d || *this == d;
	}

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

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

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

	int GetMonthDay(int year, int month)
	{
		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;
		}

		return monthArray[month];
	}

	Date& operator+=(int day)//修改了原来的日期
	{
		_day += day;
		while (_day > GetMonthDay(_year, _month))
		{
			// 月进位
			_day -= GetMonthDay(_year, _month);
			++_month;

			// 月满了
			if (_month == 13)
			{
				++_year;
				_month = 1;
			}
		}

		return *this;//注意this只是一个指针，需要解引用
	}

	Date operator+(int day)//没有修改原来的日期
	{//函数名不可以加 & ，因为函数结束tmp就销毁了
		Date tmp(*this);//调用拷贝构造函数，复制出一份新的日期
		tmp += day;//复用上面的代码
		return tmp;
	}

private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 7, 21);
	Date d2(2022, 8, 21);
	cout << (d1 < d2) << endl;
	// cout << (d1.operator<(d2)) << endl;
	cout << (d1 == d2) << endl;

	//Date ret = d1 += 50;
	//ret.Print();
	//d1.Print();

	Date ret = d1 + 50;
	ret.Print();
	d1.Print();

	return 0;
}

（2）赋值运算符只能重载成类的成员函数，不能重载成全局函数。

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


	int _year; 
	int _month; 
	int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year; left._month = right._month; left._day = right._day;
	}


	return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

  原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
（3）用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

3. 前置++和后置++重载

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

	// 前置++：返回+1之后的结果
	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}

	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
	Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	Date d1(2022, 1, 13);
	d = d1++;//该语句执行结束时 --  d: 2022,1,13   d1:2022,1,14
	d = ++d1;//该语句执行结束时 --  d: 2022,1,15   d1:2022,1,15
	return 0;
}

二、const成员

  将 const修饰的“成员函数” 称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
在这里插入图片描述
  注意：const修饰成员函数时要放在函数的末尾（也就是必须以上图左边的代码形式书写，右边是表示实际等价于左边的代码），另外内部不涉及修改成员的都是只读函数，这样的函数可以加const，这样是有利于避免权限上冲突的问题的。

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

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

    // 不想被取到有效地址的时候才会考虑重载取地址运算符 &
    Date* operator&()
    {
    	// return (Date*)0x01202;
    	return nullptr;//不想返回自己的地址，返回了空指针
    }

    const Date* operator&() const
    {
    	return this;//返回自己的地址，其实也不用写，默认生成的就是这样的
    }

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

四、构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
	/*Date()//无参构造函数
	{
		cout << "Date()" << endl;
		_year = 1;
		_month = 1;
		_day = 1;
	}*/
	
	//Date(int year, int month, int day)//有参构造函数，和上面的函数重载
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}

	Date(int year = 1, int month = 1, int day = 1)//采用全缺省，相当于上面的两个函数合并
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		//cout << this << endl;
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;   // 声明
	int _month;
	int _day;
};

class Stack
{
public:
	/*Stack()
	{
		a = nullptr;
		top = capacity = 0;
	}*/

	Stack(size_t n = 4)
	{
		if (n == 0)
		{
			a = nullptr;
			top = capacity = 0;
		}
		else
		{
			a = (int*)malloc(sizeof(int) * n);
			if(a == nullptr)
			{
				perror("realloc fail");
				exit(-1);//以异常的形式结束程序，剩下的程序不会继续执行
			}

			top = 0;
			capacity = n;
		}
	}

	// 成员函数
	//void Init()
	//{
	//	a = nullptr;
	//	top = capacity = 0;
	//}

	void Push(int x)
	{
		if (top == capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
			if (tmp == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}
			if (tmp == a) //根据首地址验证是原地扩容还是异地扩容
			{
				cout << capacity << "原地扩容" << endl;
			}
			else //异地扩容比较麻烦，需要找到一块新的空间，然后拷贝数据，最后释放旧的空间
			{
				cout << capacity << "异地扩容" << endl;
			}

			a = tmp;
			capacity = newcapacity;
		}

		a[top++] = x;
	}

	int Top()
	{
		return a[top - 1];
	}

	void Pop()
	{
		assert(top > 0);
		--top;
	}

	void Destroy()
	{
		free(a);
		a = nullptr;
		top = capacity = 0;
	}

	bool Empty()
	{
		return top == 0;
	}
private:
	// 成员变量
	int* a;
	int top;
	int capacity;
};

int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);
	st1.Push(4);
	
	while (!st1.Empty())
	{
		cout << st1.Top() << " ";
		st1.Pop();
	}
	cout << endl;

	st1.Destroy();

	Stack st2(1000);//利用缺省参数提前开好了足够大的空间，避免了多次异地扩容，比下面的语句效率更高
	//Stack st2;
	for (size_t i = 0; i < 1000; i++)
	{
		st2.Push(i);
	}

	while (!st2.Empty())
	{
		cout << st2.Top() << " ";
		st2.Pop();
	}
	cout << endl;

	st2.Destroy();

	// 调用无参构造函数不能像下面这么写，不需要加括号，因为声明函数就是Date Func（）的形式
	/*Date d1();
	d1.Print();*/

	Date d1;//自动调用无参构造函数或者上面全缺省的函数
	d1.Print();

	Date d2(2023, 7, 20);
	d2.Print();

	Date d3(2023);
	d3.Print();

	Date d4(2023, 7);
	d4.Print();

	return 0;
}

  虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。所以就需要我们学习下一篇文章提到的初始化列表。

软工在逃男大学生
关注
专栏目录
Java学习笔记3.1.1 类与对象 - 基本概念
howard2005的专栏
03-26 1274
1. 理解面向对象的概念； 2. 熟悉面向对象的三个特点； 3. 掌握类和对象的定义和使用； 4. 理解并熟悉访问控制符
lesson03-02 Java类基础知识--基本类型.ppt
09-23
Java语言的基础知识中，类是核心概念之一，而类中的基本类型则是构建程序的基本元素。基本类型不依赖于对象，它们直接存储值，是Java内存管理的最小单位。本节主要探讨了Java中的八种基本类型及其特性。 首先，布尔...
lesson02 类与对象（上）
2401_82494141的博客
04-14 701
class是声明类的关键字，className是类的名字，花括号内为类的主体，注意花括号后面有一个分号。类体中的内容为类的成员：类中的变量称为或；类中的函数称为或。成员函数的两种定义方式：1声明和定义都在类内，需注意：这种方法定义的成员函数可能会被编译器当成处理。2.类内声明，类外定义3.类声明放在1头文件，成员函数定义在源文件。
lesson04:类和对象（下）
2401_82494141的博客
04-25 1144
解答：1.
Lesson02---类与对象(上篇).pdf
m0_67371175的博客
05-28 763
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 上面结构体的定义，在C++中更喜欢用class来代替。 2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名:: ps:这里会和.成员访问函数混淆，这里主要和全局函数区分所以用域作用限定符 成员变量命名规则的建议 4.类的访问限定符及封装 4.1 访问限定符 C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选
python3类与对象汽车_Python3 类的定义和对象实例
weixin_35849182的博客
03-01 331
面向对象设计思想最重要的概念就是类(Class)和实例(Instance)，类是抽象的模板。实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。类定义在Python中，定义类是通过class关键字，语法格式如下：class ClassName:class关键字后面紧接着是类名，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的。...
【C++】类和对象——Lesson1
小羊的博客
07-29 2722
类、类的默认成员函数
lesson7 - Java类与对象(基础篇)
Codefengfeng的博客
05-27 894
叫法上，属性=成员变量=field；定义属性的语法形式为：访问修饰符属性类型属性名访问修饰符控制属性的访问范围，有四种访问修饰符public, protected, private和默认。属性类型既可以是基本类型，也可以是引用类型；叫法上，类方法=成员方法=函数定义方法的格式为：访问修饰符 返回值类型 方法名 (形参列表) {方法体return 返回值其中，修饰符类型有四种(public protected private 默认)；返回值类型。
【C++】类和对象——Lesson2
小羊的博客
08-01 2150
运算符重载
cpp初阶--Lesson 02--类与对象（上）
VegetableGirl的博客
12-13 153
Lesson 02类与对象（上） 【本节目标】 1.类与对象的初步认知 2.类的引入 3.类的定义 4.类的作用域 5.类的实例化 6.类的访问限定符及封装 7.类的对象大小的计算 8.类成员函数的this指针 1.类与对象的初步认知 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 2.类的引入 **C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数
c++Lesson04类和对象
ddddddddrose的博客
12-25 282
以一个例子说明：class Mystring { char*str; int len;//未指定类型时候默认为私有，其余的包括public和protected Mystring(){};//构造函数在对象生成时自动调用 ~Mystring(){};//析构函数在对象销毁时自动调用 } int main() { Mystring.demo;//demo为类的对象，必须使用
java从入门到精通学习笔记-Lesson2(面向对象下).pdf
11-26
总的来说，Java中的继承机制是面向对象编程的重要组成部分，它使得类之间能够形成层次结构，提高了代码的可维护性和扩展性。理解并熟练掌握继承、方法覆盖以及`super`关键字的使用，对于编写高效、灵活的Java程序至...
Lesson_jsp内置对象和简单理解servlet
07-10
Lesson_jsp内置对象和简单理解servlet
上机4：类与对象编程.docx
09-04
在Java、C++、Python等许多编程语言中，类与对象是核心概念。在这个上机任务中，我们将学习如何定义和使用类以及对象。 首先，我们定义一个名为`Student`的类。类是用来封装数据和行为的结构，它可以看作是一个模板...
lesson02.rar
02-09
在本压缩包“lesson02.rar”中，包含的是一个关于使用Java进行UDP（User Datagram Protocol）在线咨询的简单案例代码。这个案例旨在演示如何利用socket技术构建客户端和服务端之间的通信。UDP是一种无连接的传输协议...
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1102
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 644
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 412
【代码】求n的阶乘的相反数（c语言）
简易STL实现 | Set 的实现
AsherGu的博客
09-26 443
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
孙鑫Java教程：面向对象编程基础 Lesson2 - 类与对象详解
- OOP强调对象间的交互，与传统的面向过程编程（Procedural Programming，PP）不同，它首先定义数据结构，然后确定如何操作这些数据。在PP中，程序员通常先设计算法和数据结构，而在OOP中，对象模型包含数据和方法...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值