Início / coding / Perguntas / 79553665
Accepted
zecuse
Asked: 2025-04-04 01:54:24 +0800 CST

Como clonar corretamente um objeto que contém um objeto polimórfico que pode conter um vetor para mais desses tipos polimórficos?

  • 772

Estou limitado ao C++17. Preciso fazer uma estrutura de árvore (não necessariamente binária) que possa ser profundamente copiada em 2 clones independentes. Atualmente, tenho uma Nodeclasse de interface onde há 2 implementações:

  1. Uma Operationclasse contém um enum representando a operação booleana a ser realizada em seus std::vector<std::unique_ptr<Node>>operandos. Esses constituem os ramos na árvore.

  2. Uma Conditionclasse contém os dados que serão comparados quando for dito para avaliar. Eles compõem as folhas na árvore.

Por fim, tenho uma Eventclasse com a std::unique_ptrque aponta para a raiz Nodedesta árvore. Tanto Operationan quanto Conditionpodem ser a raiz da árvore.

Tenho seguido esta postagem do blog em relação à clonagem adequada de um std::unique_ptr, mas não sei bem como manter a parte polimórfica dos construtores de cópia das classes Eventand Operation. Ter esses construtores de cópia é uma parte inerente do meu problema?

#include <algorithm>
#include <memory>
#include <string>
#include <vector>

namespace tree
{
struct Node
{
    // Virtual clone function to make a new std::unique_ptr
    // with a copy of the contents of the old std::unique_ptr
    // Both std::unique_ptrs will be independent of each other
    virtual std::unique_ptr<Node> clone() const = 0;

    std::string name;
};

enum class Boolean
{
    And,
    Or,
    Xor
};

struct Operation : public Node
{
    // Copy constructor (because copying a std::vector is non-trivial)
    // that will allocate a new std::vector of the same size and clone
    // new std::unique_ptrs from the other std::vector
    Operation(const Operation &other) : op(other.op), nodes(other.nodes.size())
    {
        std::transform(other.nodes.cbegin(), other.nodes.cend(), nodes.begin(),
            [](const auto &old) {
                // This line has the compilation error because Node is abstract,
                // but I need this for the polymorphism, correct?
                return op ? std::make_unique<Node>(old->clone()) : nullptr;
            });
    }
    
    // Clones this class
    virtual std::unique_ptr<Node> clone() const override
    {
        return std::make_unique<Operation>(*this);
    }
    
    Boolean op;
    // Can hold any number of other Operation or Condition objects
    std::vector<std::unique_ptr<Node>> nodes;
};

struct Condition : public Node
{
    // Clones this class
    virtual std::unique_ptr<Node> clone() const override
    {
        return std::make_unique<Condition>(*this);
    }
    
    int datum;
};

struct Event
{
    Event(std::string name) : name(name) {}
    // This line has the same compilation error
    Event(const Event &other) : name(other.name), root(std::make_unique<Node>(other.root->clone())) {}
    std::string name;
    std::unique_ptr<Node> root;
};
} // tree
c++

2 respostas

  1. Best Answer

    Você já sabe como clonar um objeto polimórfico. Você só precisa usar a funcionalidade de clonagem corretamente em seus construtores de cópia. Você não deve usar std::make_unique<Node>()para copiar um clone, apenas use o clone como está, por exemplo:

    struct Operation : public Node
{
    ...

    Operation(const Operation &other) : ..., nodes(other.nodes.size())
    {
        std::transform(other.nodes.cbegin(), other.nodes.cend(), nodes.begin(),
            [](const auto &node) -> std::unique_ptr<Node> {
                return node ? node->clone() : nullptr;
            }
    }
    
    ...
};

struct Event
{
    ...

    Event(const Event &other) : ..., root(other.root ? other.root->clone() : nullptr) {}

    ...
};

    Como alternativa, você pode usar uma função auxiliar para tornar a clonagem um pouco mais limpa:

    // helper
std::unique_ptr<Node> cloneNode(const std::unique_ptr<Node> &node) {
    return node ? node->clone() : nullptr;
}


struct Operation : public Node
{
    ...

    Operation(const Operation &other) : ..., nodes(other.nodes.size())
    {
        std::transform(other.nodes.cbegin(), other.nodes.cend(), nodes.begin(), cloneNode);
    }
    
    ...
};

struct Event
{
    ...

    Event(const Event &other) : ..., root(cloneNode(other.root)) {}

    ...
};
    • 3

  2. std::make_unique<Node>precisa Nodeser completo, porque ele tem que procurar por Nodeconstrutores s. Mas Nodeé abstrato e não pode ser construído por si só.

    A construção de movimento de um std::unique_ptr<Node>, por outro lado, apenas copia um ponteiro.

    Altere a linha para:

    return op ? op->clone() : nullptr;

    E o mesmo para a outra linha.

    Demonstração ao vivo

    • 2

relate perguntas