【C++重载操作符与转换】转换与继承

class Animal { /*...*/ };
class Dog : public Animal { 
public:
    void bark() { /*...*/ }
};

// 向上转型示例
Animal* animalPtr = new Dog();  // 安全隐式转换

// 向下转型示例
Dog* dogPtr = dynamic_cast<Dog*>(animalPtr);  // 显式安全检查

1.2 类型转换对多态的影响

二、类型转换运算符：自定义类型的隐式/显式转换

类型转换运算符是C++中实现对象与内置类型或其他类型无缝交互的关键机制。通过重载operator type()语法，开发者可定义类对象到目标类型的转换规则。

2.1 基本语法与规则

cpp 复制代码

class MyClass {
public:
    operator int() const {  // 定义到int类型的转换
        return value;
    }
private:
    int value;
};

关键特性 ：
- 必须是成员函数，无返回类型声明。
- 形参列表为空，通过const限定保证转换不修改对象状态。
- 转换函数应避免修改被转换对象（通常声明为const成员）。

2.2 显式与隐式转换

隐式转换：当上下文需要目标类型时自动触发。

cpp 复制代码

MyClass obj(42);
int num = obj;  // 隐式调用operator int()

显式转换 ：通过static_cast强制触发，避免意外转换。

cpp 复制代码

int num = static_cast<int>(obj);  // 显式调用

2.3 转换构造函数 vs 类型转换运算符

特性	转换构造函数	类型转换运算符
定义方式	单参数构造函数	类内成员函数`operator type()`
调用场景	从其他类型构造对象	将对象转换为其他类型
示例	`MyClass(int v)`	`operator double() const`

2.4 代码示例：分数类转换

cpp 复制代码

#include <iostream>
#include <stdexcept>
using namespace std;

class Fraction {
public:
    Fraction(int num, int denom) : numerator(num), denominator(denom) {
        if (denom == 0) throw invalid_argument("Denominator cannot be zero");
    }

    // 类型转换运算符：转换为double
    operator double() const {
        return static_cast<double>(numerator) / denominator;
    }

    void display() const {
        cout << numerator << "/" << denominator << endl;
    }

private:
    int numerator;
    int denominator;
};

int main() {
    Fraction f(3, 4);
    f.display();  // 输出: 3/4

    // 隐式转换为double
    double d = f;
    cout << "As double: " << d << endl;  // 输出: 0.75

    // 显式转换
    cout << "Explicit cast: " << static_cast<double>(f) << endl;
    return 0;
}

三、继承机制：代码复用与多态的基石

继承通过建立类之间的"is-a"关系，实现代码复用和动态多态。C++支持单继承、多继承及虚继承，满足不同场景需求。

3.1 继承语法与访问控制

cpp 复制代码

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;  // 派生类不可访问
};

class Derived : public Base {  // 公有继承
public:
    void access() {
        publicVar = 1;      // 可访问
        protectedVar = 2;   // 可访问
        // privateVar = 3;  // 编译错误
    }
};

公有继承 ：基类public成员保持public，protected成员保持protected。
私有继承 ：基类所有成员在派生类中变为private。
保护继承 ：基类public和protected成员在派生类中变为protected。

3.2 构造与析构顺序

构造顺序：基类构造函数 → 成员对象构造函数 → 派生类构造函数。
析构顺序：派生类析构函数 → 成员对象析构函数 → 基类析构函数。

3.3 多重继承与菱形继承

cpp 复制代码

class Base {
public:
    void foo() { cout << "Base::foo()" << endl; }
};

class Derived1 : virtual public Base {};  // 虚继承
class Derived2 : virtual public Base {};

class Final : public Derived1, public Derived2 {};

int main() {
    Final f;
    f.foo();  // 正确：虚继承避免重复基类
    return 0;
}

虚继承 ：通过virtual关键字解决菱形继承中基类重复的问题。

3.4 代码示例：图形类层次结构

cpp 复制代码

#include <iostream>
#include <cmath>
using namespace std;

class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数
    virtual ~Shape() {}               // 虚析构函数
};

class Circle : public Shape {
public:
    Circle(double r) : radius(r) {}
    double area() const override { return 3.14159 * radius * radius; }
private:
    double radius;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override { return width * height; }
private:
    double width, height;
};

int main() {
    Shape* shapes[] = {new Circle(5), new Rectangle(3, 4)};
    for (Shape* shape : shapes) {
        cout << "Area: " << shape->area() << endl;
        delete shape;  // 正确调用派生类析构函数
    }
    return 0;
}

四、类型转换与继承的综合应用

4.1 场景：几何图形库

设计一个支持多种几何图形的库，要求：

通过类型转换获取图形的描述信息。
利用继承实现多态计算面积。
支持运行时类型识别（RTTI）。

4.2 完整代码实现

cpp 复制代码

#include <iostream>
#include <string>
#include <sstream>  // 用于替代 to_string
#include <typeinfo>
#include <stdexcept>
using namespace std;

class Shape {
public:
    virtual double area() const = 0;
    virtual operator string() const = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    Circle(double r) : radius(r) {
        if (r <= 0) throw invalid_argument("Radius must be positive");
    }

    double area() const override { return 3.14159 * radius * radius; }

    operator string() const override {
        stringstream ss;
        ss << "Circle with radius " << radius;
        return ss.str();
    }

private:
    double radius;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : width(w), height(h) {
        if (w <= 0 || h <= 0) throw invalid_argument("Dimensions must be positive");
    }

    double area() const override { return width * height; }

    operator string() const override {
        stringstream ss;
        ss << "Rectangle with width " << width << " and height " << height;
        return ss.str();
    }

private:
    double width, height;
};

void printShapeInfo(const Shape& shape) {
    cout << "Shape: " << static_cast<string>(shape) << endl;
    cout << "Area: " << shape.area() << endl;
    cout << "Type: " << typeid(shape).name() << endl;
}

int main() {
    try {
        Shape* shapes[] = {new Circle(3), new Rectangle(4, 5)};
        for (Shape* shape : shapes) {
            printShapeInfo(*shape);
            delete shape;
        }
    } catch (const exception& e) {
        cerr << "Error: " << e.what() << endl;
    }
    return 0;
}

类型转换 ：通过operator string()获取图形描述。
多态：基类指针调用派生类的area()方法。
RTTI ：typeid获取对象运行时类型信息。

五、最佳实践与注意事项

①类型转换运算符：

避免隐式转换导致的意外行为，优先使用explicit（C++11起支持）。
转换函数应保持无副作用，避免修改对象状态。

②继承设计：

优先使用组合而非继承，除非存在明确的"is-a"关系。
多重继承需谨慎，优先考虑接口继承（纯虚类）。

③资源管理：

基类析构函数必须声明为virtual，防止内存泄漏。
使用智能指针（如unique_ptr）管理动态内存。

④异常安全：

构造函数中可能抛出异常时，确保资源不会泄漏。
使用RAII（资源获取即初始化）原则。

六、总结

在C++面向对象编程中，运算符重载、类型转换与继承是三大核心特性。它们不仅提升了代码的灵活性和可读性，还为复杂系统的设计提供了强大工具。

类型转换运算符：实现对象与内置类型的无缝交互，需权衡隐式转换的便利性与安全性。
继承机制：通过单继承、多继承和虚继承，构建灵活的类层次结构，支持代码复用与多态。
综合应用：结合类型转换与继承，设计出可扩展、易维护的几何图形库。