复制抽象基类的对象

发布于 2024-10-13 07:02:55 字数 109 浏览 12 评论 0原文

如果我有一个指向派生自抽象基类的对象的指针（因此我无法创建该类的新对象），并且我希望制作该对象的深层副本，是否有比这更简洁的方法来实现这一点让抽象基类创建一个新的纯虚复制函数，每个继承类都必须实现该函数？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

稳稳的幸福 2024-10-20 07:02:55

不，但是 copy 方法不一定很痛苦：（

class Derived : public Base
{
  public:
    Base *copy() const
    {
        return new Derived(*this);
    }
};

假设您已经有一个复制构造函数，如果您需要深层复制，您就会有）。

No, but the copy method does not have to be painful:

class Derived : public Base
{
  public:
    Base *copy() const
    {
        return new Derived(*this);
    }
};

(assuming you already have a copy constructor, which, if you need a deep copy, you'll have).

回复收藏 0 原文

甜味超标? 2024-10-20 07:02:55

建议的“复制”（通常称为“克隆”）是正常方法。另一种选择是使用 rtti 的工厂和调度来找到正确的处理程序，然后调用派生类型的复制构造函数。

struct Abc
{
    virtual void who() const = 0;
};

struct A : Abc
{
    virtual void who() const { std::cout << "A" << std::endl;}
};

template<class T>
Abc* clone(Abc* abc)
{
    T* t = dynamic_cast<T*>(abc);
    if (t == 0)
        return 0;
    return new T(*t);
}

struct B : Abc
{
    virtual void who() const { std::cout << "B" << std::endl;}
};

typedef Abc* (*Cloner)(Abc*);

std::map<std::string, Cloner> clones;

void defineClones()
{
    clones[ typeid (A).name() ] = &clone<A>;
    clones[ typeid (B).name() ] = &clone<B>;
}


Abc* clone(Abc* abc)
{
    Abc* ret = 0;
    const char* typeName  = typeid(*abc).name();
    if (clones.find(typeName) != clones.end())
    {
        Cloner cloner = clones[typeName];
        ret = (*cloner)(abc);
    }
    return ret;
}
void test ()
{
    defineClones();
    Abc* a = new A;
    Abc* anotherA = clone(a);
    anotherA->who();

    Abc* b = new B;
    Abc* anotherB = clone(b);
    anotherB->who();
}

虽然上述方法有效，但它使用 rtti 的事实足以说服大多数人采用正常方法。但是，如果有原因阻止对基类进行更改，那么它可能会很有用。

这么有效率吗？增加一种新类型的边际成本确实是一笔小钱。问题是很容易忘记在每个新类中添加该行。或者您可以将其视为一个优点，即所有克隆代码都位于单个文件中，并且我们不必更改支持的层次结构来处理它。

The suggested 'copy', more usually called 'clone' is the normal approach. An alternative would be a factory and dispatch using rtti to find the right handler to then call the copy constructor on the derived type.

struct Abc
{
    virtual void who() const = 0;
};

struct A : Abc
{
    virtual void who() const { std::cout << "A" << std::endl;}
};

template<class T>
Abc* clone(Abc* abc)
{
    T* t = dynamic_cast<T*>(abc);
    if (t == 0)
        return 0;
    return new T(*t);
}

struct B : Abc
{
    virtual void who() const { std::cout << "B" << std::endl;}
};

typedef Abc* (*Cloner)(Abc*);

std::map<std::string, Cloner> clones;

void defineClones()
{
    clones[ typeid (A).name() ] = &clone<A>;
    clones[ typeid (B).name() ] = &clone<B>;
}


Abc* clone(Abc* abc)
{
    Abc* ret = 0;
    const char* typeName  = typeid(*abc).name();
    if (clones.find(typeName) != clones.end())
    {
        Cloner cloner = clones[typeName];
        ret = (*cloner)(abc);
    }
    return ret;
}
void test ()
{
    defineClones();
    Abc* a = new A;
    Abc* anotherA = clone(a);
    anotherA->who();

    Abc* b = new B;
    Abc* anotherB = clone(b);
    anotherB->who();
}

Whilst the above works, the sheer fact it uses rtti would be enough to persuade most to go the normal approach. However, it there was a reason preventing changes to the base class, it might be useful.

It this efficient? The marginal cost of adding a new type is truly a one-liner. The catch is that it will be easy to forget to add that line with each new class. Or you can see it as an upside that all the clone code lives in a single file and we don't have to change the supported hierarchy to handle it.

回复收藏 0 原文