我有一个基类实例，有一个继承自基类的派生类，我想将基类实例转换为派生实例，(如果可能的话不复制任何东西(可能向派生类发送一个基类))我该如何实现？

注意:我需要这个，因为我使用的是工厂设计模式，它标识需要使用位于基实例中的参数创建的派生类。

//class A
//class B: public A (pure virtual)
//class C: public B

B BFactory::makeB(A &a) {
    int n=a.getN();
    if(n==1){
        return new C();
    }
}

谢谢。

最佳答案

考虑汽车的情况。

您可以将兰博基尼视为汽车。

您可以将 Yugo 视为汽车。

如果汽车是兰博基尼，您就可以将其视为兰博基尼。在 C++ 中，这意味着指向 car 的指针实际上指向 Lamborghini。为了从汽车指针中取回兰博基尼指针，您应该使用 dynamic_cast。如果汽车没有指向 Lamborghini，dynamic_cast 将返回 NULL。这可以防止您试图将 Yugo 冒充为兰博基尼并烧毁 Yugo 的引擎。

但当兰博基尼被当成汽车时，它只能做汽车的事情。如果你将一辆兰博基尼复制到一辆汽车中，你就会永远剥离所有兰博基尼。没了。

代码时间!

这恐怕做不到:

//class A
//class B: public A (pure virtual)
//class C: public B

B BFactory::makeB(A &a) {
    int n=a.getN();
    if(n==1){
        return new C();
    }
}

C 被复制到 B 中，B 被返回。 B 需要一个采用 C 的构造函数，但这一点没有实际意义。如果 B 是纯虚拟的，则无法实例化。现在我们将忽略 new C()

也不能为这项工作使用引用，几乎是同样的问题，所以你陷入了返回指针的困境

B * BFactory::makeB(A &a) {
    int n=a.getN();
    if(n==1){
        return new C();
    }
}

现在我要提出一个建议:将 make 函数构建到 B 中，并处理 A 未映射到 B 可识别的任何内容的情况。

class B: public A
{
public:
    virtual ~B(){}
    static B * makeB(A & a)
    {
        switch(a.getN())
        {
            case 1:
                return new C();
        }
        return NULL;
    }
};

但这引出了另一个建议:为什么 B 应该知道什么？在这个级别，A 的意义何在？为什么 A 存储类的构建代码在层次结构中向下两步或更多步？从维护的角度来看很糟糕。对象的要点是他们知道自己是谁以及如何操纵自己。将其短路会导致疼痛。

class B: public A
{
public:
    virtual ~B(){}
    virtual B* makeB() = 0;
};

现在 B 只制造 B，不需要 A 的帮助，那些扩展 B 的人被困在弄清楚如何制造自己——他们应该比任何人都更了解这项任务。更安全，因为 B 永远不会识别新类的代码。

class C: public B
{
public:
    B* makeB()
    {
        return new C();
    }
};

class D: public B
{
public:
    B* makeB()
    {
        return new D();
    }
};

编辑:传统工厂

您要的是一个抽象工厂。为此你什么都不需要。你甚至不需要上课。您当然不需要 A 类。这种工厂的目标是调用者对类一无所知。通过提供 A，调用者需要知道如何制作 A 或让另一家工厂制作 A。

首先在头文件 BFactory.h 中进行一些设置:

#ifndef BFACTORY_H_
#define BFACTORY_H_

#include <exception>
class B
{
public:
    virtual ~B(){}
    virtual std::string whatAmI() = 0;
protected:
    // data members common to all B subclasses
};

enum bType
{
    gimmie_a_C,
    gimmie_a_D,
    gimmie_an_E
};

class BadTypeException: public std::exception
{
public:
    const char* what() const noexcept
    {
        return "Dude! WTF?!?";
    }
};

B* BFactory(enum bType type);

#endif /* BFACTORY_H_ */

在这里我要稍微偏离书本的方式。我将不使用整数来标识要构建的类型，而是使用枚举。两个原因:gimme_a_C 比 1 更易于阅读和理解，并且如果您尝试提供未枚举的值，则会生成编译器错误。

enum bType
{
    gimmie_a_C,
    gimmie_a_D,
    gimmie_an_E
};

如果使用新类型更新枚举 (gimmie_an_E) 但工厂没有更新，则标记愚蠢的异常。

class BadTypeException: public std::exception
{
public:
    const char* what() const noexcept
    {
        return "Dude! WTF?!?";
    }
};

这就是 Factory 客户端需要看到的全部内容。他们看不到 C。他们看不到 D。除了 enum bType 中列出的名称之外，他们不知道 C 和 D 以任何方式存在。他们所看到的只是指向 B 的指针。

现在执行 BFactory.cpp:

#include "BFactory.h"

class C:public B
{
    std::string whatAmI()
    {
        return "C";
    }
};

class D:public B
{
    std::string whatAmI()
    {
        return "D";
    }
};

B* BFactory(enum bType type)
{
    switch(type)
    {
        case gimmie_a_C:
            return new C();
        case gimmie_a_D:
            return new C();
        default:
            throw BadTypeException();
    }
}

我会留给读者找出上面代码中导致这些错误的愚蠢错误以及我不喜欢它们的原因。

和用法，main.cpp:

#include "BFactory.h"

int main()
{
    B * temp;
    temp = BFactory(gimmie_a_C);
    std::cout << temp->whatAmI() << std::endl;
    delete temp;
    temp = BFactory(gimmie_a_D);
    std::cout << temp->whatAmI() << std::endl;
    delete temp;
    //temp = BFactory(1001); // won't compile
    try
    {
        temp = BFactory(gimmie_an_E); // will compile, throws exception 
        std::cout << temp->whatAmI() << std::endl;
    }
    catch(BadTypeException& wtf)
    {
        std::cerr << wtf.what() << std::endl;
    }
}

A 仍然绝对没有用处或参与。如果 A 存在，B 或 B 的 child 应该没有任何关系。

现在我们可以做一些改进，使指针更安全一些。 unique_ptr 允许我们保持指向 B 的指针的多态优势，而不会出现内存管理问题。

std::unique_ptr<B> BFactory(enum bType type)
{
    switch(type)
    {
        case gimmie_a_C:
            return std::unique_ptr<B>(new C());
        case gimmie_a_D:
            return std::unique_ptr<B>(new D());
        default:
            throw BadTypeException();
    }
}

和新的主要内容:

int main()
{
    std::unique_ptr<B> temp;
    temp = BFactory(gimmie_a_C);
    std::cout << temp->whatAmI() << std::endl;
    temp = BFactory(gimmie_a_D);
    std::cout << temp->whatAmI() << std::endl;
}

关于c++ - 使用基类实例创建派生类实例，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31395957/