C++面对对象继承与操作符重载

类外运算符重载

class Person{
private:
	int x,y;
public:
	Person(int x, int y):x(x),y(y){}
	// set get 函数
	void setX(int x){
		this->x = x;
	}
	void setY(int y){
	this->y = y;
	}
	int getX(){
	return this->x;
	}
	int getY(){
	return this->y;
	]
}
// 把 + 重载 运算符重载，在真是开发中，基本都是写在类的里面的
Person operator + (Person p1, Person p2){
	int x = p1.getX() + p2.getX();
	int y = p1.getY() + p2.getY();
	Person res(x,y);
	retrun res;
}

int main（）{
	// 对象1+对象2 C++、java、kotlin都不支持
	//c++/kotlin 运算符重载，把+重载掉， 
	Person p1(100,200);
	Person p2(100,200);
	Person p3 = p1 + p2; //我们需要把+号重载掉 C+=/kotlin
	cout << p3.getX() << "," << p3.getY() << endl; //200 和400
	return 0;
}

类里运算符重载

class Person{
private:
	int x,y;
public:
	Person(int x, int y):x(x),y(y){}
	// set get 函数
	void setX(int x){
		this->x = x;
	}
	void setY(int y){
	this->y = y;
	}
	int getX(){
	return this->x;
	}
	int getY(){
	return this->y;
	]
	// 把 + 重载 运算符重载
	//加了 const 关键字，不能胡乱修改
	// & 引用，不会复制新的对象，相当于给Person这块内存取个别名，操作的还是同一个对象
	Person operator + (const Person  & p){
		int x = this->x + p.x;//在类里面，可以直接拿私有成员
		int y = this->y + p.y;
		return Person (x,y);
	}
	
	void operator ++(){//++对象
		this->x = this->x + 1;
		this->y = this->y + 1;
	}
	void operator ++(int){//对象++
		this->x = this->x + 1;
		this->y = this->y + 1;
	}
	
	//istream  输入 系统的
	//ostream 输出 系统的
	// 重载 <<   _START:是系统的输出
	friend void operator << (ostream & _START, Person p){
		_START << "开始输出了" << p.x << "!" << p.y << "结束了" << endl;
	}
	//返回 _START 类似链式调用返回this，同一个思路
	friend ostream & operator >> (ostream & _START, const Person & p){
	_START << "开始输出了" << p.x << "!" << p.y << "结束了" << endl;
	return _START;
	}
	
	//istream  输入 系统的
	friend istream & operator >>> (istream & _START, Person p) {
	//接收用户输入的，把输入的信息给x
		_START >>> p.x >>> p.y;
	}
}

int main（）{
	// 对象1+对象2 C++、java、kotlin都不支持
	//c++/kotlin 运算符重载，把+重载掉， 
	Person p1(100,200);
	Person p2(100,200);
	Person p3 = p1 + p2; //我们需要把+号重载掉 C+=/kotlin
	cout << p3.getX() << "," << p3.getY() << endl; //200 和400
	p3++;
	++p3;
	
	//报错 <<系统能够输出各种基本类型对象，但是p3对象是我们自己创建的
	//重载了 << 之后就不会报错了，这是单个的
	cout << p3;
	//重载 多个的
	cout >> p3 >> p3 >> p3 >> p3;

	cout << endl;//系统的换行
	// cout 输出的C++
	// cin 输入的C++
	Person p4; //需要定义空参构造函数
	cin >>> p4;// >>>被我们重载了
	cout << "你输入的是：" << p4.getX() << endl;
	cout << "你输入的是：" << p4.getY() << endl;
	
	return 0;
}

括号运算符

数组： 系统源码把括号[i]给重载 系统重载后的样子 *（arr + i）

#include <iostream>
using namespace std;

class ArrayClass{
private:
	// C++ 默认都是系统值 size 系统值 -6464654
	int size = 0; // 大小 开发过程中，给size默认值，不然可能回出现后患无穷的问题
	int * arrayValue;// 数组存放int 类型的很多值
public:
	void set(int index, int value){
	arrayValue[index] = value;// []目前是系统的
	size+ = 1;
	}
	int getSize(){
	return this->size;
	}
	// 运算符重载[index]
	int operator [](int index){
	return this->arrayValue[index];//[] 系统的
	}
};

// 输出容器的内容
void printfArrayClass(ArrayClass arrayClass){
	for(int i = 0; i< arrayClass.getSize(); ++i){
		cout << arrayClass[i] <<endl;// []是我们自己的
	}
}

int main(){
	// 能在栈区的，尽量在栈区，自动回收。
	ArrayClass arrayClass;
	arrayClass.set(0,100);
	arrayClass.set(1,100);
	arrayClass.set(2,100);
	arrayClass.set(3,100);
	printfArrayClass(arrayClass)
	return 0;
}

C++对象继承

#include <iostream>
using namespace std;

class Person{
private：
	char * course;
public:
	char * name;
	int age;
public:
	// ：父类 ， 给自己子类成员初始化
	Person(char * name,int age, char * course):name(name), course(course){
	this->age = age;
	cout << "Person 构造函数" endl;
	}
	void print(){
	cout << this->name << "," << this->age << endl;
	}
};

//继承
Class Student : public Person{
// 类默认是私有的
public:
	Student(char * name, int age) : Person(name, age){
		cout << "Student 构造函数" << endl;
	
	}
	void test(){
	print();
	}
};

int main(){
	Student student("李元霸", 100,"C++");
	stu.name = "张三";// public 继承才能拿父类的成员,如果没有，即使父类成员是public也不行
	return 0;
}

多继承

//歧义一
#include <iostream>
using namespace std;

class BaseActivity1{
public:
	ovoid onCreate(){
	cout << "BaseActivity1 onCreate" << endl;
	}
	ovoid onStart(){
	cout << "BaseActivity1 onStart" << endl;
	}
	void show(){
	cout << "BaseActivity1 show" << endl;
	}
}
class BaseActivity2{
public:
	ovoid onCreate(){
	cout << "BaseActivity2 onCreate" << endl;
	}
	ovoid onStart(){
	cout << "BaseActivity2 onStart" << endl;
	}
	void show(){
	cout << "BaseActivity2 show" << endl;
	}
}
class BaseActivity3{
public:
	ovoid onCreate(){
	cout << "BaseActivity3 onCreate" << endl;
	}
	ovoid onStart(){
	cout << "BaseActivity3 onStart" << endl;
	}
	void show(){
	cout << "BaseActivity3 show" << endl;
	}
}

class MainActivity1 : public BaseActivity1, public BaseActivity2,
	public BaseActivity3{
public:	
	ovoid onCreate(){
	cout << "MainActivity1 onCreate" << endl;
	}
	ovoid onStart(){
	cout << "MainActivity1 onStart" << endl;
	}
}

int main(){
	MainActivity1 m1;// 子类
	//优先查找自己的函数
	m1.onCreate();
	m1.onStart();
	m1.show(); //报错，不明确调用哪一个
	//解决方案：明确指定父类：：
	m1.BaseActivity3::show();
	//或者你在子类中重写show方法就像上面的onCreate方法一样
	return 0;
}

//歧义二
class Object{
public:
	int number;
	void show(){
	cout << "object show run... " << endl;}
};

//父类1
class Base1 : virtual public Object{
};
//父类2
class Base2: virtual public Object{
};
//子类
class Son : public Base1, public Base2{
};

int main(){
	Son son;
	son.number = 2000;//报错 因为不知道你的这个number是基于谁的
	//解决一
	son.Base1::number = 1000;
	//解决二 重定义number，覆盖掉父类的同名成员
	//解决三 虚基类 属于虚继承的范畴 virtual 
	Object object;
	Base1 base1;
	Base2 base2;
	Song son1;
	// 都木有问题
	object.show();
	base1.show();
	base2.show();
	son1.show();
	// virtual 不管你有多少父类，继承不会复制多一份代码模板，指向源头那一份
	// 真实C++ 开发，是很少出现歧义，如果出现，系统源码用第三种解决方案
	return 0;
}