类外运算符重载
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;
}