从基类中选择子类...可能吗？

Question

我正在学习 C++，但我遇到了一个问题。我需要一种在基类中使用特定子类的方法。这有意义还是我使用了错误的方法？ SelectBrand应该选择子类，我该怎么做？

下面是我的简化课程：

---

-----
class Protocol {

public:

    Protocol() {};
    ~Protocol() {};
    int openPort();
    int readPort(char *buffer);

.....

private:

        Protocol (const Protocol&);
};

int Protocol::openPort() {......};

int Protocol::readPort() {.........};

/***********************************************************************************/

class Device{

public:

        Device(Protocol& port):_protocol(port){}
        ~Device();
        virtual int getEvent(char *buffer) { return -1; }
        int Device::selectBrand();

        ..............

protected:

        Protocol& _protocol;

private:

        int brand;
        Device(const Device&orig);
};

Device::~Device() {}

int Device::selectBrand() {

       ......

       switch (X)

            case 1:

                    "use subclass Brand_B"

            case 2:

                    "use subclass Brand_B"

        .......

}

/***********************************************************************************/

class Brand_A:public Device {

public:

        Brand_A(Protocol& port);
        ~Brand_A();
        int getEvent(void *rawData);  

private:

        Brand_A(const Brand_A&);
};

Brand_A::Brand_A(Protocol& port):Device(port) {}

Brand_A::~Brand_A() {}

int Brand_A::getEvent(void *rawData) {


            .... readPort(......);

}

/***********************************************************************************/

class Brand_B:public Device {

public:

        Brand_B(Protocol& port);
        ~Brand_B();
        int getEvent(void *rawData);  

private:

        Brand_B(const Brand_B&);

};

Brand_B::Brand_B(Protocol& port):Device(port) {}

Brand_B::~Brand_B() {}

int Brand_B::getEvent(void *rawData) {


            .... readPort(......);

}

/* main **********************************************************/

int main(int argc, char **argv) {

        Device *mydev;

        char *buffer;

    ..............

    mydev->selectBrand();

    ..........

    mydev->getEvent(buffer);

    ...........

}

Answer 1

我想我应该充实我上面的评论。首先，您可以查看维基百科页面以获取有关抽象工厂模式的更多信息。基本上，它允许您访问接口的不同实现，并在运行时确定所使用的实现。但是，您仍然不知道您将获得哪个实现，因为这是在返回接口实现的工厂方法中决定的。因此，您只能使用接口中的成员，而不能使用特定的实现。使用上面的类的示例如下：

class Device
{
    virtual int getEvent(void *rawData) = 0;
}

class BrandA : public Device
{
    // define constructors/destructors etc.

    int getEvent(void *rawData)
    {
        // BrandA's implementation for getEvent
    }
}

class BrandB : public Device
{
    // define constructors/destructors etc.

    int getEvent(void *rawData)
    {
        // BrandB's implementation for getEvent
    }
}

class DeviceFactory
{
    static Device *CreateDevice(/*any parameters for determining the device?*/)
    {
        // You probably don't want to randomly determine which implementation you use...
        if ((rand() % 2) == 0)
        {
            return new BrandA();
        }
        else
        {
            return new BrandB();
        }
    }
}

int main()
{
    // CreateDevice will decide which type of device we use, however we can only
    // explicitly reference the members of the base class (Device).
    Device *myDevice = DeviceFactory::CreateDevice();

    myDevice->getEvent();

    return 0;
}

Answer 2

看起来您可能正在尝试实现多态性之类的东西，而 C++ 会为您做到这一点。如果您在基类中定义虚拟方法并在子类中重写它们，则对指针或对基类型的引用调用这些方法应该会导致调用子类的实现。

例如：

class BaseClass
{
    virtual void DoSomething()
    {
        printf("base");
    }

};

class SubClass : public BaseClass
{
    void DoSomething()
    {
        printf("sub");
    }
};

int main()
{
    BaseClass *myBase = new SubClass();
    myBase->DoSomething(); // should print "sub" to stdout

    return 0;
}

创建时必须知道要使用什么派生类型（子类的类型），以便实例具有派生类型的附加功能。如果不这样做，您获得的只是基类的功能，并且您不能将其视为除基类之外的任何内容（或者如果您的基类继承自某个对象，则不能将其视为继承层次结构中更高的任何内容）。

如果不同的实例实际上没有做任何不同的事情，您甚至可能想使用成员来区分它们。从代码示例中很难准确判断您想要做什么。也许一个更具体的例子来说明你想要实现什么而不是你如何实现它会有所帮助。

Answer 3

请让我重新表述这个问题。我有 1 个基类和一些子类； Brand_A ....Brand_N

现在，在 main() 中，我事先不知道我将使用哪个子类；这个选择需要基类中的一个函数，我称之为 selectBrand。我需要的是一种根据内部条件选择和使用正确子类的机制。我想伪装到 main() 所选的子类。如何得到这个？

Answer 4

我实现并测试了这段代码；效果很好。这是好的设计还是可以做得更好？

class BehaviorBase
{
public:
    virtual ~BehaviorBase() {}
    virtual void DoSomethingOn(Object* obj) {}
};

class Object
{
public:
    BehaviorBase* behavior;
    void DoSomething();
    void ChangeBehavior(int param);
    ~Object();
}

class BehaviorA: public BehaviorBase
{
   void DoSomethingOn(Object* obj)
   {
    printf("Behavior A\n");
   }
};

class BehaviorB: public BehaviorBase
{
   string other_data;
   void DoSomethingOn(Object* obj)
   {
    printf("Behavior B\n");
   }
};

void Object::DoSomething()
{
    behavior->DoSomethingOn(this);
}

Object::~Object()
{
    delete behavior;
}

void Object::ChangeBehavior(int param)
{
    delete behavior;
    switch(param)
    {
        case 1: behavior = new BehaviorA; break;
        case 2: behavior = new BehaviorB; break;
    }
}    

int main(int argc, char **argv) {
    int param=1;
    Object *obj;
    obj= new Object;

    obj->ChangeBehavior(param);
    obj->DoSomething();     
    delete obj;
    return(0);
}

Answer 5

这不是一个好主意。

一般来说，答案是dynamic_cast，但是从基类调用后代的特定行为通常是一个糟糕的设计标志。

您可以尝试反转类层次结构并使用模板。