寒假学习记录二（c++学习笔记）_c++属性相加-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_73044708/article/details/128761951

一、运算符重载

运算符重载：对已有的运算符重载重新定义，赋予其另外一种功能，以适应不同的数据类型。

编译器定义的通用名称是operator需要重载的运算符。

重载时有两种方法：一是通过自己写成员函数实现，二是通过自己写全局函数实现

eg:

加号运算符重载

实现两个自定义数据类型相加的运算。

编译器定义了通用名称operator+。

方式1：通过自己写成员函数来实现两个对象相加属性后的新对象

class score {
public:
    int m_score;
    score operator+(score& two) {
        score three;
        three.m_score = this->m_score + two.m_score;
        return three;
    }
};
int main() {
    score one;
    one.m_score = 98;
    score two;
    two.m_score = 88;
    //score three= one.operator+(two);
    score three = one + two;
    cout<<"three的score是"<<three.m_score<<endl;
    system("pause");
    return 0;
}

该方法的本质调用是score three= one.operator+(two);

但是可以简化成score three = one + two;

方式2：通过自己写全局函数来实现两个对象相加属性后的新对象

class score {
public:
    int m_score;
};
score operator+(score& one, score& two) {
    score three;
    three.m_score = one.m_score + two.m_score;
    return three;
}
int main() {
    score one;
    one.m_score = 98;
    score two;
    two.m_score = 88;
    //score three= operator+(one,two);
    score three = one + two;
    cout << "three的score是" << three.m_score << endl;
    system("pause");
    return 0;
}

该方法的本质调用是score three= operator+(one,two);

也可以简化成score three = one + two;

2.左移运算符重载

实现输出自定义类型

输出时只使用一个一个自定义类型，无法使用自定义成员函数实现。

使用自定义全局函数实现输出自定义类型

class score {
public:
    int m_score;
};
ostream &operator<<(ostream& cout, score& one) {
    cout << "one的score是" << one.m_score;
    return cout;
}
int main() {
    score one;
    one.m_score = 98;
    //operator<<(cout, one);
    cout << one << endl;
    system("pause");
    return 0;
}

cout为输出流对象（ostream），全局只能有一个，所以传形参和全局函数的返回值类型设置时都使用引用，并且设置函数返回值为输出流，是为了能够使用链式输出在输出自定义函数后追加输出其他内容。

该方法的本质调用是operator<<(cout, one);

简化为cout << one << endl;

可以通过设置全局函数重载作友元的方式访问私有属性。

3.递增运算符重载

通过重载递增运算符，实现自定义整型数据的递增

class  myint {
public:
    myint() {
        num = 0;
    }
    myint& operator++(){//前置递增
        //先递增
        num++;
        //再返回
        return *this;
    }
    myint operator++(int) {//后置递增，int用来区分前后置
        //先记录
        myint temp = *this;
        //再递增
        num++;
        //最后返回记录的值
        return temp;
    }
    int num;
};
ostream &operator<<(ostream& cout, myint m_int) {
    cout  << m_int.num;
    return cout;
}
int main() {
    myint one;
    myint two;
    one.num = 1;
    two.num = 1;
    cout << ++one << endl;
    cout << two++ << endl;
    system("pause");
    return 0;
}

递增运算符是需要区分前后置，所以使用int作占位符来区分。

前置返回一个引用是为了能够实现在进行++(++one)时，是一直对一个数据进行操作。而在后置时不返回引用是因为返回的是一个局部参数，重载函数结束后就会结束，会出现非法操作。

4.函数调用运算符重载

函数调用运算符是（），没有固定写法，操作灵活。重载后调用像函数调用，所以又叫仿函数。

列举个仿printf

class  myprint {
public:
    void operator()(string test) {
        cout << test << endl;
    }
};

int main() {
    myprint Myprint;
    Myprint("hello world");
    system("pause");
    return 0;
}

二、继承

继承是面对对象的三大特征之一。

有些类与类之间有存在特殊关系，

上图中下一级类之间除了有上一级的共性之外也有自己的特征，所以利用这种关系，使用继承来实现减少重复代码的效果。

继承的基础语法

继承的好处就是减少代码重复

单继承：class 子类：继承方式父类

多继承：class 子类：继承方式父类1 ，继承方式父类2

简单案列：

//公共信息
class base {
public:
    void school() {
        cout << "xx学校" << endl;
    }
};
//个人信息
class member01:public base {
public:
    void name(){
        cout << "xx" << endl;
    }
};
class member02 :public base {
public:
    void name() {
        cout << "xxx" << endl;
    }
};
int main() {
    member01 one;
    member02 two;
    one.school();
    one.name();
    two.school();
    two.name();
    system("pause");
    return 0;
}

2.继承方式

继承的方式一共有3种：