1.类外运算符重载
- class Point {
- private:
- int x,y;
- public:
- // 系统C++源码,大量使用此方式 :x(x), y(y)
- Point(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;
- }
- };
- /*类外运算符重载
- * 在真实开发过程中,基本上都是写在类的里面的,外部是不能获取内部的私有成员的
- * */
- Point operator + (Point point1,Point point2){
- int x = point1.getX() + point2.getX();
- int y = point1.getY() + point2.getY();
- Point res(x, y);
- return res;
- }
- int main(){
- Point pointA(10,20);
- Point pointB(10,20);
- Point pointC=pointA+pointB;
- cout
日志输出:
20 , 40两个对象做+法运算就是执行了运算符重载函数
2.类内部运算符号重载 class Point { private: int x,y; public: Point(){} // 系统C++源码,大量使用此方式 :x(x), y(y) Point(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; } /** 常量引用:不允许修改,只读模式
* & 性能的提高,如果没有& 运行+ 构建新的副本,会浪费性能
* 如果增加了& 引用是给这块内存空间取一个别名而已
* */
Point operator + (const Point & point){ int x=this->x+point.x; int y=this->y+point.y; return Point(x,y); } Point operator - (const Point & point){ int x=this->x-point.x; int y=this->y-point.y; return Point(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 & _START, Point & point) {// 接收用户的输入,把输入的信息
_START >> point.x >> point.y;
return _START;
}
};
int main(){
Point pointA(30,50);
Point pointB(10,20);
// Point pointC=pointA-pointB;
++pointA;
// cout > pointC; // >> 是我们自己重载的哦
cout
- 类内部运算符重载,允许访问私有变量
- 传入的参数是常量引用,const 表示不可更改,& 可以提升性能,只会有一个变量别名,不加会拷贝一份,浪费内存。
- > 重载,需要加friend 友元函数来进行重载
- ostream & _START:表示输出
- istream & _START:表示输入
3.[] 运算符号重载class ArrayClass {
private:
int size =0 ; // 大小 开发过程中,给size赋默认值,不然可能会出现,无穷大的问题
int * arrayValue; // 数组存放 int 类型的很多值
public:
ArrayClass(){
/*指针类型必须分配空间*/
arrayValue= static_cast(malloc(sizeof(int *) * 10)); } void set(int index, int value) { arrayValue[index] = value; // []目前不是我的 size+=1; } int getSize() { // size成员的目标:是为了循环可以遍历 return this->size; } // 运算符重载 [index] int operator[](int index) { return this->arrayValue[index]; // 系统的 } }; // 输出容器的内容 void printfArryClass(ArrayClass arrayClass) { cout 4.c++继承 class Person { public: char *name; int age; public: Person(char *name, int age) : name(name) { this->age = age;cout name age
- 默认是 隐式代码: : private Person
- 私有继承:在子类里面是可以访问父类的成员,但是在类的外面不行
- 必须公开继承,才可以访问父类的成员
- 先执行父类的构造函数,再执行子类的构造函数
5.多继承 class BaseActivity1 { public: void onCreate() {cout
- c++ 允许多继承,可能会出现二义性,原则上是尽量避免二义性
- 通过明确父类的方式解决二义性
- 通过子类重写父类的方法规避二义性
6.通过虚继承来解决二义性问题// 祖父类
class Object{ public: int number; void show() {cout
- 如果没有虚继承,那么son对象访问number就会报二义性的问题,同时访问show方法同样存在二义性问题
- 由于在继承的时候添加了虚继承,就能解决类似这样的问题,虚继承的含义是:将通过继承得来的number和show方法,放置在另外一个统一空间上,这样子类再访问的时候就不会出现二义性的问题了。
到此这篇关于C++运算符重载与多继承及二义性详解的文章就介绍到这了

我的微信
微信号已复制
我的微信
这是我的微信扫一扫