目录
零. 简介
一. 继承
1.基类,派生类
2.访问控制和继承:
3.多继承
二. 多态
关键字 virtual override :
用例:工厂模式
三. 重载
函数重载:
操作符重载:
零. 简介
- 继承：允许一个类从另一个类获取属性和方法。子类可以继承父类的特性，并可以进行扩展和修改。
- 多态：基于继承的特性，使得不同的子类可以对同一方法进行不同的实现。
- 重载：是指函数或操作符在同一作用域内具有多个不同的定义，根据参数列表的不同来区分。
一. 继承
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.访问控制和继承:
| 访问 | public | protected | private |
|---|---|---|---|
| 同一个类 | yes | yes | yes |
| 派生类 | yes | yes | no |
| 外部的类 | yes | no | no |
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;
}三. 重载
重载的优点包括：
- 提高代码的可读性和可维护性：使用有意义的函数名来处理不同类型的数据。
- 提供了更灵活的编程接口：可以根据具体需求使用不同的函数实现。
函数重载:
截图:
代码:
#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 对象。通过重载操作符，可以提供更直观和自然的语法来操作类的对象。
