类和对象（中）

目录

1.类的6个默认成员函数

2.构造函数

2.1 概念

2.2 特性

3.析构函数

3.1 概念

3.2 特性

4.拷贝构造函数

4.1 概念​

4.2 特性

5.赋值运算符重载

5.1 运算符重载 （重要）

5.2 赋值运算符重载

5.3 Date类的其他运算符重载

6.const成员函数

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

 

1.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

​

2.构造函数

2.1 概念

对于以下Date类：

class Date
{
public:
    void Init(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;
};
​
int main()
{
    Date d1;
    d1.Init(2022, 7, 5);
    d1.Print();
    Date d2;
    d2.Init(2022, 7, 6);
    d2.Print();
    return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，一方面是有点麻烦，另一方面还可能有所遗忘，那能否在对象创建时，就将信息设置进去呢？

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

2.2 特性

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

特性如下：

  1. 函数名与类名相同。

  2. 无返回值。

  3. 对象实例化时编译器自动调用对应的构造函数。

  4. 构造函数可以重载

class Date
{
public:
    // 1.无参构造函数
    Date()
    {}
    // 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); // 调用带参的构造函数
​
    //Date d3();//错误 
}

注意：无参构造函数的调用不要加()，否则就成了函数声明。

‍

构造函数是6大默认成员函数之一，我们不写时编译器自动生成 。

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

class Date
{
public:
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
​
int main()
{
    Date d1;
​
    return 0;
}

上述代码我们不写构造函数仍然可以编译通过，因为编译器生成了一个无参的默认构造函数。

但我们一旦示定义一个有参的构造函数呢？

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;
};
​
int main()
{
    Date d1;
    return 0;
}

代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成默认的无参构造，Date没有合适的默认构造函数可用。

‍

但是我们发现：d对象经过编译器生成的默认构造后，三个成员依然是随机值，没有初始化，这是编译器没有生成默认构造吗？主要因为：

  • 编译器默认生成的构造函数，针对内置类型不做处理，针对自定义类型去调用自定义类型的默认构造。

  1. 内置类型：C/C++自带的类型，int......指针（任何类型的指针都是内置类型）

  2. 自定义类型：struct/class

所以不是没有生成构造函数，而是因为Date类的成员全是内置类型，生成的默认构造没有处理。

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;//调用Time类的默认构造
};
​
int main()
{
    Date d;
    return 0;
}

如果自定义类型没有可用的默认构造，比如用户自己定义了一个有参的构造，此时编译报错。

class Time
{
public:
    Time(int hour, int minute, int second)
    {
        cout << "   Time(int hour, int minute, int second)" << endl;
        _hour = hour; 
        _minute = minute; 
        _second = second; 
    }
private:
    int _hour;
    int _minute;
    int _second;
};
​
class Date
{
private:
    // 基本类型(内置类型)
    int _year;
    int _month;
    int _day;
    // 自定义类型
    Time _t;
};
​
int main()
{
    Date d;
    return 0;
}

‍

内置类型和自定义类型 没有做到统一，可以认为是早期C++语法设计时的一个缺陷，针对这个缺陷，C++11打了补丁：内置类型的成员变量可以给一个默认值，默认构造时使用默认值初始化对象。

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 = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
​
int main()
{
    Date d;
    return 0;
}

‍

  • 默认构造函数有哪些？（特点：不传参数就可以调用）

  1. 我们不写，编译器自动生成的默认构造函数。

  2. 我们显示定义的无参构造函数。

  3. 我们显示定义的全缺省构造函数。（有参构造和无参构造都能用，最常用）

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. 一般的类都需要我们自己写默认构造函数，不让编译器自动生成；显示定义一个全缺省的默认构造，这样无参和有参都能使用。

  2. 特殊情况下也会使用编译器默认生成的，如：类中成员变量全是自定义类型（比如MyQueue类，里面全是Stack类）或者自定义类型较多（内置类型使用C++11的补丁）。

‍

3.析构函数

3.1 概念

一个类的Destory函数类似Init函数，使用上有诸多不便，而且相比Init函数更容易忘记使用并且造成内存泄露，这是C语言的一个缺陷，针对这个缺陷C++设计了析构函数 。

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

3.2 特性

  1. 析构函数名是在类名前加上字符 ~。

  2. 无参数无返回值类型。

  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

‍

析构函数剩余的其它特性和构造函数完全相同：

  • 我们不写，编译器默认生成一个析构函数；默认生成的析构函数针对内置类型不做处理（内置类型本身也不需要清理，系统直接将其内存回收即可），针对自定义类型去调用自定义类型的析构函数。

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};

int main()
{
	Date d;
	return 0;
}

‍

  • 涉及资源申请的类（也就是从堆中malloc、relloc出一块空间）的析构函数，一定要用户自己显示写，否则造成内存泄漏。

涉及资源申请的类，必定会malloc/relloc出一块空间并交给一个指针（指针是内置类型）来维护这块空间，编译器默认生成的析构函数不处理内置类型，所申请的空间没有得到释放，造成内存泄漏。

typedef int STDateType;

class Stack
{
public:
	//构造函数，显示写一个全缺省的
	Stack(int capacity = 4)
	{
		_a = (STDateType*)malloc(capacity * sizeof(STDateType));
		_top = 0;
		_capacity = capacity;
	}

	//析构函数，一定要显示写，否则造成内存泄漏
	~Stack()
	{
		free(_a);
		_top = 0;
		_capacity = 0;
	}

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

  • 总结

  1. 需要写析构的：有涉及资源申请的内置类型（指针），如Stack类。

  2. 不需要写析构的，编译器默认生成的够用：

    1.类中全是自定义类型，比如MyQueue类；

    2.类中全是没有涉及资源申请的内置类型，比如Date类。

  3. 总结下来：没有涉及资源申请的指针需要手动释放，编译器默认生成的够用。

‍

4.拷贝构造函数

4.1 概念​

创建对象时，可以创建一个与已存在对象一某一样的新对象。

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

  1. 使用引用：相比传值，传引用效率更高（而且只能传引用，下面解释）。

  2. 使用const引用：

    一方面可以防止误操作修改了参数的对象引用。

    另一方面可以让const对象的引用 也传进来进行拷贝。

4.2 特性

  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;
	}
/*
	Date(const Date d)//错误写法
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
*/
private:
	int _year;
	int _month;
	int _day;
};

‍

拷贝构造函数剩余的其它特性和构造函数相同：

  • 我们不写，编译器默认生成一个拷贝构造函数；默认生成的拷贝构造函数针对内置类型是按照字节方式直接拷贝的，针对自定义类型去调用自定义类型的拷贝构造函数。

默认的拷贝构造函数，对象会根据内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。（这里也是兼容了C结构体的拷贝）

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}

	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time::Time(const Time&)" << endl;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};

int main()
{
	Date d1;

	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
	Date d2(d1);
	return 0;
}

‍

那么编译器默认生成的这种简单值拷贝（浅拷贝）的方式有没有缺陷呢？当然有！

typedef int STDateType;

class Stack
{
public:
	//构造函数，显示写一个全缺省的
	Stack(int capacity = 4)
	{
		_a = (STDateType*)malloc(capacity * sizeof(STDateType));
		_top = 0;
		_capacity = capacity;
	}

	//编译器默认生成的拷贝构造会这么做：
	/*Stack(const Stack& s)
	{
		_a = s._a;
		_top = s._top;
		_capacity = s._capacity;
	}*/

	//析构函数，一定要显示写，否则造成内存泄漏
	~Stack()
	{
		free(_a);
		_top = 0;
		_capacity = 0;
	}

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

int main()
{
	Stack s1;
	Stack s2(s1);

	return 0;
}

我们发现程序直接崩溃了，这是为什呢？

​

总结来说：

  1. 涉及资源申请的类一旦使用浅拷贝，两个对象中维护动态开辟空间的指针会一模一样，析构时会对同一块空间重复释放，导致程序崩溃。（这也是C语言中潜在的并无法解决的问题）

  2. 还有一个问题，就是两个对象的指针都指向同一块空间，一个对象修改空间中的内容会影响到另一个对象，这明显扯淡。

所以:

  • 类中一旦涉及到资源申请，拷贝构造函数是一定要写的，否则就是浅拷贝。

那么我们怎么写呢？使用深拷贝!就是重新开辟一块空间，不共用一块空间。

typedef int STDateType;

class Stack
{
public:
	//构造函数，显示写一个全缺省的
	Stack(int capacity = 4)
	{
		_a = (STDateType*)malloc(capacity * sizeof(STDateType));
		_top = 0;
		_capacity = capacity;
	}

	//编译器默认生成的拷贝构造会这么做：
	/*Stack(const Stack& s)
	{
		_a = s._a;
		_top = s._top;
		_capacity = s._capacity;
	}*/

	Stack(const Stack& s)
	{
		_top = s._top;
		_capacity = s._capacity;

		_a = (STDateType*)malloc(sizeof(STDateType) * _capacity);
		memcpy(_a, s._a, sizeof(STDateType) * _capacity);
	}


	//析构函数，一定要显示写，否则造成内存泄漏
	~Stack()
	{
		free(_a);
		_top = 0;
		_capacity = 0;
	}

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

int main()
{
	Stack s1;
	Stack s2(s1);

	return 0;
}

‍

  • 总结：

  1. 需要写拷贝构造的：有涉及资源申请的内置类型（指针），如Stack类，我们要写一个深拷贝。

  2. 不需要写拷贝构造的，编译器默认生成的就可以用：

    1.类中全是自定义类型，比如MyQueue类，自动调用Stack的拷贝构造 ；

    2.类中全是没有涉及资源申请的内置类型，比如Date类，简单的值拷贝就可以。

‍

  • 拷贝构造的使用场景

    1. 使用已存在对象创建新对象

    2. 函数参数类型为类类型对象

    3. 函数返回值类型为类类型对象

class Date
{
public:
	Date(int year, int minute, int day)
	{
		cout << "Date(int,int,int):" << this << endl;
	}

	Date(const Date& d)
	{
		cout << "Date(const Date& d):" << this << endl;
	}

	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

Date Test(Date d)
{
	Date temp(d);
	return temp;
}

int main()
{
	Date d1(2022,1,13);
	Test(d1);
	return 0;
}

​

5.赋值运算符重载

5.1 运算符重载 （重要）

C语言中我们想要比较两个结构体，只能写一个函数来比较，而且相比与内置类型可以直接使用==运算符比较，函数比较方式的可读性并不强。

C++为了增强代码的可读性引入了运算符重载，运算符重载可以让自定义类型对象像内置类型变量那样使用运算符，是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

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

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

注意：

  1. 不能通过连接其他符号来创建新的操作符：比如operator@。

  2. 重载操作符必须有一个类类型参数。

  3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义。

  4. 运算符重载既可以写成全局函数（非必要情况下不建议，因为需要公开成员变量或者使用友元函数，破坏封装），也可以重载成成员函数。

  5. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this。

  6. 重载的运算符有两个操作数时，左操作数是第一个参数（重载成成员函数时，该参数作为this指针被隐藏），右操作数是第二个参数。

  7. .*、 ::、 sizeof、 ?:、 . 注意以上5个运算符不能重载。

  8. 我们重载的运算符一定是一个有意义的运算符，就比如Date类，Date+Date、Date*Date是没有意义的。

  9. 运算符重载和函数重载没有关系。

‍

我们来重载一下Date类的+=和+运算符

static int daysOfMonth[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };

int GetDayOfMonth(int year, int month)
{
	if (month == 2 &&
		((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))))
		return 29;

	return daysOfMonth[month];
}

Date& Date::operator+=(int days)
{
	if (days < 0)
		return *this -= (-days);

	_day += days;
	while (_day > GetDayOfMonth(_year, _month))
	{
		_day -= GetDayOfMonth(_year, _month);
		_month++;

		if (_month == 13)
		{
			_month = 1;
			_year++;
		}
	}
	return *this;
}

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

注意：

  1. 运算符重载的参数建议都传引用，如果不修改参数，最好传const引用：const Date& d。

  2. +=也有返回值，因为C语言的+=支持a += b += 10;这种写法。

  3. +=我们返回的是*this， *this就是调用函数的对象，出了函数作用域还在，可以用引用返回。

  4. +运算符可以复用+=运算符，使用+时对象不改变，所以拷贝构造一个临时对象tmp来复用+=，tmp是局部对象，出了作用域销毁，必须使用传值返回。

  5. +=也可以复用+，这两种复用方式的效率不同，+=复用+如下：

Date Date::operator+(int days)
{
	Date tmp(*this);
	tmp._day += days;
	while (tmp._day > GetDayOfMonth(tmp._year, tmp._month))
	{
		tmp._day -= GetDayOfMonth(tmp._year, tmp._month);
		tmp._month++; 

		if (tmp._month == 13)
		{
			tmp._month = 1;
			tmp._year++;
		}
	}
	return tmp; 
}

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

+复用+=时+会有两次拷贝（拷贝tmp一次，传值返回一次），+=复用+时+=会有三次拷贝（+有两次，赋值重载会有一次）。

5.2 赋值运算符重载

谈论两种问题：

  1. 赋值运算符重载和拷贝构造函数的区别？

    拷贝构造是用一个已经存在的对象去初始化一个新的对象，而赋值运算符重载是两个已经存在的对象进行赋值操作。

  2. 赋值运算符重载有没有返回值？

    有没有返回值就取决于C语言的=运算符有没有返回值，C语言支持连续赋值，=其实是有返回值的，所以赋值运算符重载有返回值。

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

注意一点，就是避免自己给自己赋值，直接比较指针即可。

‍

赋值运算符重载也就默认成员函数之一，其它特性和拷贝构造一模一样：

  • 参数是对本类类型对象的引用(一般常用const修饰)，返回值是T&。

  • 我们不写，编译器默认生成一个赋值运算符重载；默认生成的赋值运算符重载针对内置类型是按照字节方式直接拷贝的，针对自定义类型去调用自定义类型的赋值运算符重载。

  • 类中一旦涉及到资源申请，赋值运算符重载我们要自己写个深拷贝。

‍

  • 赋值运算符只能重载成类的成员函数不能重载成全局函数。

    原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

‍

5.3 Date类的其他运算符重载

  • -=和-：

Date& Date::operator-=(int days)
{
	if (days < 0)
		return *this += (-days); 

	_day -= days;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year--;
		}

		_day += GetDayOfMonth(_year, _month);
	}
	return *this;
}

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

  • 前置++和后置++：

    1. 前置++和后置++如何区分？后置++使用一个占位参数int来和前置++作区分，这个参数只是一个类型，没有实际意义。

    2. 后置++返回++前的值，但本身还是要++的，所以我们拷贝构造一个对象做临时值，*this自己复用+=1，然后返回我们保存的临时值。

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

//后置++
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;
}

  • -运算符（Date-Date）：

int Date::operator-(const Date& d)
{
	// 假设左大右小
	int flag = 1;
	Date max = *this;
	Date min = d;

	// 假设错了，左小右大
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}

	return n * flag;
}

  • 比较运算符：

比较运算符我们只需要实现==和>，其他运算符复用这两个即可。

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

	return true;
}

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

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

	return false;
}

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);
}

  • <<和>>运算符：

我们要打印Date类的对象d，不能总是使用d.Print()，Date类能不能重载<<和>>运算符，实现使用控制台cout和cin来打印和修改对象？

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

这是我们把<<运算符重载成成员函数，发现有以下两个问题：

  1. 运算符重载我们写成成员函数时，第一个参数是隐藏的this指针，指向要打印的对象d，而第一个参数是左操作数，所以这种情况下我们要这么使用重载的运算符：d<<cout，这明显扯淡。所以我们尝试重载成全局函数。

  2. 确定<<重载没有返回值？如果连续<<呢？所以我们要返回ostream类的对象out。

问题又来了，我们重载成全局函数，不能访问Date类的私有成员了：

​

这里有两种解决办法：1、成员变量公开 2、使用友元函数

所谓友元函数，就是该函数是类的朋友，函数就能访问类中的私有成员了。

class Date
{
public:
	//...

	//友元函数
	friend ostream&  operator<<(ostream& out, const Date& d);//cout << d1
	friend istream&  operator>>(istream& in, Date& d);//cin >> d1
private:
	//...
};

ostream&  operator<<(ostream& out, const Date& d) 
{
	out << d._year << ":" << d._month << ":" << d._day << endl;
	return out;
}

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

注意：重载>>，我们要修改d对象，所以不能加const。

‍

前四种成员函数总结：

​​​

6.const成员函数

我们知道，普通的成员函数，内部的this指针类型是（假设为Date类）Date* const this，那么这种成员函数const对象能使用吗？明显不可以！因为普通成员函数的this指向的是非const对象，const对象使用就涉及权限放大问题。

就比如这里的==运算符重载，const对象d1作为左操作数时，他的地址会传给this，this的类型是 Date* const this，涉及权限放大。

如何让const对象也能使用成员函数呢？这就要介绍const成员函数了：

在函数后加const修饰的“成员函数”称之为const成员函数；const修饰类成员函数，实际修饰的是*this，也就是this指针指向的对象。此时this的类型变成const Date * const this 。

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

	return true;
}

‍

注意：

  • 非const对象也能使用const成员函数，因为这只涉及权限缩小。但是如果同时存在const成员函数和普通成员函数，非const对象优先使用普通成员函数。

    Date Date::operator+(int days) const
{
	cout << "Date Date::operator+(int days) const" << endl;
	Date tmp(*this);
	tmp += days;
	return tmp;
}

Date Date::operator+(int days)
{
	cout << "Date Date::operator+(int days)" << endl;
	Date tmp(*this);
	tmp += days;
	return tmp;
}

    ​

  • 并不是所有成员函数我们都无脑加const，就比如+=、-=、++、--，这明显不能写成const成员函数，因为我们要修改*this，而且const对象根本不能使用以上运算符。

  • const只能修饰成员函数，不能修饰全局函数。因为const修饰的是*this，没有this指针不是扯淡吗？

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

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

	const Date* operator&() const
	{
		return this ;
	}
private :
	int _year ; 
	int _month ;
	int _day ; 
}

  • 这两个函数构成重载，一个参数是Date*，另一个参数是const Date *。

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

小Tip：&d转化成 d.operator&(&d);&d不是会无限调用吗？答案是：不会！因为编译器底层并不会加上这个形参&d，他是直接把对象的地址放入寄存器中。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux开机、重启、关机和用户登录注销

Linux开机、重启、关机和用户登录注销

1.【关机】 shutdown shutdown now 表示立即关机 shutdown -h now 表示立即关机 shutdown -h 1 表示1分钟后关机 halt 用来关闭正在运行的Linux操作系统 2.【重启】 shutdown -r now 表示立即重启 reboot 重启系统 sync …
阅读更多...
2023年免费CRM软件盘点：14款热门工具全面比较（含开源）

2023年免费CRM软件盘点：14款热门工具全面比较（含开源）

在初创企业或小型企业阶段&#xff0c;特别是在预算有限且客户管理需求较为基础的情境下&#xff0c;使用免费的CRM系统通常是一个理智的选择。这类系统虽然在功能上可能不如付费版本丰富&#xff0c;但基本的客户信息管理、销售跟踪和沟通记录等核心功能通常都能满足需求。 对…
阅读更多...
【Proteus仿真】【51单片机】贪吃蛇游戏

【Proteus仿真】【51单片机】贪吃蛇游戏

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真51单片机控制器&#xff0c;使用8*8LED点阵、按键模块等。 主要功能&#xff1a; 系统运行后&#xff0c;可操作4个按键控制小蛇方向。 二、软件设计 /* 作者&#xff1a;嗨小易…
阅读更多...
蜜罐系统HFish的部署与功能实测

蜜罐系统HFish的部署与功能实测

1. 引入 根据参考1对蜜罐的定义&#xff1a; 蜜罐&#xff08;Honeypot&#xff09;是一个计算机科学领域的术语&#xff0c;指用于检测或防御未经授权的行为或黑客攻击的陷阱。其名称来源于其工作原理类似于用来诱捕昆虫的蜜罐。蜜罐通常伪装成看似有利用价值的网路、资料、…
阅读更多...
CHS零壹视频恢复程序高级版视频修复OCR使用方法

CHS零壹视频恢复程序高级版视频修复OCR使用方法

目前CHS零壹视频恢复程序监控版、专业版、高级版已经支持了OCR&#xff0c;OCR是一种光学识别系统&#xff0c;高级版最新版本中不仅仅是在视频恢复中支持OCR&#xff0c;同时视频修复模块也增加了OCR功能&#xff0c;此功能可以针对一些批量修复的视频文件&#xff08;如执法仪…
阅读更多...
ubuntu(18.04)中架设HiGlass docker镜像服务，已尝试mcool、bedpe、wig格式文件

ubuntu(18.04)中架设HiGlass docker镜像服务，已尝试mcool、bedpe、wig格式文件

前言 使用到的软件 docker 文档 &#xff1a; https://www.docker.com/ HiGlass 文档&#xff1a;http://docs.higlass.io/higlass_docker.html#running-locally https://github.com/higlass/higlass-dockerhiglass-docker 地址&#xff1a;https://github.com/higla…
阅读更多...
【JAVA学习笔记】 57 - 本章作业

【JAVA学习笔记】 57 - 本章作业

项目代码 https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter14/src/com/yinhai/homework 1. (1)封装个新闻类&#xff0c;包含标题和内容属性&#xff0c;提供get, set方法&#xff0c; 重写toString方法&#xff0c;打印对象时只打印标题; (2)只提供…
阅读更多...
【机器学习合集】模型设计之注意力机制动态网络 -＞（个人学习记录笔记）

【机器学习合集】模型设计之注意力机制动态网络 -＞（个人学习记录笔记）

文章目录 注意力机制1. 注意力机制及其应用1.1 注意力机制的定义1.2 注意力机制的典型应用 2. 注意力模型设计2.1 空间注意力机制2.2 空间注意力模型2.3 通道注意力机制2.4 空间与通道注意力机制2.5 自注意力机制2.5 级联attention 动态网络1. 动态网络的定义2. 基于丢弃策略的…
阅读更多...
小程序day02

小程序day02

目标 WXML模板语法 数据绑定 事件绑定 那麽問題來了&#xff0c;一次點擊會觸發兩個組件事件的話&#xff0c;該怎么阻止事件冒泡呢&#xff1f; 文本框和data的双向绑定 注意点: 只在标签里面用value“{{info}}”&#xff0c;只会是info到文本框的单向绑定&#xff0c;必须在…
阅读更多...
安装docker报错：except yum.Errors.RepoError, e:

安装docker报错：except yum.Errors.RepoError, e:

问题描述&#xff1a; 在安装docker的时候&#xff0c;配置阿里云地址出现以下问题 问题原因&#xff1a; linux 系统中存在多版本的python. yum 依赖 python 2, 而个人使用 python 3 导致. 解决办法&#xff1a; 修改 /usr/bin/yum-config-manager文件中第一行 #!/usr/bin/p…
阅读更多...
arcgis图上添加发光效果！

arcgis图上添加发光效果！

看完本文， 你可以不借助外部图片素材， 让你的图纸符号表达出你想要的光！ 我们以之前的某个项目图纸为例，来介绍下让符号发光的技术！ 第一步—底图整理 准备好栅格影像底图、行政边界的矢量数据，确保“数据合适、位置正确、边界吻合”。 确定好图纸的大小、出图比例、投…
阅读更多...
字体文件名称成中的Bold, Light,Italic,Regular, Medium是什么意思？

字体文件名称成中的Bold, Light,Italic,Regular, Medium是什么意思？

解释 字体文件名&#xff1a; IntelOneMono-Bold.ttf其中IntelOneMono字体名称 Bold 字体的样式 .ttf字体后缀 样式英文 中文Bold粗体BoldItalic粗体斜体Italic斜体Light细体LightItalic斜细体Medium中等MediumItalic中等斜体Regular标准以下来自鸿蒙字体以下来自鸿蒙字体TC…
阅读更多...
深度学习_3 数据操作之线代，微分

深度学习_3 数据操作之线代，微分

线代基础 标量 只有一个元素的张量。可以通过 x torch.tensor(3.0) 方式创建。 向量 由多个标量组成的列表&#xff08;一维张量&#xff09;。比如 x torch.arange(4) 就是创建了一个1*4的向量。可以通过下标获取特定元素&#xff08;x[3]&#xff09;&#xff0c;可以通…
阅读更多...
通过Google搜索广告传送的携带木马的PyCharm软件版本

通过Google搜索广告传送的携带木马的PyCharm软件版本

导语 最近&#xff0c;一起新的恶意广告活动被发现&#xff0c;利用被入侵的网站通过Google搜索结果推广虚假版本的PyCharm软件。这个活动利用了动态搜索广告&#xff0c;将广告链接指向被黑客篡改的网页&#xff0c;用户点击链接后下载的并不是PyCharm软件&#xff0c;而是多种…
阅读更多...
WSL安装Ubuntu

WSL安装Ubuntu

先安装wsl2 安装Ubuntu 打开windows商店&#xff0c;搜索对应版本的Ubuntu&#xff0c;点击获取进度跑完后&#xff0c;点击打开&#xff0c;就可以完成安装 删除Ubuntu版本 wsl --unregister Ubuntu-18.04安装位置迁移 正常情况下Ubuntu是被安装在C盘&#xff0c;我们需要…
阅读更多...
解决pycharm中，远程服务器上文件找不到的问题

解决pycharm中，远程服务器上文件找不到的问题

一、问题描述 pycharm中&#xff0c;当我们连接到远程服务器上时。编译器中出现报错问题&#xff1a; cant open file /tmp/OV2IRamaar/test.py: [Errno 2] No such file or directory 第二节是原理解释&#xff0c;第三节是解决方法。 二、原理解释 实际上这是由于我们没有设置…
阅读更多...
优先队列----数据结构

优先队列----数据结构

概念 不知道你玩过英雄联盟吗&#xff1f;英雄联盟里面的防御塔会攻击离自己最近的小兵&#xff0c;但是如果有炮车兵在塔内&#xff0c;防御塔会优先攻击炮车&#xff08;因为炮车的威胁性更大&#xff09;&#xff0c;只有没有兵线在塔内时&#xff0c;防御塔才会攻击英雄。…
阅读更多...
Leetcode刷题详解——两两交换链表中的节点

Leetcode刷题详解——两两交换链表中的节点

1. 题目链接&#xff1a;24. 两两交换链表中的节点 2. 题目描述&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 …
阅读更多...
【机器学习】一、机器学习概述与模型的评估、选择

【机器学习】一、机器学习概述与模型的评估、选择

机器学习简介 由来 阿瑟.萨缪尔Arthur Samuel,1952年研制了一个具有自学习能力的西洋跳棋程序&#xff0c;1956年应约翰.麦卡锡John McCarthy&#xff08;人工智能之父&#xff09;之邀&#xff0c;在标志着人工智能学科诞生的达特茅斯会议上介绍这项工作。他发明了“机器学习…
阅读更多...
GitHub项目监控

GitHub项目监控

目录 github开放平台接口限流 监控某个仓库的更新状态 对于常用Github的用户来说&#xff0c;经常有一些自动化的需求。比如监控某些项目的更新情况并实时拉取&#xff0c;比如监控github全网上传的代码是否携带了公司的APIKEY&#xff0c;SECRETKEY等… github开放平台 gith…
阅读更多...
最新文章

Copyright @ 2022~2023