C++学习第十九天：类与对象：const修饰成员函数，友元，运算符重载

一、const修饰成员函数

一）、特点

1、不可修改属性

不可以修改成员的属性，在成员函数后面加const（既不可以修改指向，也不可以修改值），本质上是修饰的this指针，而this指针本质上是指针常量（哪个对象调用该成员函数，这个this指针就指向谁，不可以修改指针指向）。

2、mutable关键字

3、常对象

常对象不可以修改成员属性，且常对象只能调用常函数（联想到静态成员函数只能访问静态成员属性）

3、总结

二、友元

一）、全局函数做友元

1、方法：在类中声明类外的全局函数是类的好朋友，在声明的前面加上friend。这样全局函数就可以访问类中私有成员属性

二）、类做友元

1、方法：在类中声明另一个类为友元，前面加friend修饰。
2、注意：类中的成员函数可以在类外实现，但是要在类中声明，在类外加类的作用域限制：building::building()

#include<iostream>
using namespace std;
#include<string>
class building
{
friend class goodgay;
public:
	string m_sitting_room;
	building();
private:
	string m_bed_room;
};
class goodgay
{
public:
	void visit(building& b)
	{
		cout << "好基友正在访问" << b.m_sitting_room << endl;
		cout << "好基友正在访问" << b.m_bed_room << endl;
	}
};
building::building()
{
	m_sitting_room = "客厅";
	m_bed_room = "卧室";
}
void test()
{
	building b1;
	goodgay g;
	g.visit(b1);
}
int main()
{
	test();
	system("pause");
	return 0;
}

在一个类中调用另一个类的成员方法
（1）类引用作为形参

class goodgay
{
public:
	void visit(building& b)
	{
		cout << "好基友正在访问" << b.m_sitting_room << endl;
		cout << "好基友正在访问" << b.m_bed_room << endl;
	}
};

（2）类作为另一个类的成员

#include<iostream>
using namespace std;
#include<string>
class goodgay;
class building
{
friend goodgay;
public:
	string m_sitting_room;
	building();
private:
	string m_bed_room;
};
class goodgay
{
public:
	building * b;
	goodgay();//构造函数初始化成员属性
	void visit();

};
building::building()
{
	m_sitting_room = "客厅";
	m_bed_room = "卧室";
}
goodgay::goodgay()
{
	b = new(building);
}
void goodgay::visit()
{
	cout << "好基友正在访问" << b->m_sitting_room << endl;
	cout << "好基友正在访问" << b->m_bed_room << endl;
}
void test()
{
	//building b;在创建g时就会调用构造函数创建b
	goodgay g;
	g.visit();
}
int main()
{
	test();
	system("pause");
	return 0;
}

三）、成员函数做友元

三、运算符重载

一）、概念

对已有的运算符重新定义，赋予其它的功能。（对于内置的数据类型，编译器知道如何进行运算。）

1、加法运算符重载

operator +（对于加法重载的统一名称）
（1）通过成员函数进行加法
（2）通过全局函数进行加法

person operator+(person& b)
	{
		person temp;
		temp.m_a = this->m_a + b.m_a;
		temp.m_b = this->m_b + b.m_b;
		return temp;
	}

本质调用：person p3=p1.operator+（p2);

#include<iostream>
using namespace std;
//加号运算符重载
//1、成员函数实现加法运算符重载
//2、全局函数实现加法运算符重载

class person
{
public:
	int m_a;
	int m_b;
	
};
//2
person operator+(person& a, person& b)
{
	person temp;
	temp.m_a = a.m_a + b.m_a;
	temp.m_b = a.m_b + b.m_b;
	return temp;
}
void test()
{
	person p1;
	p1.m_a = 20;
	p1.m_b = 30;
	person p2;
	p2.m_a = 10;
	p2.m_b = 20;
	person p3 = p1 + p2;
	cout << p3.m_a << endl;
	cout << p3.m_b << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

2、运算符重载也可以发生函数重载

3、左移运算符重载（<<）

out属于ostream类型，ostream对象有且只能有一个，所以重载时需要用引用；
由于cout只能在运算符左侧，所以只能用全局函数进行运算符重载；
想要链式输出，则需要返回ostream的引用。
左移运算符配合友元可以输出自定义运算符。

4、递增运算符重载

回忆自定义递增

前置递增

#include<iostream>
using namespace std;
//前置递增重载
//后置递增重载

class number
{
friend ostream& operator<<(ostream& cout, number& n1);
private:
	int m_a;
public:
	number(int a);
	number& operator++()
	{
		++m_a;
		return *this;
	}
};
number::number(int a)
{
	m_a = a;
}
ostream& operator<<(ostream& cout, number& n1)
{
	cout << n1.m_a << endl;
	return cout;
}
int main()
{
	number n1(10);
	cout << ++(++n1) << endl;
	system("pause");
	return 0;
}

前置递增运算符重载，返回的是引用。为了一直对一个数据进行递增，如果返回的是值，那么返回的不是本体，而是他的复制。
后置递增

#include<iostream>
using namespace std;
//前置递增重载
//后置递增重载

class number
{
	friend ostream& operator<<(ostream& cout, number& n1);
	int m_a;
public:
	number(int a)
	{
		m_a = a;
	}
	number& operator++()
	{
		++m_a;
		return *this;
	}
	number& operator++(int)//int为占位符，将后置和前置递增区分开来
	{ 
		number temp = *this;
		m_a++;
		return temp;
	}
};

ostream& operator<<(ostream& cout, number& n1)
{
	cout << n1.m_a << endl;
	return cout;
}
int main()
{
	number n1(10);
	cout << n1++ << endl;
	cout << n1 << endl;
	system("pause");
	return 0;
}