c++初阶------类和对象（六大默认构造函数的揭破）

news2025/4/28 17:11:34

作者前言

🎂 ✨✨✨✨✨✨🍧🍧🍧🍧🍧🍧🍧🎂
​🎂 作者介绍： 🎂🎂
🎂 🎉🎉🎉🎉🎉🎉🎉 🎂
🎂作者id：老秦包你会， 🎂
简单介绍：🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂🎂
喜欢学习C语言、C++和python等编程语言，是一位爱分享的博主，有兴趣的小可爱可以来互讨 🎂🎂🎂🎂🎂🎂🎂🎂
🎂个人主页::小小页面🎂
🎂gitee页面:秦大大🎂
🎂🎂🎂🎂🎂🎂🎂🎂
🎂 一个爱分享的小博主 欢迎小可爱们前来借鉴🎂

类和对象

  • **作者前言**
  • 默认成员函数
  • 类的空类
  • 构造函数
      • 内置类型和自定义类的的自动初始化情况
  • 析构函数
  • 拷贝函数
    • 拷贝函数的特征
  • 赋值运算符重载
    • 运算符重载
    • 赋值运算符重载
    • cout的流提取(<<)
  • const成员函数
  • 取地址及const取地址操作符重载

默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
在这里插入图片描述

类的空类

我们在写类的成员变量和成员函数，我们实例化一个对象，有时候就会忘记实例化，直接使用成员函数，这个在C语言会报错，在c++就不会报错,但是值是随机的

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stru
{
public:
	void Fun()
	{
		cout << _a << endl;
		cout << _b << endl;
	}
private:
	int* _a;
	int _b;
};
int main()
{
	Stru str;
	str.Fun();

	return 0;
}

有啥方法可以解决呢？答案是构造函数

构造函数

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

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

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stru
{
public:
	Stru()
	{
		_a = 200;
		_b = 100;
	}
	Stru(int a, int b)
	{
		_a = a;
		_b = b;
	}
	void Fun()
	{
		cout << _a << endl;
		cout << _b << endl;
	}
private:
	int _a;
	int _b;
};
int main()
{
	Stru str;
	str.Fun();
	Stru st1(1, 1);
	st1.Fun();

	return 0;
}

这里有两种写法，一种是直接使用自己定义的，一种是使用传入的参数，需要注意的是 第一种写法不用加（），因为加了就相当于是函数声明了。
注意：可以使用函数重载，但是要注意是否有冲突，缺省参数和无参数是否存在歧义。

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

c++编译器默认构造函数：一般情况内置类型不会进行初始化，自定义类型的初始化会自动调用默认构造函数。

内置类型和自定义类的的自动初始化情况

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
	Stack()
	{
		_a = (int *)malloc(sizeof(int) * 4);
		if (_a == nullptr)
		{
			perror("malloc");
			return;
		}
		_top = 0;//栈顶元素的下一个
		_capacity = 4;
	}
	//插入
	void Stackpushback(int elemest)
	{
		if (_top == _capacity)
		{
			int size = _capacity > 0 ? 2 * _capacity : 4;
			int* tmp = (int*)realloc(_a, sizeof(int) * size);
			if (tmp == nullptr)
			{
				perror("realloc");
				return;
			}
			_a = tmp;
			_capacity = size;
		}
		_a[_top++] = elemest;
	}
	//删除
	void Stackpop()
	{
		if(_top)
			_top--;
	}
	//栈顶元素
	int Stacktop()
	{
		if(_top)
			return _a[_top - 1];
		return INT_MAX;
	}
	//是否为空
	bool Stackempty()
	{
		return _top;
	}


private:
	int* _a;
	int _top;
	int _capacity;

};
class StackQueue
{
private:
	//入数据的栈
	Stack pushstack;
	//出数据的栈
	Stack popstack;
	int size;
	
};
int main()
{
	Stack mystack;
	StackQueue mq;
	return 0;
}

在这里插入图片描述
可以看到size没有初始化就赋值了0，因为在vs2019优化过了，我们一般就认为是没有初始化化的，

内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认
注意一下：指针类型都是内置类型

但是在C++11就增加了补丁
**内置类型成员变量在类中声明时可以给默认值。**本质上还是声明，定义是要给空间的
在这里插入图片描述
总结：

  1. 我们不写构造函数，编译器会自己写一个构造函数，这个值是随机值，这个函数叫做默认构造
  2. 无参数构造函数可以叫默认构造
  3. 全缺省函数也叫默认构造
  4. 这三种不能同时存在，只能存在一个

析构函数

前面我们学习了构造函数，主要用于初始化对象
这里我们学习析构函数

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

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

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
    函数不能重载
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	~Date()
	{
		cout << "调用析构函数" << endl;
	}
	Date()
	{
		_a = 20;
	}
private:
	int _a = 30;
};
int main()
{
	Date time;
	return 0;
}

在这里插入图片描述
这个析构函数我们可以运用于经常忘记的内存释放的地方，比如栈使用结束后，空间释放
​
在这里插入图片描述
注意:析构调用完才销毁对象

拷贝函数

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Fun(Date d)
{
	d.print();
}
int main()
{
	Date d1(2024, 1, 4);
	Fun(d1);

	return 0;
}

这种是一种浅拷贝，但是当浅拷贝运用到某些场景就会带来不必要的麻烦

在这里插入图片描述
当Fun函数运行的时候是有可能更改对应地址的值的

拷贝函数的特征

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

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，
    因为会引发无穷递归调用。
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	~Date()
	{
		cout << "调用析构函数" << endl;
	}
	Date(const Date& dd)
	{
		_year = dd._year;
		_month = dd._month;
		_day = dd._day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 1, 3);
	Date d2(d1);

	return 0;
}

在这里插入图片描述
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}
	~Date()
	{
		cout << "调用析构函数" << endl;
	}
	Date(const Date& dd)
	{
		_year = dd._year;
		_month = dd._month;
		_day = dd._day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Fun(Date d)
{
	d.print();
}
int main()
{
	Date d1(2024, 1, 3);
	Date d2(d1);
	Fun(d1);

	return 0;
}

在这里插入图片描述

这里的dd是是d1的引用，因为形参是实参的临时拷贝，这里的this指针指向的是d，
这个图也可以解释出，为啥拷贝函数传值会陷入无限的循环

  1. 深拷贝
#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		_capacity = capacity;
		_top = 0;

	}
	//深拷贝
	Stack(const Stack& st)
	{
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (_a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		_capacity = st._capacity;
		_top = st._top;

	}
private:
	int *_a;
	int _top;
	int _capacity;
};
int main()
{
	Stack d1(5);
	Stack d2(d1);
	return 0;
}

在这里插入图片描述
在这里插入图片描述
创建两个一模一样的空间，深拷贝就是要进行一比一的复制，浅拷贝在这里会公用一块地址，
浅拷贝的示意图：
在这里插入图片描述
注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
简单的来说，如果涉及到地址就要考虑一下是否需要深拷贝，如是简单的拷贝值的化，拷贝函数可以写也可以不写，不写的话，编译器会默认构造一个拷贝函数，（浅拷贝）

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
	//构造函数
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		_capacity = capacity;
		_top = 0;

	}
	//深拷贝
	Stack(const Stack& st)
	{
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (_a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		_capacity = st._capacity;
		_top = st._top;

	}
	//析构函数
	~Stack()
	{
		free(_a);
		cout << "释放了空间" << endl;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int *_a;
	int _top;
	int _capacity;
};
class MyQueue
{
private:
	Stack _d1;
	Stack _d2;
	int _size = 0;

};
int main()
{
	MyQueue q1;
	MyQueue q2(q1);//调用了拷贝构造
	return 0;
}

这里的情况就是q1会开辟成员变量的空间，调用了MyQueue的默认构造函数，然后_d1和_d2调用Stack的自定义的默认构造.
在这里插入图片描述
在这里插入图片描述
q1和q2之间的联系，之间调用的是拷贝函数，调用MyQueue的默认拷贝构造函数，而Stack调用的就是自定义的拷贝构造函数

一些场合
自定义当返回值

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Stack
{
public:
	//构造函数
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		_capacity = capacity;
		_top = 0;

	}
	//深拷贝
	Stack(const Stack& st)
	{
		cout << "拷贝" << endl;
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (_a == NULL)
		{
			perror("malloc");
			exit(-1);
		}
		_capacity = st._capacity;
		_top = st._top;

	}
	//析构函数
	~Stack()
	{
		free(_a);
		cout << "释放了空间" << endl;
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}
private:
	int *_a;
	int _top;
	int _capacity;
};
class MyQueue
{
private:
	Stack _d1;
	Stack _d2;
	int _size = 0;

};
Stack fun()
{
	Stack d1;
	return  d1;
}
int main()
{
	fun();
	return 0;
}

在这里插入图片描述
可以看出返回值，不会直接返回d1，而是d1的拷贝，也就是d1的临时对象
如果换成

Stack& fun()
{
	static Stack d1;
	return  d1;
}

在这里插入图片描述

在这里插入图片描述
可以把图中的Test函数换成我们的fun函数，看懂了就可以了。

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

赋值运算符重载

运算符重载

前面我们学习C语言，知道内置类型（int 、char…）可以直接使用各种运算符,但是自定义类型是不可以的

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	//构造函数
	Date(int year, int month, int day)
	{
		cout << "构造函数" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	//浅拷贝
	Date(const Date& d1)
	{
		cout << "拷贝" << endl;
		_year = d1._year;
		_month = d1._month;
		_day = d1._day;
	}
	//析构函数
	~Date()
	{
		cout << "析构函数" << endl;
	}
	int _year;
	int _month;
	int _day;
};
//相等
bool Equal(Date x, Date y)
{
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
}
//大于
bool Greater(Date x, Date y)
{
	if (x._year > y._year)
	{
		return true;
	}
	else if (x._year == y._year && x._month > y._month)
	{
		return true;
	}
	else if (x._year == y._year && x._month == y._month && x._day > y._day)
	{
		return true;
	}
	else
		return false;
}
int main()
{
	Date a(2024,1,3);
	Date b(2024, 1, 5);
	cout << Equal(a, b) << endl;
	return 0;
}

在这里插入图片描述
我们如果要比较这些自定义类型就有可能要写成函数,但是不太方便,所以c++改变了一些

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

//相等
bool operator==(Date x, Date y)
{
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
}
//大于
bool operator>(Date x, Date y)
{
	if (x._year > y._year)
	{
		return true;
	}
	else if (x._year == y._year && x._month > y._month)
	{
		return true;
	}
	else if (x._year == y._year && x._month == y._month && x._day > y._day)
	{
		return true;
	}
	else
		return false;
}

函数名就更改过成这样的,使用这个函数方法有两种,一种是直接写函数名直接调用

另一种
在这里插入图片描述
这里使用a ==b 就是 operator==(x, y)的简写,需要注意的是 << 的优先级比 == 、>…高。

函数重载和运算符重载两者毫不相关,函数重载允许参数不同的同名函数，而运算符重载允许自定义类型直接使用运算符
我们还可以在类里面写

#include<iostream>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	//构造函数
	Date(int year, int month, int day)
	{
		cout << "构造函数" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	//浅拷贝
	Date(const Date& d1)
	{
		cout << "拷贝" << endl;
		_year = d1._year;
		_month = d1._month;
		_day = d1._day;
	}
	//析构函数
	~Date()
	{
		cout << "析构函数" << endl;
		cout << _year << '-' << _month << '-' << _day << endl;
	}

	//相等
	bool operator==(Date& y)
	{
		return _year == y._year
			&& _month == y._month
			&&_day == y._day;
	}
private:
	int _year;
	int _month;
	int _day;
	//大于
	bool operator>(Date& y)
	{
		if (_year > y._year)
		{
			return true;
		}
		else if (_year == y._year && _month > y._month)
		{
			return true;
		}
		else if (_year == y._year && _month == y._month && _day > y._day)
		{
			return true;
		}
		else
			return false;
	}
	void exchengtime(int* a)
	{
		if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
			a[2] = 29;
		else
			a[2] = 28;
	}
	Date& operator+=(int day)//这里返回引用是防止对象拷贝返回
	{
		int a[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
		_day += day;
		exchengtime(a);
		while (_day > a[_month])
		{
			_day -= a[_month];
			_month++;
			if (_month > 12)
			{
				_year++;
				exchengtime(a);
				_month %= 12;
			}

		}
		return *this;
	}
};
int main()
{
	Date a(2024,1,3);
	Date b(2024, 1, 5);
	cout << (a == b) << endl; // a.operator==(b)  -> a.operator==(&a, b)
	a += 363;
	return 0;
}

赋值运算符重载

有时候就是我们会看见到i = 5; j = 20;
我们有时需要对对象进行赋值

#include<iostream>
//using namespace std;
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	//构造函数
	Date(int y, int m, int d)
	{
		_year = y;
		_month = m;
		_day = d;

	}
	//拷贝
	Date(const Date& d1)
	{
		_year = d1._year;
		_month = d1._month;
		_day = d1._day;
	}
	//析构函数
	~Date()
	{
		cout << _year << endl;
		cout << _month << endl;
		cout << _day << endl;
	}
	Date& operator=(const Date& d1)
	{
		//防止自己给自己赋值(特别是深拷贝的时候)
		if (this != &d1)
		{
			_year = d1._year;
			_month = d1._month;
			_day = d1._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	int a = 10;
	cout << a << endl;
	Date d1(2024, 1, 15);
	Date d2(2024,1,16);
	Date d3(2024,1,17);
	d3 = d1 = d2;


	return 0;
}

这样就可以不使用到拷贝构造,
还需要注意的是operator=是默认成员函数,不写编译器会默认生成,跟拷贝构造的行为类似,对内置类型进行值拷贝,自定义类型调用他的赋值

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

#pragma once
#include<iostream>
#include<assert.h>
using std::cout;
using std::endl;
using std::cin;
class Date
{
public:
	//构造函数
	Date(int y = 2024, int m = 1, int d = 15);
	//拷贝
	Date(const Date& d1);
	//析构函数
	~Date();

	int Getmonthday(int year, int month);

	bool operator<(const Date& d1);
	bool operator>(const Date& d1);
	bool operator==(const Date& d1);
	bool operator<=(const Date& d1);
	bool operator>=(const Date& d1);

	Date& operator=(const Date& d1);
	Date& operator+=(int day);
	Date operator+(int day);
	
private:
	int _year;
	int _month;
	int _day;
};

test.cpp

#include"Date.h"
Date::Date(int y, int m, int d)
{
	_year = y;
	_month = m;
	_day = d;
	if (_year < 0 || _month < 1 || _month >12 || _day > Getmonthday(_year, _month) || _day < 0)
	{
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << "非法日期" << endl;
		exit(-1);
	}

}
int Date::Getmonthday(int year, int month)
{
	int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
	{
		monthday[2] = 29;
	}
	return monthday[month];

}
//拷贝
Date::Date(const Date& d1)
{
	_year = d1._year;
	_month = d1._month;
	_day = d1._day;
}
//析构函数
Date::~Date()
{
	cout << _year << endl;
	cout << _month << endl;
	cout << _day << endl;
}
Date& Date::operator=(const Date& d1)
{
	//防止自己给自己赋值(特别是深拷贝的时候)
	if (this != &d1)
	{
		_year = d1._year;
		_month = d1._month;
		_day = d1._day;
	}
	return *this;
}
Date& Date::operator+=(int day)
{
	*this = *this + day;
	return *this;
}
Date Date::operator+(int day)
{
	Date tmp(*this);
	int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	tmp._day += day;
	if ((tmp._year % 4 == 0 && tmp._year % 100 != 0) || (tmp._year % 400 == 0))
	{
		monthday[2] = 29;
	}
	else
	{
		monthday[2] = 28;
	}
	while (tmp._day - monthday[tmp._month] > 0)
	{
		
		tmp._day -= monthday[tmp._month];
		tmp._month++;
		if (tmp._month > 12)
		{
			tmp._month %= 12;
			tmp._year++;
			if ((tmp._year % 4 == 0 && tmp._year % 100 != 0) || (tmp._year % 400 == 0))
			{
				monthday[2] = 29;
			}
			else
			{
				monthday[2] = 28;
			}
		}
	}
	return tmp;


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

}
bool Date::operator==(const Date& d1)
{
	return _year == d1._year && _month == d1._month && _day == d1._day;
}
bool Date::operator<=(const Date& d1)
{
	return (*this) < d1 || (*this) == d1;
}
bool Date::operator>(const Date& d1)
{
	return !((*this) <= d1);
}
bool Date::operator>=(const Date& d1)
{
	return !((*this)< d1);
}

test1.cpp

#include"Date.h"
int main()
{
	Date d1(2024, 1, 3);
	Date d2(2024,1,16);
	Date d3(2020,1,17);
	int a = d1 == d2;
	cout << a << endl;
	a = d1 >= d2;
	cout << a << endl;
	a = d1 <= d2;
	cout << a << endl;
	d3 += 366;
	return 0;
}

需要注意的是代码中的**operator+(int day)**函数 和 **operator+=(int day)**函数的效率是很低效的
在这里插入图片描述
这张图里面可以说明,上图的代码的对象拷贝是次数多,造成了效率的低效,
对象的赋值进行了一次拷贝对象
*this + day 创建了一个临时的 Date 对象，表示当前对象的值加上 day 天的结果。*this = … 将上面提到的临时对象的值赋给了当前对象 *this。这个赋值操作涉及到对象的拷贝。赋值操作符 = 的行为是根据类的定义而定的，，它会执行对象的成员逐个拷贝。

实现 - 和-=
这里的实现方法和上面的方法是不一样的，

Date& Date::operator-=(int day)
{
	_day -= day;
	int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
	{
		monthday[2] = 29;
	}
	else
	{
		monthday[2] = 28;
	}
	while (_day <= 0)
	{
		_month--;
		
		if (_month <= 0)
		{
			_year--;
			if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
			{
				monthday[2] = 29;
			}
			else
			{
				monthday[2] = 28;
			}
			_month = 12;
		}
		_day += monthday[_month];

	}
	return *this;


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


}

可以看看这里，这里的情况就是，在operator-函数里面套用operator-=，这样的效率就变高了

实现++
前置++

Date& Date::operator+=(int day)
{
	_day += day;
	int monthday[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
	{
		monthday[2] = 29;
	}
	else
	{
		monthday[2] = 28;
	}
	while (_day - monthday[_month] > 0)
	{
		_day -= monthday[_month];
		_month++;
		if (_month > 12)
		{
			_month %= 12;
			_year++;
			if ((_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0))
			{
				monthday[2] = 29;
			}
			else
			{
				monthday[2] = 28;
			}
		}

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

后置++
后置++不能和上面写的一样,因为要构成重载，我们只能从参数那里下手，不然就会无法构成重载，

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

}

编译器链接的时候，函数的名字只和函数的名字和函数的参数类型有关，跟函数的形参名字没有关系。
就是说c++的函数在链接的时候有自己的函数名修饰规则，
在这里插入图片描述

cout的流提取(<<)

小解释
我们在使用std::cout的打印不同类型是不需要和C语言写出格式符,
在这里插入图片描述
我们使用iostram头文件,主要就是里面定义了对象,
我们顺着点击
在这里插入图片描述
在这里插入图片描述
就会看到下图
在这里插入图片描述
可以看到定义了很多函数,简单的来说就是函数重载,类型匹配,进而就解释了cout支持流提取,cout是一个对象,
那我们来函数重载一个流提取

void Date::operator<<(ostream& out)
{
	out << _year << "-" << _month << "-" << _day << endl;
}

out相当于我们把std::cou传入,

cout的小例子
我们有时候在使用cout打印一个自定义类型的变量时,会出错,例如

Date A;//Date是一个类,A是对象
cout<<A;

如果我们这样写的话会报错,因为cout的类方法是没有写这样的双操作数运算符符重载的,
如果我们按照刚刚写的日期类的流提取的函数重载,
可以这样
在这里插入图片描述
这样可以正常输出，因为双操作数运算符的第一个参数是左操作数，第二个参数是右操作数，我们这个日期类的流提取函数重载的第一个参数就是this这个隐藏的参数
void Date::operator<<(Date * const this ，ostream& out)
这样实现的话虽然没有错，但是不方便理解，运算符重载也没有规定在类之外不能进行重载，所以我们可以在类外进行运算符重载

void operator<<(ostream& out, const Date& A)
{
	out << A._year << "-" << A._month << "-" << A._day << endl;
}

需要把Date的类成员进行public权限才能成功运行
友元函数
或者我们可以写一个友元函数
友元函数 :既可以是不属于任何类的非成员函数,也可以是另一个类的成员函数 ,统称为友元函数

//友元函数
friend void operator<<(ostream& out, const Date& A)
{
	out << A._year << "-" << A._month << "-" << A._day << endl;
}

这个函数是在类定义的，但是不是成员函数,
如果在类之外定义不用加Data::这个

我们还知道

cout << a<< b<<endl;

支持这样的上面写的不支持,如果要改动,就把返回类型改为ostream&
在这里插入图片描述
这样就可以支持了

流插入

//流插入
	friend istream& operator>>(istream& out, Date& A)
	{
		out >> A._year;
		out >> A._month;
		out >> A._day;
		cout << A;
		return out;
	}

小总结
一般的运算符一般实现成成员函数,而流插入和流提取必须实现全局,这样才能让流对象作为第一个参数.

流是为解决自定义类型的输入和输出问题,C语言的printf 、scanf只能解决内置类型,无法解决自定义类型的输入输出问题

const成员函数

我们在C语言知道，const修饰的变量是改变不了，如果是强行改变那就另当别论了，需要注意的是权限可以平移和缩小，但是不能放大，也就是说，const修饰的变量可以传参给const修饰的变量（权限平移）， 非const修饰的变量可以传参给const修饰的变量（权限缩小）， 但是不能const修饰的变量可以传参给非const修饰的变量（权限放大）
那么在cpp中是怎么使用const，会有怎么样的效果呢？

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
在这里插入图片描述
这里我定义一个const修饰的对象，一个是没有const修饰的对象，

当我们写出下面代码
在这里插入图片描述
会发现有报错,为啥会这样呢

在这里插入图片描述
在这个运算符重载中,this这个参数是没有被const修饰过的,被const修饰过的A使用没有被const的成员函数,就会报错,
所以这里有个结论:

  1. const对象，不能调用非const成员函数,只能调用const成员函数(权限的平移)
  2. 普通对象可以调用非const成员函数,也可以调用const成员函数(权限的平移和缩小)

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

//取地址操作符重载
Date* Date::operator&()
{
	return this;
}
//主要为了适应const对象取地址操作符重载,
const Date* Date::operator&()const
{
	return this;
}

这两个是默认成员函数一般不用重新定义 ，编译器默认会生成。
除非因为自己有想法,可以进行重载,这样可以恶搞一下其他人

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1496222.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

部署YOLOv8模型的实用常见场景

部署YOLOv8模型的实用常见场景

可以的话&#xff0c;GitHub上点个小心心&#xff0c;翻不了墙的xdm&#xff0c;csdn也可以点个赞&#xff0c;谢谢啦 车流量检测&#xff08;开源代码github&#xff09;&#xff1a; test3 meiqisheng/YOLOv8-DeepSORT-Object-Tracking (github.com) 车牌检测&#xff0…
阅读更多...
代码随想录算法训练营第11天

代码随想录算法训练营第11天

20. 有效的括号 方法&#xff1a; 1. 如果 !st.empty() return false2.如果st.top() ! s[i] return false3. 如果 st.empty() return false注意&#xff1a; 以下这种写法 不满足 题目要求的第二点&#xff0c;不能以正确的顺序闭合 if(s[i] st.top()){return true;s…
阅读更多...
openssl调试记录

openssl调试记录

openssl不能直接解密16进制密文&#xff0c;需要把密文转化成base64格式才能解密 调试记录如下&#xff1a;
阅读更多...
【必读】产品经理必须要熟练掌握的五类产品管理框架

【必读】产品经理必须要熟练掌握的五类产品管理框架

产品管理从其传统根源已经走过了很长一段路&#xff0c;不断发展以适应现代企业的步伐和需求。随着产品变得更加复杂&#xff0c;用户的需求更加细致&#xff0c;用于指导这些产品的框架需要升级。请阅读本文&#xff0c;深入了解从字面上看改变了产品管理游戏规则的结构。 01.…
阅读更多...
越南、泰国发稿案例分析：CloudNEO专家级海外新闻传播矩阵

越南、泰国发稿案例分析：CloudNEO专家级海外新闻传播矩阵

在东南亚地区&#xff0c;越南和泰国作为经济增长迅速、市场潜力巨大的国家&#xff0c;吸引着越来越多的国际企业进驻和投资。在这个充满机遇和挑战的市场中&#xff0c;有效的新闻传播成为企业赢得市场份额和建立品牌形象的关键一环。CloudNEO作为专业的海外新闻传播服务提供…
阅读更多...
事务 失效的八种情况

事务 失效的八种情况

在某些业务场景下&#xff0c;如果一个请求中&#xff0c;需要同时写入多张表的数据。为了保证操作的原子性&#xff08;要么同时成功&#xff0c;要么同时失败&#xff09;&#xff0c;避免数据不一致的情况&#xff0c;我们一般都会用到 spring 事务。 确实&#xff0c;sprin…
阅读更多...
docker-compose Install ONLYOFFICE

docker-compose Install ONLYOFFICE

ONLYOFFICE 前言 ONLYOFFICE 是一款全面的协作办公软件套件，集成了文档处理、电子表格和演示文稿等功能，为团队提供了无缝协作的工作环境。其功能强大，操作简便，是各种规模和类型的团队的首选工具。 功能介绍 多人协作：ONLYOFFICE 提供实时协作功能，让团队成员可以同时…
阅读更多...
【设计模式 04】建造者模式

【设计模式 04】建造者模式

如果要构建的对象很复杂&#xff0c;那么可以将整个构建过程拆分成多个步骤&#xff0c;并为每一个步骤定义一个抽象的接口。并添加一个指导者用来控制构建产品的顺序和步骤。 Java实现&#xff1a; // 产品类 class Product {private String part1;private String part2;pub…
阅读更多...
vue3+ts项目创建 使用npm create vue@latest

vue3+ts项目创建 使用npm create vue@latest

npm create vuelatest相关创建代码&#xff1a;
阅读更多...
android基础学习

android基础学习

从上面的描述就可以知道&#xff0c;每一个Activity组件都有一个对应的ViewRoot对象、View对象以及WindowManager.LayoutParams对象。这三个对象的对应关系是由WindowManagerImpl类来维护的。具体来说&#xff0c;就是由WindowManagerImpl类的成员变量mRoots、mViews和mParams所…
阅读更多...
onnxruntime模型部署(二)C++部署手写数字识别

onnxruntime模型部署(二)C++部署手写数字识别

导出onnx模型 模型链接&#xff1a; 夸克网盘链接 百度网盘链接&#xff0c;提取码&#xff1a;8fkb 环境配置 OpenCV配置 自行百度 onnxruntime C版配置 有两种方法&#xff0c;一种是下载源码自己编译&#xff0c;还有一种是使用预编译好的文件。众说周知&#xff0c;…
阅读更多...
Vue深度教程

Vue深度教程

一、Vue简介 1.简介 2.快速上手 二、基础 1.创建一个Vue应用 2.模板语法 3.响应式基础 4.计算属性 5.Class与 Style绑定 6.条件渲染 7.列表渲染 8.事件处理 9.表单输入绑定 10.生命周期钩子 11.侦听器 12.模板引用 13.组件基础 三、深入组件 1.组件注册 2.Props 3.组件事件 …
阅读更多...
xinput1_3.dll丢失都有什么办法可以有效的解决、xinput1_3.dll导致游戏不能启动怎么办？

xinput1_3.dll丢失都有什么办法可以有效的解决、xinput1_3.dll导致游戏不能启动怎么办？

使用电脑的过程中是不是会遇到关于某个dll文件丢失的提示&#xff0c;今天想和大家聊的是xinput1_3.dll文件&#xff0c;如果电脑提示xinput1_3.dll丢失有什么办法可以有效的解决&#xff0c;解决办法都有哪些&#xff0c;如果xinput1_3.dll丢失会对电脑有什么影响。&#xff0…
阅读更多...
详解高质量增长的关键动力：ABM、数据、AI与业财融合

详解高质量增长的关键动力：ABM、数据、AI与业财融合

企业要穿越周期&#xff0c;不能仅靠节衣缩食&#xff0c;增长与盈利仍是必须。当盲目做大规模无法带来可持续发展&#xff0c;高质量增长便成为必须。在降本增效之上&#xff0c;企业需要变革增长模式。 在纷享销客的《领创者》开年直播上&#xff0c;纷享销客联合创始人、经…
阅读更多...
OpenHarmony下musl编译工具链普法

OpenHarmony下musl编译工具链普法

OpenHarmony下musl编译工具链普法 引言 欠的债总是要还的&#xff0c;这不前面欠的关于OpenHarmony下musl相关的还是要还的。这里我对其中的相关知识点&#xff0c;梳理&#xff0c;归纳重新消化下&#xff01; 一.GCC/Clang/LLVM的区别与联系 说实话&#xff0c;这块我现在都…
阅读更多...
streamlit学习-如何播放HLS视频(streamlit嵌入html)

streamlit学习-如何播放HLS视频(streamlit嵌入html)

streamlit学习-如何播放HLS视频 一.效果二.直播环境搭建(仅供演示)1.生成m3u82.搭建http服务器(支持跨域)3.验证hls(VLC播放 http://localhost:8000/playlist.m3u8) 三.streamlit demo 本文演示了streamlit如何实现hls直播[streamlit中嵌入html] 一.效果 二.直播环境搭建(仅供演…
阅读更多...
vue+Nodejs+Koa搭建前后端系统（九）-- 上传图片

vue+Nodejs+Koa搭建前后端系统（九）-- 上传图片

web2.0的到来使网页世界正式进入了寒武纪&#xff0c;各式各样的多媒体资源屡见不鲜&#xff0c;上传资源变得刻不容缓&#xff01; 前言 本文是在该系列的基础上&#xff0c;针对前后端代码的修改。 准备 HTTP上传图片时Content-Type值常见的有2种&#xff1a;application…
阅读更多...
spring boot3token拦截器链的设计与实现

spring boot3token拦截器链的设计与实现

⛰️个人主页: 蒾酒 &#x1f525;系列专栏&#xff1a;《spring boot实战》 &#x1f30a;山高路远&#xff0c;行路漫漫&#xff0c;终有归途。 目录 写在前面 流程分析 需要清楚的 实现步骤 1.定义拦截器 2.创建拦截器链配置类 3.配置拦截器链顺序 4.配置拦截…
阅读更多...
OpenAI反击Elon Musk

OpenAI反击Elon Musk

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
Ribbon实现Cloud负载均衡

Ribbon实现Cloud负载均衡

安装Zookeeper要先安装JDK环境 解压 tar -zxvf /usr/local/develop/jdk-8u191-linux-x64.tar.gz -C /usr/local/develop 配置JAVA_HOME vim /etc/profile export JAVA_HOME/usr/local/develop/jdk1.8.0_191 export PATH$JAVA_HOME/bin:$PATH export CLASSPATH.:$JAVA_HOM…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023