类和对象(下)

敲上瘾

于 2024-08-04 11:53:54 发布

阅读量696

点赞数 53

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2302_80105876/article/details/140790868

版权

一、默认成员函数

默认构造也就是即使自己不写编译器也会默认生成的函数，直接用就可以。不过有的时候并不靠谱，它无法完成深拷贝，还需要自己来完成。

1.构造函数

构造函数是默认成员函数之一，它的作用主要是完成对象的初始化。

特点：

没有返回值，在自己写的时候也不需要写返回值类型void
直接用类名做函数名
构造函数可以重载。
如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤户显式定义编译器将不再⽣成。

其中⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。

我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤初始化列表才能解决。

2.析构函数

主要是完成清理工作，这个函数会在对象的主调函数结束的时候编译器会自动调用释放内存，一般这个函数都不需要自己写编译器会默认生成，对于动态申请的内存空间还需我们手动写一个析构函数去进行内存的释放。

特点：

没有返回值，在自己写的时候也不需要写返回值类型void
类名前面加~做为函数名
对象⽣命周期结束时，系统会⾃动调⽤析构函数。
跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会调⽤它的析构函数。
⼀个局部域的多个对象，C++规定后定义的先析构

3.拷贝构造函数

在定义对象的同时把另一个对象赋给它的时候编译器会自动调用拷贝构造函数，或着函数返回一个对象的时候也会进行调用。它主要是完成数据的拷贝。要与它区别的是赋值运算符重载函数，在已定义的对象进行赋值操作时调用的是赋值运算符重载函数，而在定义对象进行赋值操作的时候调用的是拷贝构造函数。

二、运算符重载

当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
运算符重载是具有特名字的函数，他的名字是由operator后⾯加要定义的运算符。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。
重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数⽐运算对象少⼀个。
运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
不能通过连接语法中没有的符号来创建新的操作符，⽐如operator@。
* :: sizeof ?: . 注意以上5个运算符不能重载。
重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义。
⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，⽐如Date类重载operator-就有意义，但是重载operator+就没有意义。
重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。
重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了对象<<cout，不符合使⽤习惯和可读性。

三、const成员函数

const成员函数也就是const修饰成员函数，它放在成员函数参数列表后面，它的作用是修饰this指针，比如Date类原来隐式的this指针相当于Date* const this，用const修饰后相当于 const Date* const this。

四、初始化列表

1.初始化列表是每个成员变量定义的地方，在每定义一个对象的时候都会走一遍初始化列表，而初始化列表是编译器默认生成的，当然也可以自己写一个来替代作初始化的构造函数

2.初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成
员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式，最后还需一个{}。如果需要可以在{ }里写一些逻辑。

如下：

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

3.需要注意的是引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错。所以建议初始化变量就在初始化列表进行初始化而不用构造函数初始化。
4.C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤的。
5.初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。

6.针对static成员变量，只能在类外进行初始化，否则编译器会报错。

五、友元

1.对于私有变量，在类外是不能访问的，但有时在写类外函数又必须访问。那么可以把这个函数在类里面声明一下，并在返回类型前面加上friend，那么该函数就被称为这个类的友元函数。可以理解为你是我的朋友，我的私有可以给你用。友元类同理。
友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
        2.⼀个函数可以是多个类的友元函数。
        3.友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
        4.友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是B的友元。

类是可以嵌套使用的，类里面可以定义另一个类，而内层类是外层类的友元，反过来则不是。

六、匿名对象

匿名对象顾名思义就是在定义对象的时候没有给名字（如Date()），一个类名加一对括号就是匿名对象，匿名对象都只能使用一次，在对应的那一条语句结束后就会调用析构函数释放掉。

七、Date实现源

#define _CRT_SECURE_NO_WARNINGS 1
using namespace std;
#include<iostream>
class Date
{
public:
	// 获取某年某月的天数
	int GetMonthDay(int year, int month)
	{
		static int arr[13] = { -1,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 arr[month];
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 拷贝构造函数
  // d2(d1)
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	// 赋值运算符重载
  // d2 = d3 -> d2.operator=(&d2, d3)
	Date& operator=(const Date& d);
	// 析构函数
	~Date()
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}
	Date& operator+=(int day);
	Date operator+(int day);
	Date operator-(int day);
	Date& operator-=(int day);
	Date& operator++();
	Date operator++(int);
	Date operator--(int);
	Date& operator--();
	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);
	int operator-(const Date& d);
private:
	int _year;
	int _month;
	int _day;

};
Date& Date::operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	return (*this);
}
Date& Date::operator+=(int day)
{
	if (day < 0)
		return (*this) -= (-day);
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month > 12)
		{
			_month = 1;
			_year++;
		}
	}
	return *this;
}
Date Date::operator+(int day)
{
	Date dy = (*this);
	dy += day;
	return dy;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
		return (*this) += (-day);
	_day -= day;
	while (_day < 1)
	{
		_month--;
		if (_month < 1)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}
Date Date::operator-(int day)
{
	Date dy = (*this);
	dy -= day;
	return dy;
}
Date& Date::operator++()
{
	return (*this) += 1;
}
// 后置++
Date Date::operator++(int)
{
	Date dy = (*this);
	(*this) += 1;
	return dy;
}
// 后置--
Date Date::operator--(int)
{
	Date dy = (*this);
	(*this) -= 1;
	return dy;
}
// 前置--
Date& Date::operator--()
{
	return (*this) -= 1;
}
// >运算符重载
bool Date::operator>(const Date & d)
{
	if (_year != d._year)
		return _year > d._year;
	if (_month != d._month)
		return _month > d._month;
	if (_day != d._day)
		return _day > d._day;
	return false;
}
// ==运算符重载
bool Date::operator==(const Date& d)
{
	return _year == d._year && _month == d._month && _day == d._day;
}
// >=运算符重载
bool Date::operator >= (const Date& d)
{
	return (*this) > d || (*this) == d;
}
// <运算符重载
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);
}
// 日期-日期 返回天数
int Date::operator-(const Date& d)
{
	int f = 1;
	Date min = d, max = (*this);
	if (min > max)
	{
		max = d, min = (*this);
		f = 0;
	}
	int sum = 0;
	while (min != max)
	{
		min+=1;
		sum++;
	}
	return f ? sum : -sum;
}
int main()
{
	Date mu(2004, 7,9);
	Date fu(mu);
	fu -= 200;
	fu.Print();
	fu += 30;
	fu.Print();
	Date(fu - 30).Print();
	cout << fu - mu << endl;
	return 0;
}

敲上瘾

关注

53
点赞
踩
41

收藏

觉得还不错? 一键收藏
37
评论
类和对象(下)

我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。主要是完成清理工作，这个函数会在对象的主调函数结束的时候编译器会自动调用释放内存，一般这个函数都不需要自己写编译器会默认生成，对于动态申请的内存空间还需我们手动写一个析构函数去进行内存的释放。1.初始化列表是每个成员变量定义的地方，在每定义一个对象的时候都会走一遍初始化列表，而初始化列表是编译器默认生成的，当然也可以自己写一个来替代作初始化的构造函数。可以理解为你是我的朋友，我的私有可以给你用。
复制链接

扫一扫