Início / coding / Perguntas / 79433751
Accepted
Caduchon
Asked: 2025-02-13 00:14:18 +0800 CST

Visite a variante de classes aninhadas: como evitar código redundante?

  • 772

Tenho muitas classes polimórficas. Cada uma delas tem uma classe aninhada chamada Configurationcontendo todos os hiperparâmetros requeridos pela classe. Para cada árvore de classes, crio uma variante das configurações possíveis e uma função instantiatecapaz de criar a instância a partir da configuração. Como no exemplo abaixo.

# include <variant>
# include <memory>

class Base
{};

class A : public Base
{
    public:
        struct Configuration { /*hyperparameters*/ };
        A(Configuration const&) {}
};

class B : public Base
{
    public:
        struct Configuration { /*hyperparameters*/ };
        B(Configuration const&) {}
};

struct BaseConfiguration
{
    using type = std::variant<A::Configuration, B::Configuration>;
    static std::unique_ptr<Base> instantiate(type const& config);
};

struct BaseVisitor
{
    // My problem is here...
    std::unique_ptr<Base> operator()(A::Configuration const& config)
    { return std::make_unique<A>(config); }
    std::unique_ptr<Base> operator()(B::Configuration const& config)
    { return std::make_unique<B>(config); }
};

std::unique_ptr<Base> BaseConfiguration::instantiate(type const& config)
{
    return std::visit(BaseVisitor(), config);
}

int main()
{
    BaseConfiguration::type config = A::Configuration();
    std::unique_ptr<Base> x = BaseConfiguration::instantiate(config);
    return 0;
}

Gostaria de evitar o código redundante na BaseVisitorclasse. Todas as funções são exatamente as mesmas (muitas funções para algumas hierarquias). Existe uma maneira de reduzir esse código? Tentei com a seguinte abordagem de modelo, mas não compila (com C++17).

struct BaseVisitor
{
    template <typename X>
    std::unique_ptr<Base> operator()(typename X::Configuration const& config)
    { return std::make_unique<X>(config); }
};

Erro do compilador:

<source>: In static member function 'static std::unique_ptr<Base> BaseConfiguration::instantiate(const type&)':
<source>:36:22: error: no matching function for call to 'visit(BaseVisitor, const BaseConfiguration::type&)'
   36 |     return std::visit(BaseVisitor(), config);
      |            ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~

O mesmo código no Compiler Explorer

c++

3 respostas

  1. Uma alternativa poderia ser declarar o tipo pai em cada configuração e depois usá-lo no seu visitante.

    #include <variant>
#include <memory>
#include <type_traits>

class Base
{};

class A : public Base
{
    public:
        struct Configuration {
            using Parent = A;
            /*hyperparameters*/
        };
        A(Configuration const&) {}
};

class B : public Base
{
    public:
        struct Configuration {
            using Parent = B;
            /*hyperparameters*/
        };
        B(Configuration const&) {}
};

struct BaseConfiguration
{
    using type = std::variant<A::Configuration, B::Configuration>;
    static std::unique_ptr<Base> instantiate(type const& config);
};

std::unique_ptr<Base> BaseConfiguration::instantiate(type const& config)
{
    return std::visit([&](const auto& config) -> std::unique_ptr<Base> {
    std::unique_ptr<Base> baseptr = std::make_unique<typename std::remove_cvref_t<decltype(config)>::Parent>(config);
    return baseptr;
}, config);
}

int main()
{
    BaseConfiguration::type config = A::Configuration();
    std::unique_ptr<Base> x = BaseConfiguration::instantiate(config);
    return 0;
}
    • 3
  2. Best Answer

    O truque todo é entregar o tipo esperado ao visitante. Aqui está uma das soluções possíveis:

    class Base
{
public:
    virtual ~Base() = default;
};

class A : public Base
{
    public:
        struct Configuration { 
            using configured_type = A;  
            /*hyperparameters*/ 
        };
        A(Configuration const&) {}
};

class B : public Base
{
    public:
        struct Configuration { 
            using configured_type = B;
            /*hyperparameters*/ 
        };
        B(Configuration const&) {}
};

struct BaseConfiguration
{
    using type = std::variant<A::Configuration, B::Configuration>;
    static std::unique_ptr<Base> instantiate(type const& config);
};


std::unique_ptr<Base> BaseConfiguration::instantiate(type const& config)
{
    return std::visit([] (const auto& detail_config) -> std::unique_ptr<Base> {
        using configured_type = typename std::decay_t<decltype(detail_config)>::configured_type;
        return std::make_unique<configured_type>(detail_config);
    }, config);
}

    https://godbolt.org/z/f37WhM898

    • 2

  3. Outra maneira de vincular a configuração à sua classe "pai" é usando modelo em vez de classes internas:

    template <typename T>
struct Configuration;

template <>
struct Configuration<class A>
{
    /*hyperparameters*/
};

class A : public Base
{
public:
    explicit A(Configuration<A> const&) {}
};

    E aqui Té dedutível para Configuration<T>contrário a T::Configuration.

    Então o visitante pode ser simplesmente:

    struct BaseVisitor
{
    template <typename T>
    std::unique_ptr<Base> operator()(Configuration<T> const& config) const
    { return std::make_unique<T>(config); }
};

    Demonstração

    Que pode ser transformado em lambda em C++20

    []<typename T>(Configuration<T> const& config) { return std::make_unique<T>(config); }
    • 0

relate perguntas