C++面向对象-继承,多态,重载

​零. 简介

• 继承：允许一个类从另一个类获取属性和方法。子类可以继承父类的特性，并可以进行扩展和修改。

• 多态：基于继承的特性，使得不同的子类可以对同一方法进行不同的实现。

• 重载：是指函数或操作符在同一作用域内具有多个不同的定义，根据参数列表的不同来区分。

一. 继承

1.基类,派生类

子类可以直接继承父类公开和保护的属性和方法.

代码:

#include<iostream>
#include<vector>
#include <string>


class Animal {

protected:
    int age = 10;

public:
    std::string m_name;
    void makeSound() {
        std::cout<< m_name << "叫;   " <<"年龄: " <<age<< std::endl;
    }
};

class Dog : public Animal {

     
public:
    Dog() {
        age = 1;
    }
};
class Cat : public Animal {

public:
    Cat() {
        age = 2;
    }
};

int main() {
    Dog dog;
    dog.m_name = "小狗";
    dog.makeSound();  // 输出：Barking

    Cat cat;
    cat.m_name = "小猫";
    cat.makeSound();  // 输出：Barking



    return 0;
}

2.访问控制和继承:

3.多继承

代码

#include<iostream>

using namespace std;

class DogRed {
  
public:
    void Run() {
        cout << "小狗跑" << endl;
  }
};
class DogBlue {

public:
    void Eat() {
        cout << "小狗吃" << endl;
    }
};

class Dog : public DogRed, public DogBlue {


};

int main() {

    Dog dog;
    dog.Run();
    dog.Eat();

    return 0;
}

继承所有父类的公共,保护的属性和方法.

二. 多态

代码:

#include <iostream>

class Animal {
public:
    virtual void makeSound() {
        std::cout << "动物叫" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "小狗叫" << std::endl;
    }
};
class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "小猫叫" << std::endl;
    }
};
int main() {
    Animal* dog = new Dog();  // 使用基类指针指向派生类对象
    dog->makeSound();          // 多态：根据实际对象类型调用相应的函数
    delete dog;

    Animal* cat = new Cat();  // 使用基类指针指向派生类对象
    cat->makeSound();          // 多态：根据实际对象类型调用相应的函数
    delete cat;
    return 0;
}

关键字 virtual override :

• virtual：用于在基类中声明虚函数。虚函数允许在运行时根据对象的实际类型来确定要调用的函数。

• override：（C++11 及以上版本）用于在派生类中明确表示要重写基类的虚函数。

用例:工厂模式

多态在工厂模式中是一个常见的应用.使用多态实现了不同具体产品类的操作。通过工厂类创建不同类型的产品对象，然后调用它们的共同方法.

简单的工厂模式代码示例:

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void operate() = 0;
};

// 具体产品类 1
class ConcreteProduct1 : public Product {
public:
    void operate() override {
        std::cout << "ConcreteProduct1 operate()" << std::endl;
    }
};

// 具体产品类 2
class ConcreteProduct2 : public Product {
public:
    void operate() override {
        std::cout << "ConcreteProduct2 operate()" << std::endl;
    }
};

// 工厂类
class Factory {
public:
    Product* createProduct() {
        return new ConcreteProduct1();
    // 可以根据需要返回不同的具体产品对象
    // 例如：return new ConcreteProduct2();
    }
};

int main() {
    Factory factory;
    Product* product = factory.createProduct();
    product->operate();

    return 0;
}

三. 重载

重载的优点包括：

2. 提高代码的可读性和可维护性：使用有意义的函数名来处理不同类型的数据。

4. 提供了更灵活的编程接口：可以根据具体需求使用不同的函数实现。

函数重载:

截图:

代码:

#include <iostream>

void print(int value) {
    std::cout << "Integer: " << value << std::endl;
}

void print(double value) {
    std::cout << "Double: " << value << std::endl;
}

int main() {
    print(42);
    print(3.14);

    return 0;
}

在上面的示例中，定义了两个 print 函数，一个接受整数参数，另一个接受双精度浮点数参数，这就是函数重载。

操作符重载:

代码:

#include <iostream>

class MyClass {
private:
    int value;
public:
    MyClass(int val) : value(val) {}

    MyClass operator+(const MyClass& other) {
        return MyClass(value + other.value);
    }

    void display() {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj1(5);
    MyClass obj2(3);

    MyClass result = obj1 + obj2;

    result.display();  // 输出结果

    return 0;
}

在上面的示例中，重载了 + 操作符，使得可以对两个 MyClass 对象进行相加操作，并返回一个新的 MyClass 对象。通过重载操作符，可以提供更直观和自然的语法来操作类的对象。