1. Toy模板网首页
  2. > Toy博客

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

7月前 作者：花想云(西安第一深情) 分类：Toy博客 阅读(69) 违法举报

这篇具有很好参考价值的文章主要介绍了C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

💐专栏导读

🌸作者简介：花想云，在读本科生一枚，致力于 C/C++、Linux 学习。

🌸本文收录于 C++系列，本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等，专为大学生打造全套 C++ 学习教程，持续更新！

🌸相关专栏推荐：C语言初阶系列 、C语言进阶系列 、数据结构与算法

💐文章导读

本章主要内容为认识与学习C++非常重要的概念——运算符重载。通过日期类的实现，逐步学习各个运算符重载的实现方法即含义。6个默认成员函数还剩余3个——赋值运算符重载与2个取地址重载，我们本章就会解决它们~

🌷运算符重载

🌺引例

假设现在有一个日期类Date，以及两个Date类对象d1、d2。在实际应用中，我们难免会对两个对象进行比较大小、加减乘除、流插入、流提取、赋值等一系列操作。在C语言阶段，我们的做法一般是实现各操作对应的函数。例如：

class Date
{
	//...
}
int Add(Date d1,Date d2); //相加
int Sub(Date d1,Date d2); //相减
int Compare(Date d1,Date d2); //比较
//...

虽然这种做法可以满足需求，但是有一个缺点：代码的可读性较差。尽管使用者好像能通过函数名猜出函数的大致功能，但是使用者并不知道函数的具体实现难免会造成错误的使用。

有没有什么方法可以像这样让人一眼就能看懂呢？例如：

d1+d2;
d1-d2;
d1==d2
//...

为了增强代码的可读性，C++中引入了运算符重载的概念。

🌺概念及运用

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

运算符重载实际上就如同函数重载，使操作符拥有新的功能。

🌼运算符重载结构

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

例如：

bool operator==(Date d1,Date d2);

🌺牛刀小试

定义一个Date类：

class Date
{
public:
	//构造函数
	Date(int year = 0, int month = 0, int day = 0)
	{
		//判断日期是否合法
		//GetMonthDay()获取这个月的天数
		if (month > 0 && month < 13 &&
			(day > 0 && day <= GetMonthDay(year, month)))
		{
				_year = year;
				_month = month;
				_day = day;
		}
		else
		{
			cout << "日期非法" << endl;
		}
	}
private:
	int _year;//年
	int _month;//月
	int _day;//日
};

🍁==重载

我们都知道==是用来比较的运算符，Date类对象进行比较该怎么比较呢？我们可以规定，如果两个对象的年、月、日都相当则两个对象相等，返回true。

🌼错误示例1

bool operator==(Date d1, Date d2)
{
	return (d1._year == d2._year) && 
		   (d1._month == d2._month) && 
		   (d1._day == d2._day);
}
void Test1()
{
	Date d1(2023, 4, 1);
	Date d2(2023, 3, 2);

	//注意此处会有操作符优先级的问题，所以要加小括号
	cout << (d1 == d2) << endl;
}

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

此处有一个典型的错误：该函数不是类的成员函数，无法访问类的私有成员！

有3个办法可以解决：

  1. 将类的成员改为公有（虽然可以解决，但会破坏类的封装性）；
  2. 使该函数成为类的友元函数（后面的章节再做讲解）；
  3. 将该函数包含在类中成为类的成员函数；

目前我们只能选择第3种方法。

🌼错误示例2

class Date
{
public:
	//构造函数
	Date(int year = 0, int month = 0, int day = 0)
	{
		if (month > 0 && month < 13
		&& (day > 0 && day <= GetMonthDay(year, month)))
		{
			_year = year;
			_month = month;
			_day = day;
		}
	}
	bool operator==(Date d1, Date d2)
	{
		return (d1._year == d2._year) && (d1._month == d2._month) && (d1._day == d2._day);
	}
private:
	int _year;
	int _month;
	int _day;
	
};

🌼特别注意

  • 二元运算符的重载函数的参数有两个，规定第一个参数为左操作数，第二个参数为右操作数。

还记得成员函数有什么特性吗？成员函数有一个自带的参数this，类型为类类型。因为我们不可能将this指针删掉，所以只能省略第一个参数。

上一章中曾提到，为减少拷贝引起的消耗，尽量使用引用的方式传参。

🌼正确的做法

class Date
{
public:
	//...
	bool operator==(const Date& d)//若不改变形参最好用const修饰
	{
		return (_year == d._year) && 
			   (_month == d._month) && 
			   (_day == d._day);
	}
	//...	
};

🌺运算符重载的特性

运算符重载有如下特性：

  • 重载操作符必须有一个类类型参数；
  • 不能通过连接其他符号来创建新的操作符：比如operator@、operator?等；
  • 用于内置类型的运算符，其含义不能改变，例如：int类型的+，不能改变其含义；
  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；
  • .* :: sizeof ?: .注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

🌺其它运算符重载的实现

有了上述的==作为示例，我们还可以实现< > <= >= + - ++ --等一系列操作符的重载。

🍁> < >= <= != 重载

实现两个重载后，其他重载的实现可以复用已经实现的操作符。

class Date
{
public:
	//构造函数
	//...
	bool operator==(const Date& d)
	{
		return (_year == d._year) && (_month == d._month) && (_day == d._day);
	}
	bool operator<(const Date& d) 
	{
		return _year < d._year
			|| (_year == d._year && _month < d._month)
			|| (_year == d._year && _month == d._month && _day < d._day);
	}
	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);
	}
//...
};

🍁+= -= + - 重载

注意：下列四个运算符的右操作数都为天数。

class Date
{
public:
	//...
	//获取当月的天数
	int 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& operator+=(int day)
	{
		//判断是否加了负数
		if (day < 0)
		{
			//复用
			*this -= -day;
			return *this;
		}

		_day += day;
		while (_day > GetMonthDay(_year, _month));
		{
			_day -= GetMonthDay(_year, _month);
			//进位
			_month++;
			if (_month == 13)
			{
				_year++;
				_month = 1;
			}
		}
		return *this;
	}
	//-= 返回自身的引用,减少拷贝
	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 operator+(int day) 
	{
		//拷贝构造
		//因为加不改变自身的值，所以创建临时对象
		Date tmp(*this);
		//复用
		tmp += day;
		return tmp;
	}
	Date operator-(int day)
	{
		Date tmp(*this);
		tmp -= day;
		return tmp;
	}
//...
};

🍁前置++与后置++重载

前置++和后置++都是一元运算符，为了让前置++与后置++能形成正确重载，C++规定：

  • 后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
    自动传递。
class Date
{
public:
	//...
	//前置++
	Date& operator++()
	{
		*this += 1;
		return *this;
	}
	//后置++
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，
	// 故需在实现时需要先将this保存一份，然后给this + 1
	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
	Date operator++(int)
	{
		Date tmp(*this);
		*this += 1;
		return tmp;
	}
	//前置--
	Date& operator--()
	{
		*this -= 1;
		return *this;
	}
	//后置--
	Date operator--(int)
	{
		Date tmp(*this);
		*this -= 1;
		return tmp;
	}
//...
};

🍁日期-日期的实现

日期+日期没有意义，但是日期-日期有意义，日期-日期代表相距多少天。

class Date
{
//...
	int 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;
	}
	//...
}

🍁<< 与 >>重载

🌼错误示例

class Date
{
//...
	//使用因为返回，为了适应连续输入或输出的情况
	ostream& operator<<(ostream& out)
	{
		out << _year << "年" << _month << "月" << _day << "日" << endl;
		return out;
	}
	istream& operator>>(istream& in)
	{
		in >>_year >>_month >>_day;
		return in;
	}
	//...
}

>> << 是二元操作符，上文中提到二元操作符第一个参数为左操作数，第二个参数为右操作数。此时这段代码第一个参数为this，也就意味着左操作数变成了对象，右操作数变成了cout。那么我们使用时只能这样写：

void Test2()
{
	Date d1(2023, 4, 1);
	d1 << cout;
}

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

虽然能满足需求，但是用起来感觉怪怪的。由于我们无法改变this的位置，所以只能使用其它办法来实现<< >>的重载了。

这里我们只能将重载定义在类的外面才能避开this的影响。但是类外的函数又访问不了类的私有成员。我们只能通过将重载函数设置为类友元函数来实现了。

🌼正确的做法

class Date
{
//...
	//申明友元函数
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
	//...
}
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日";
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

🌷简单的测试

到这里，我们试着写一个测试函数验证运算符重载是否正确并学会运算符重载的使用。

void Test()
{
	Date d1(2023, 4, 1);
	Date d2(2022, 3, 1);
	cout << d1+1 <<endl;
	cout << d2 <<endl;
	cout << d1++ << endl;
	cout << d2-- << endl;
	cout << d1 << endl;
	cout << d2 << endl;
	cout << (d1 == d2) << endl;
	cout << (d1 >= d2) << endl;
	cout << (d1 <= d2) << endl;
	cout << (d1 != d2) << endl;
	cout << (d1+100) << endl;
	cout << (d1 - 200) << endl;
}

测试结果：
C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

结果证明我们目前实现的运算符重载以及操作符重载还是挺成功的。小伙伴们在自己实现的时候也要记得边写边测试哦~

🌷默认成员函数——赋值运算符重载

与之前讲的构造函数与析构函数等默认成员函数相同，赋值运算符重载也属于6个默认成员函数之一。

作为与众不同的默认成员函数，其有以下特性：

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

🌼赋值重载

class Date
{
//...
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	//...
}
  1. 赋值运算符只能重载成类的成员函数不能重载成全局函数；

🌼错误示例

class Date
{
	//...
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有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 =”必须是非静态成员。

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

这里赋值重载与拷贝构造函数的特性非常相似。

🌷默认成员函数——取地址操作符重载

6个默认成员函数只剩两个——取地址重载与const取地址重载。但是，这两个函数实在没有实现的必要，因为我们自己实现与编译器自动实现出来的效果是一样的。

🌼取地址重载

class Date
{
	//...
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
	//...
};

🌷const成员

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

🌼什么情况下需要用const修饰？

我们可能暂时感受不到const修饰的作用，但是遇到如下情况，const修饰就非常有必要了。

🌼举例

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

void Test3()
{
	Date d1(2023, 4, 1);
	d1.print();
	const Date d2(2022, 3, 1);
	d2.print();
}

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

报错内容为：“void Date::print(void)”: 不能将“this”指针从“const Date”转换为“Date &”。

这里是典型的权限放大错误，我们不能将const Date* &d2传递给形参Date* this。

改正的办法为同样用const修饰this，但具体的写法可不像我们想的那样。

void print() const
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

因为我们无法显式的修改this，所以C++规定在函数的后面加上const即为修饰this。

🌷日期类的实现

我们总结上文中的运算符重载，整理一下完整的日期类的实现。此处我们使用多文件的形式实现—>

  • Date.h文件中进行头文件包含、命名空间展开、类的声明、内联函数定义等；
  • Date.cpp文件中进行对类成员函数的定义。

🌺Date.h

#define _CRT_SECURE_NO_DEPRECATE 1
#include<iostream>
#include<assert.h>
using namespace std;

// 类里面短小函数，适合做内联的函数，直接是在类里面定义的
class Date
{
	// 友元函数声明
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

public:
	Date(int year = 0, int month = 0, int day = 0);
	void Print() const;
	int GetMonthDay(int year, int month) const;

	bool operator==(const Date& d) const;
	bool operator!=(const Date& d) const;
	bool operator<(const Date& d) const;
	bool operator<=(const Date& d) const;
	bool operator>(const Date& d) const;
	bool operator>=(const Date& d) const;

	Date& operator+=(int day);
	Date operator+(int day) const;


	Date& operator-=(int day);
	Date operator-(int day) const;

	int operator-(const Date& d) const;

	Date& operator=(const Date& d);

	//前置++
	Date& operator++();

	// 后置++
	// int参数 仅仅是为了占位，跟前置重载区分
	Date operator++(int);

	// 前置--
	Date& operator--();

	// 后置--
	Date operator--(int);

	//取地址重载
	Date* operator&();
	const Date* operator&() const;

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

inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日";
	return out;
}

inline istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

🌺Date.cpp

#define _CRT_SECURE_NO_DEPRECATE 1
#include"Date.h"
//构造函数
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;
	}
}

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

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

bool Date::operator<=(const Date& d) const
{
	//函数的复用
	return *this < d || *this == d;
}

bool Date::operator>(const Date& d) const
{
	//函数的复用
	return !(*this <= d);
}

bool Date::operator>=(const Date& d) const
{
	//函数的复用
	return !(*this < d);
}

bool Date::operator!=(const Date& d) const
{
	//函数的复用
	return !(*this == d);
}

//获取当月的天数
int Date::GetMonthDay(int year, int month) const
{
	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::operator+=(int day)
{
	//判断是否加了负数
	if (day < 0)
	{
		//复用
		*this -= -day;
		return *this;
	}

	_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)
{
	//判断是否减了一个负数
	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) const
{
	//拷贝构造
	//因为加不改变自身的值，所以创建临时对象
	Date tmp(*this);
	//复用
	tmp += day;
	return tmp;
}

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

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

//后置++
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，
// 故需在实现时需要先将this保存一份，然后给this + 1
// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
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;
}

int Date::operator-(const Date& d) const
{
	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;
}

Date& Date::operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}

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

C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载

点击下方个人名片，可添加博主的个人QQ，交流会更方便哦~
↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓文章来源地址https://www.toymoban.com/news/detail-406426.html

到了这里，关于C++修炼之筑基期第四层 ——透过日期类看运算符重载 | 赋值运算符重载 | 取地址操作符重载的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 计算机网络——第四层：传输层以及TCP UDP

    计算机网络——第四层：传输层以及TCP UDP

            连接模式的传输。         保证按顺序传送数据包。         流量控制、错误检测和在数据包丢失时的重传。         用于需要可靠传输的应用，如网络（HTTP/HTTPS）、电子邮件（SMTP, IMAP, POP3）和文件传输（FTP）。         数据报模式。        

    2024年01月21日
    浏览(48)
  • 【C++】透过STL源码深度剖析及模拟实现vector

    【C++】透过STL源码深度剖析及模拟实现vector

    鉴于读者的响应，打算将文章拆分一下，方便观看，基本接口可看 深入浅出STL之vector类 以下我所介绍的都是基于【SGI】版本的STL，对源码有兴趣的同学可以去看看 侯捷老师的《STL源码剖析》 然后呢我们就去调出【vector】的一些核心源码，这里我们主要关注的就是这个使用原

    2024年02月14日
    浏览(29)
  • 【C++修炼之路】C++入门（上）

    【C++修炼之路】C++入门（上）

    👑作者主页：@安 度 因 🏠学习社区：安度因的学习社区 📖专栏链接：C++修炼之路

    2024年01月17日
    浏览(31)
  • 【C++修炼之路】内存管理

    【C++修炼之路】内存管理

    👑作者主页：@安 度 因 🏠学习社区：StackFrame 📖专栏链接：C++修炼之路

    2024年02月16日
    浏览(22)
  • 【C++修炼之路】C++入门（中）—— 函数重载和引用

    【C++修炼之路】C++入门（中）—— 函数重载和引用

    👑作者主页：@安 度 因 🏠学习社区：StackFrame 📖专栏链接：C++修炼之路

    2024年02月02日
    浏览(28)
  • 【C++修炼之路】33.特殊类设计

    【C++修炼之路】33.特殊类设计

    每一个不曾起舞的日子都是对生命的辜负 掌握常见特殊类的设计方式 拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。 C++98 将拷贝构造函数与赋值运算符重载只声明不

    2024年02月13日
    浏览(38)
  • 【C++修炼之路】list 模拟实现

    【C++修炼之路】list 模拟实现

    👑作者主页：@安 度 因 🏠学习社区：StackFrame 📖专栏链接：C++修炼之路

    2024年02月16日
    浏览(24)
  • 【C++修炼秘籍】List深度剖析

    【C++修炼秘籍】List深度剖析

    ☀️心有所向，日复一日，必有精进 ☀️专栏《C++修炼秘籍》 ☀️作者：早凉 ☀️如果有错误，烦请指正，如有疑问可私信联系； 目录 【C++修炼秘籍】STL-List 文章目录 前言 一、list介绍 二、list的使用/接口介绍 构造函数 list iterator的使用 list capacity list element access list mod

    2024年01月25日
    浏览(30)
  • 【C++程序员的自我修炼】拷贝构造函数

    【C++程序员的自我修炼】拷贝构造函数

    心存希冀 追光而遇目有繁星 沐光而行 目录 拷贝构造函数概念 拷贝构造的特征 无穷递归的解释 浅拷贝 总结：  深拷贝 拷贝构造函数典型调用场景 总结  契子 ✨ 在生活中总有很多琐事，不做不行做了又怕麻烦，有时候想要是有个和自己一模一样的人就好了 可以帮我上早读

    2024年04月14日
    浏览(36)
  • C++修炼之练气期第五层——引用

    C++修炼之练气期第五层——引用

    目录 1.引用的概念 2.引用的性质 3.常量引用 4.使用场景 1.作参数 2.作返回值 5.传值与传引用的效率比较  6.值和引用作为返回值的性能比较  7.引用与指针 指针与引用的不同点 要说C语言中哪个知识点最难学难懂，大部分人可能和我一样的答案——指针。C++既然是C语言的豪华

    2024年01月18日
    浏览(27)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包