处理派生类型的构造方法的最佳方法

Question

我有一个类似于下面的继承层次结构，我想编写我的DAL来持久化这些对象，但不确定构建它的最佳方法是什么？

• 宠物<-狗<-犬与拉布拉多
• 宠物<-猫<-波斯和猫

虽然所有类都是从Pet继承的，但每个方法都需要调用不同的存储过程并添加不同的sql参数。不过，也有一些常见的参数。

以下是一些想法：

(1)具有重载保存方法的PetDal，该方法接受每种派生类型。

(2) PetDal采用单独的SaveLabrador、SaveTabby方法。

(3) Base PetDal +继承的LabradorDal、TabbyDal类，每个类型有一个公共接口。例如，虚空保存(宠物宠物)，它需要在每个方法(策略方法)中将宠物转换成派生类型。

(4)其他方式。

Answer 1

(1)和(2)是完全相同的，只是语法上不同而已。(4)的一个问题是，如果您想处理不同的持久类型(平面文件、数据库等)，那么您必须为每个置换(AlsationToFileDAL、AlsationToSybaseDAL等)创建一个类。

您可以使用(1)/(2)进行双重调度，例如：

// pets.h

#include <string>
#include <iostream>

class Alsation;
class Persian;

class PetDAL
{
public:
    virtual ~PetDAL () {}

    virtual void save (const Alsation* alsation) = 0;
    virtual void save (const Persian* persian) = 0;
};

class Pet
{
    std::string name_;

public:
    Pet (const std::string& name) : name_ (name)
    {}

    virtual ~Pet () {}

    std::string getName () const
    {
        return name_;
    }

    virtual void save (PetDAL* dal) const = 0;
};

class Dog : public Pet
{
    bool sleepWalks_;
public:
    Dog (const std::string& name, bool sleepWalks) : Pet (name), sleepWalks_ (sleepWalks)
    {}

    bool getSleepWalks () const {return sleepWalks_;}

};

class Alsation : public Dog
{
public:
    Alsation (const std::string& name, bool sleepWalks) : Dog (name, sleepWalks)
    {}

    virtual void save (PetDAL* dal) const
    {
        dal->save (this);
    }
};

class Cat : public Pet
{
    int purrsPerMinute_;

public:
    Cat (const std::string& name, int purrsPerMinute) : Pet (name), purrsPerMinute_ (purrsPerMinute)
    {}

    int getPurrsPerMinute () const {return purrsPerMinute_;}
};

class Persian : public Cat
{
public:
    Persian (const std::string& name, int purrsPerMinute) : Cat (name, purrsPerMinute)
    {}

    virtual void save (PetDAL* dal) const
    {
        dal->save (this);
    }
};

class PetDALCoutImpl : public PetDAL
{
public:
    virtual void save (const Alsation* alsation)
    {
        std::cout << "Saving alsation " << std::endl
            << "\tname=" << alsation->getName () << std::endl
            << "\tsleepwalks=" << alsation->getSleepWalks () << std::endl;
    }

    virtual void save (const Persian* persian)
    {
        std::cout << "Saving persian " << std::endl
            << "\tname=" << persian->getName () << std::endl
            << "\tpurrsPerMinute=" << persian->getPurrsPerMinute () << std::endl;
    }
};

int test (int argc, char* argv[])
{
    Dog* dog = new Alsation ("fido", true);
    Cat* cat = new Persian ("dave", 10);

    PetDAL* petDAL = new PetDALCoutImpl ();

    dog->save (petDAL);
    cat->save (petDAL);

    delete cat;
    delete dog;

    return 0;
};

也就是说，宠物基类知道它的子类可以保存到DAL，但是它不依赖DAL实现。

Answer 2

您考虑过使用像战略模式这样的模式吗？它可能适合您的需要，因为您可以对不同的实现有不同的策略，同时仍然使用来自抽象类的属性/方法？