C++类和对象3-阿里云开发者社区

C++类和对象2：https://developer.aliyun.com/article/1548157

五、运算符重载

运算符重载概念:对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型；

1、加号运算符重载

#include <iostream>
#include <string>
 
using namespace std;
 
class Person {
public:
    int m_A;
    int m_B;
//成员函数加号重载
    Person operator+(const Person &person) {
        Person tem;
        tem.m_A = this->m_A + person.m_A;
        tem.m_B = this->m_B + person.m_B;
        return tem;
    };
};
//成员函数加号重载
Person operator+(const Person &p1,const Person &p2) {
    Person tem;
    tem.m_A = p1.m_A + p2.m_A;
    tem.m_B = p1.m_B + p2.m_B;
    return tem;
};
void test01() {
    Person p1;
    p1.m_A = 10;
    p1.m_B = 20;
    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() {
    test01();
    return 0;
}

20
40

2、左移运算符重载

重载左移运算符配合友元可以实现输出自定义数据类型

#include <iostream>
#include <string>
 
using namespace std;
 
//左移运算符重载
class Person {
    friend ostream &operator<<(ostream &cout, Person &p);
 
public:
    Person(int a, int b) : m_A(a), m_B(b) {}
 
private:
    int m_A;
    int m_B;
};
 
//只能利用全局函数重载左移运算符 成员函数无法实现cout在左侧
ostream &operator<<(ostream &cout, Person &p) {
    cout << "m_A=" << p.m_A << " m_B=" << p.m_B;
    return cout;
}
 
void test01() {
    Person p(10, 10);
    cout << p << " test" << endl;
}
 
int main() {
    test01();
    return 0;
}

m_A=10 m_B=10 test

3、递增运算符重载

前置递增返回的是引用，后置递增返回的值。

#include <iostream>
#include <string>
 
using namespace std;
 
//自增运算符重载
class MyInteger {
    friend ostream &operator<<(ostream &cout, const MyInteger &myInteger);
 
public:
    MyInteger() {
        m_Num = 0;
    }
 
    //重载前置++运算符
    MyInteger &operator++() {
        // 先进行++运算
        m_Num++;
        //再将自身做返回
        return *this;
    }
 
    //重载后置++运算符
    MyInteger operator++(const int) {
        //        先记录当时的结果
        MyInteger tem = *this;
        // 后递增
        m_Num++;
        //最后将记录结果做返回
        return tem;
    }
 
private:
    int m_Num;
};
 
ostream &operator<<(ostream &cout, const MyInteger &myInteger) {
    cout << myInteger.m_Num << " ";
    return cout;
}
 
void test01() {
    int a = 10;
    cout << ++a << endl;
    cout << a << endl;
    int b = 10;
    cout << b++ << endl;
    cout << b << endl;
}
 
void test02() {
    MyInteger myInt;
    cout << ++(++myInt) << endl;
    cout << myInt << endl;
}
 
void test03() {
    MyInteger myInt;
    cout << myInt++ << endl;
    cout << myInt << endl;
}
 
int main() {
//    test01();
    test02();
    test03();
    return 0;
}

4、赋值运算符重载

#include <iostream>
#include <string>
 
using namespace std;
 
//赋值运算符重载
class Person {
public:
    Person(int age) {
        m_Age = new int(age);
    }
 
    ~Person() {
        if (m_Age != NULL) {
            delete m_Age;
            m_Age = NULL;
        }
    }
 
//    重载赋值运算符
    Person &operator=(Person &p) {
//        先判断是否有属性在堆区，如果有先释放，然后深拷贝
        if (m_Age != NULL) {
            delete m_Age;
            m_Age = NULL;
        }
        m_Age = new int(*p.m_Age);
        return *this;
    }
 
    int *m_Age;
};
 
void test01() {
    Person p1(18);
    Person p2(20);
    Person p3(30);
    p3=p2 = p1;
    cout << *p1.m_Age << endl;
    cout << *p2.m_Age << endl;
    cout << *p3.m_Age << endl;
}
 
int main() {
    test01();
    return 0;
}

18
18
18

5、关系运算符重载

作用: 重载关系运算符，可以让两个自定义类型对象进行对比操作

#include <iostream>
#include <string>
 
using namespace std;
 
//作用: 重载关系运算符，可以让两个自定义类型对象进行对比操作
class Person {
public:
    Person(string name, int age) {
        name = m_Name;
        age = m_Age;
    }
 
    bool operator==(const Person &p) {
        if (this->m_Name == p.m_Name&&this->m_Age==p.m_Age) {
            return true;
        } else {
            return false;
        }
    }
    bool operator!=(const Person &p) {
        return !operator==(p);
    }
 
    string m_Name;
    int m_Age;
};
 
void test01() {
    Person p1("zhang", 15);
    Person p2("zhang", 16);
    cout << (p1 == p2) << endl;
}
 
int main() {
    test01();
    return 0;
}

6、函数调用运算符重载

函数调用运算符()也可以重载

由于重载后使用的方式非常像函数的调用，因此称为仿函数

仿函数没有固定写法，非常灵活

#include <iostream>
#include <string>
 
using namespace std;
 
//函数调用运算符()也可以重载
//由于重载后使用的方式非常像函数的调用，因此称为仿函数
//仿函数没有固定写法，非常灵活
class MyPrint {
public:
    void operator()(string text) {
        cout << text << endl;
    }
};
 
void test01() {
//    重载()操作符，也称为仿函数
    MyPrint myPrint;
    myPrint("hello world");
//    匿名函数
    MyPrint()("hello world");
}
 
int main() {
    test01();
    return 0;
}

hello world
hello world

六、继承

1、继承的基本语法

继承好处：减少重复代码

语法：class 子类：继承方式父类

子类也称为派生类

父类也称为基类

#include <iostream>
#include <string>
 
using namespace std;
/*
 * 继承好处：减少重复代码
 * 语法：class 子类：继承方式 父类
 * 子类也称为派生类
 * 父类也称为基类
 */
//普通页面实现
class BasePage {
public:
    void header() {
        cout << "首页、公开课、登录、注册……（公共头部）" << endl;
    }
 
    void footer() {
        cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
    }
 
    void left() {
        cout << "Java、Python、C++……（公共分类列表）" << endl;
    }
};
 
//java页面
class Java : public BasePage {
public:
    void content() {
        cout << "Java学科视频" << endl;
    }
};
 
//python页面
class Python : public BasePage {
public:
    void content() {
        cout << "Python学科视频" << endl;
    }
};
 
void test01() {
    cout << "Java下载视频" << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
    cout<<"------------------"<<endl;
    cout << "Python下载视频" << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
}
 
int main() {
    test01();
    return 0;
}

Java下载视频
首页、公开课、登录、注册……（公共头部）
帮助中心、交流合作、站内地图……（公共底部）
Java、Python、C++……（公共分类列表）
Java学科视频
------------------
Python下载视频
首页、公开课、登录、注册……（公共头部）
帮助中心、交流合作、站内地图……（公共底部）
Java、Python、C++……（公共分类列表）
Python学科视频

2、继承方式

公共继承：父类的私有属性不可访问，其他属性权限和父类保持一致；

保护继承：父类的私有属性不可访问，父类public权限会降级为protected；

私有继承：父类的私有属性不可访问，父类public、protected会降级为private；

#include <iostream>
#include <string>
 
using namespace std;
 
//公共继承基类
class Base1 {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};
//公共继承
class Son1:public Base1{
public:
    void func(){
        cout<<m_A<<endl;
        cout<<m_B<<endl;
    }
};
//保护继承
class Son2:protected Base1{
    void func(){
        cout<<m_A<<endl;
        cout<<m_B<<endl;
    }
};
//私有继承
class Son3:private Base1{
    void func(){
        cout<<m_A<<endl;
        cout<<m_B<<endl;
    }
};
 
void test01(){
    Son1 s1;
    s1.m_A=100;
//    s1.m_B=100;
}
int main() {
 
    return 0;
}

3、继承中的对象模型

#include <iostream>
#include <string>
 
using namespace std;
 
//作用: 重载关系运算符，可以让两个自定义类型对象进行对比操作
class Base {
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;//私有成员只是被隐藏，但是还是会被继承下去
};
 
//公共继承
class Son : public Base {
public:
    int m_D;
};
 
void test01() {
    //16
    //父类中所有非静态成员属性都会被子类继承下去
    //父类中私有成员属性是被编译器给隐藏了，因此访问不到，但是确实被继承下去了
    cout << "size of Son = " << sizeof(Son) << endl;
}
 
int main() {
    test01();
    return 0;
}

size of Son = 16

使用*Visual Studio 2022 Developer Command Prompt v17.5.5工具，查看对象模型；

#进入代码盘符
D:\ProgramFiles\Microsoft Visual Studio\2022\Community>f:
#进入代码目录
 
F:\>cd F:\myCode\c++\0418_01
#查看代码类的结构  cl /d1 reportSingleClassLayout类名 文件名
 
F:\myCode\c++\0418_01>cl /d1 reportSingleClassLayoutSon main.cpp

4、继承中构造与析构顺序

先构造父类，再构造子类，析构的顺序与构造的顺序相反

#include <iostream>
#include <string>
 
using namespace std;
 
//继承中的构造与析构顺序
class Base {
public:
    Base() {
        cout << "Base构造执行" << endl;
    }
 
    ~Base() {
        cout << "Base析构执行" << endl;
    }
};
 
class Son : public Base {
public:
    Son() {
        cout << "Son构造执行" << endl;
    }
 
    ~Son() {
        cout << "Son析构执行" << endl;
    }
};
 
void test01() {
    Son s;
}
 
//继承中的构造和析构顺序如下：
//先构造父类，再构造子类，析构的顺序与构造的顺序相反
int main() {
    test01();
    system("pause");
    return 0;
}

Base构造执行
Son构造执行
Son析构执行
Base析构执行

5、继承同名成员处理方式

访问子类同名成员直接访问即可

访问父类同名成员需要加作用域

#include <iostream>
#include <string>
 
using namespace std;
 
//访问子类同名成员 直接访问即可
//访问父类同名成员 需要加作用域
class Base {
public:
    Base() {
        m_A = 100;
    }
 
    void func() {
        cout << "Base func()" << endl;
    }
 
    void func(int a) {
        cout << "Base func(int a)" << endl;
    }
 
    int m_A;
};
 
class Son : public Base {
public:
    Son() {
        m_A = 200;
    }
 
    void func() {
        cout << "Son func()" << endl;
    }
 
    int m_A;
};
 
//同名成员属性
void test01() {
    Son son;
    cout << son.m_A << endl;
//    如果通过子类对象访问父类中的同名成员，需要加作用域
    cout << son.Base::m_A << endl;
};
 
//同名成员函数
void test02() {
    Son son;
    son.func();
    son.Base::func();
//    如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏父类中所有同名成员函数，如果想访问，需要加作用域
    son.Base::func(10);
};
 
int main() {
    test01();
    test02();
    return 0;
}

200
100
Son func()
Base func()

6、继承同名静态成员处理方式

与同名成员处理方式一致。可通过类名访问。

7、多继承语法

#include <iostream>
#include <string>
 
using namespace std;
 
//多继承
class Base1 {
};
 
class Base2 {
};
 
class Son : public Base1, protected Base2 {
 
};
 
int main() {
 
    return 0;
}

8、菱形继承

两个派生类继承同一个基类

又有某个类同时继承者两个派生类

这种继承被称为菱形继承，或者钻石继承

#include <iostream>
#include <string>
 
using namespace std;
 
//动物类
class Animail {
public:
    int m_Age;
};
 
//利用虚继承 解决菱形继承的问题
//继承之前加上 virtual变成虚继承 Animail类称为虚基类
//羊类
class Sheep : virtual public Animail {
};
 
//驼类
class Tuo : virtual public Animail {
};
 
//羊驼类
class SheepTuo : public Sheep, public Tuo {
};
 
void test01() {
    SheepTuo st;
    st.Sheep::m_Age=18;
    st.Tuo::m_Age=28;
    cout<<st.m_Age<<endl;
    cout << sizeof(st) << endl;
}
 
int main() {
    test01();
    return 0;
}

28
24

七、多态

静态多态:函数重载和运算符重载属于静态多态，复用函数名;

动态多态: 派生类和虚函数实现运行时多态;

静态多态的函数地址早绑定 - 编译阶段确定函数地址;

动态多态的函数地址晚绑定 - 运行阶段确定函数地址;

#include <iostream>
#include <string>
 
using namespace std;
 
//多态
 
//动物类
class Animal {
public:
    //虚函数
    virtual void speak() {
        cout << "Animal speak" << endl;
    }
};
 
class Cat : public Animal {
public:
    void speak() {
        cout << "cat apeak" << endl;
    }
};
 
//执行说话的函数
//地址早绑定,在编译阶段确定函数地址
//如果想让猫说话,那么这个函数地址不能提前绑定,需要在运行阶段绑定,地址晚绑定
//动态多态满足条件:1、有继承关系；2、子类重写父类的虚函数。动态多态的使用：父类的指针或者引用，指向子类对象。
void doSpeak(Animal &animal) {
    animal.speak();
}
 
void test01() {
    Cat cat;
    doSpeak(cat);
}
 
int main() {
    test01();
    return 0;
}

代码组织结构清晰

可读性强

利于前期和后期的扩展以及维护

#include <iostream>
#include <string>
 
using namespace std;
 
//计算器普通写法
class Calculator {
public:
    int getResult(string oper) {
        if (oper == "+") {
            return m_NUm1 + m_Num2;
        } else if (oper == "-") {
            return m_NUm1 - m_Num2;
        } else if (oper == "/") {
            return m_NUm1 / m_Num2;
        } else if (oper == "*") {
            return m_Num2 * m_NUm1;
        }
 
    }
 
    int m_NUm1;
    int m_Num2;
};
 
//实现计算器抽象类
class AbstractCalculator {
public:
    virtual int getResult() {
        return 0;
    }
 
    int m_Num1;
    int m_Num2;
};
 
//加法计算器
class AddCalculator : public AbstractCalculator {
public:
    int getResult() {
        return m_Num1 + m_Num2;
    }
};
 
//减法计算器
class SubCalculator : public AbstractCalculator {
public:
    int getResult() {
        return m_Num1 - m_Num2;
    }
};
 
void test01() {
    Calculator cal;
    cal.m_NUm1 = 10;
    cal.m_Num2 = 20;
    cout << cal.getResult("+") << endl;
    cout << cal.getResult("-") << endl;
}
 
void test02() {
    AbstractCalculator *abc = new AddCalculator();
    abc->m_Num1 = 10;
    abc->m_Num2 = 20;
    cout << abc->getResult() << endl;
    delete abc;
}
 
int main() {
//    test01();
    test02();
    return 0;
}

类中有纯虚函数，类称为抽象类；

抽象类无法实例化对象，子类必须重写抽象类的纯虚函数，否则也称为抽象类；

#include <iostream>
#include <string>
 
using namespace std;
 
//类中有纯虚函数，类称为抽象类
//抽象类无法实例化对象，子类必须重写抽象类的纯虚函数，否则也称为抽象类
class Base {
public:
    virtual void func() = 0;
};
 
class Son : public Base {
public:
    void func() {
        cout << "son func" << endl;
    }
};
 
void test01() {
    Base *base = new Son();
    base->func();
    delete base;
}
 
int main() {
    test01();
    return 0;
}

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码

解决方式:将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：都可以解决父类指针释放子类对象，都需要有具体的函数实现；区别：纯虚析构的类输入抽象类，无法实例化对象。

#include <iostream>
#include <string>
 
using namespace std;
 
//多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构代码
//解决方式:将父类中的析构函数改为虚析构或者纯虚析构
//虚析构和纯虚析构共性：都可以解决父类指针释放子类对象，都需要有具体的函数实现；区别：纯虚析构的类输入抽象类，无法实例化对象。
 
//虚析构和纯虚析构
class Animal {
public:
    Animal() {
        cout << "Animal 构造函数" << endl;
    }
 
//利用虚析构可以解决，父类指针释放子类对象时不干净的问题。
//  virtual  ~Animal() {
//        cout << "Animal 析构函数" << endl;
//    }
//纯虚析构，需要申明和实现
    virtual  ~Animal() = 0;
 
    //    纯虚函数
    virtual void speak() = 0;
};
 
Animal::~Animal() {
    cout << "Animal 纯虚析构函数" << endl;
}
 
class Cat : public Animal {
public:
    Cat(string name) {
        cout << "Cat 构造函数" << endl;
        m_Name = new string(name);
    }
 
    virtual void speak() {
        cout << *m_Name << "小猫在说话" << endl;
    }
 
    ~Cat() {
        if (m_Name != NULL) {
            cout << "Cat 析构函数" << endl;
            delete m_Name;
            m_Name = NULL;
        }
    }
 
    string *m_Name;
};
 
void test01() {
    Animal *animal = new Cat("tom ");
    animal->speak();
    delete animal;
}
 
int main() {
    test01();
    return 0;
}

Animal 构造函数
Cat 构造函数
tom 小猫在说话
Cat 析构函数
Animal 纯虚析构函数

C++类和对象3

五、运算符重载

1、加号运算符重载

2、左移运算符重载

3、递增运算符重载

4、赋值运算符重载

5、关系运算符重载

6、函数调用运算符重载

六、继承

1、继承的基本语法

2、继承方式

3、继承中的对象模型

4、继承中构造与析构顺序

5、继承同名成员处理方式

6、继承同名静态成员处理方式

7、多继承语法

8、菱形继承

七、多态

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++类和对象3

五、运算符重载

1、加号运算符重载

2、左移运算符重载

3、递增运算符重载

4、赋值运算符重载

5、关系运算符重载

6、函数调用运算符重载

六、继承

1、继承的基本语法

2、继承方式

3、继承中的对象模型

4、继承中构造与析构顺序

5、继承同名成员处理方式

6、继承同名静态成员处理方式

7、多继承语法

8、菱形继承

七、多态

热门文章

最新文章

相关课程

相关电子书

相关实验场景