交互类 - 组织代码

Question

我在正确组织课程方面遇到了一些问题。

假设，我有一些 ABase 类。当我想为这个类创建一些不同的（更具体的）抽象时（表示为 AParticular），我可以使用继承或组合。然后很容易将 AParticular 视为 ABase：在继承的情况下它是自动生成的，在组合的情况下我可以创建一些 const ABase& AParticular::GetABasePart() 方法。这样我可以避免代码重复并获得多态特性。

但是，当我有两个或多个相互交互的类时，在更具体的抽象中创建这些类的类似物时会遇到一些问题。 例如，假设我有两个类 Car 和 Station。 Station有一些公共的汽车保养方法：

class Car {
  ...
}

class Station {
  ...
  void AddCarToPlaceNumberN(const Car& car, int place_number) {
    // adds car to some_container<Car>.
  }
  Car* GetMutableCarPointer(int place_number) {
    // gets mutable pointer from some_container<Car>.
  }
  ...
  some_container<Car> cars;
}

现在，我想创建 Truck 和 TruckStation 类：它们与 Car 和 Station 类非常相似，并且有细微的变化。要理解问题，认为它们与 Car 和 Station 类完全一样就足够了，但它们的方法有一点不同的名称（即 TruckStation::AddTruckToPlaceNumberN 而不是 Station::AddCarToPlaceNumberN）

如何组织新类的代码来提供这些功能？

1. 没有代码重复，我想使用已经创建的 Car 和 Station 类方法。
2. 快速转换 Truck& -> Car&, TruckStation& -> Station&（不需要继承，组合也适合），因为我有时想将 Truck 视为 Car，将 TruckStation 视为 Station。
3. 关卡 Car-Station 中的所有交互方法都应在新关卡 Truck-TruckStation 中实现。

主要问题是 3d 项目。让我们考虑两种交互方式：

1) 这个方法没问题：

// If we use inheritance in creating Truck and TruckStation, then we just run
void TruckStation::AddTruckToPlaceNumberN(const Truck& car, int place_number) {
   AddCarToPlaceNumberN(car, place_number)
}
// If we use composition, then it is appropriate to run sth like that:
void TruckStation::AddTruckToPlaceNumberN(const Truck& car, int place_number) {
   station_.AddCarToPlaceNumberN(car.GetCarPart(), place_number);
}

2) 但我不知道如何实现 Station::GetMutableCarPointer(): 的类比：

// For example, if TruckStation was inherited from Station, then suppose:
Truck* TruckStation::GetMutableTruckPointer() {
   Car* car = GetMutableCarPointer();
   // Ups! I need to return Truck*, not Car*.
}

重复问题：我怎样才能实现这些类来提供：

1. 没有代码重复。
2. 可以将新类视为其更高级别的抽象。
3. 实现方法如 TruckStation::GetMutableTruckPointer() 对应于 Station::GetMutableCarPointer()。

Tnx！

Answer 1

具体到您的代码。我会这样做。

1. 基类 Vehicle 由 Car 和 Truck 的特定类扩展。
2. 类站与方法
   • void Station::AddVehicleToPlaceNumberN(const Vehicle& vehicle, int placeNumber)
   • Vehicle* Station::GetMutableVehiclePointer()

设计/班级组织背后的原因。 1. 仅在需要不同实现时才使用继承。如果继承方法的不同实现执行相同的操作（例如 AddVehicleToPlaceNumberN），则无需分离实现。 2. 使用泛型方法名总是有助于简化代码。这些方法可以被重载（传递不同数量和类型的参数）以完成特定的事情。

Answer 2

懒惰的方法是让站使用泛型类型 T 以便； （请耐心等待，我对 C++ 继承语法并不完全清楚，但原则适用）

template<typename T>
class Station<T>:CarStation
{
    void Station<T>::StatAddCarToPlaceNumberN(const T& car, int place_number)
    {
    // adds car to some_container<T>.
    }

    T * Station<T>::GetMutableCarPointer(int place_number) 
    {
        // gets mutable pointer from some_container<Car>.
        return dynamic_cast<T>(car);
    }
}

并且有一个抽象超类 Station，它实现了一个返回基指针的函数，比如

class CarStation
{
    //...
    some_container<Car> cars;
    virtual Car * CarStation::GetMutableCarBasePointer(int place_number) = 0;

}

Car * CarStation::GetMutableCarBasePointer(int place_number)
{
       //gets mutable pointer to base class from some_container<T>
}

现在，如果你愿意，你可以创建一个新的类 TruckStation（这在 C++ 中我不确定，我再次称之为原理）

class TruckStation : Station<Truck>
{
   //...
}

或者直接选择Station<Truck>