Caduchon's questions

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

Veja o código a seguir contendo 3 implementações de uma função que chama outra função de lançamento.

# include <stdexcept>

void f()
{
    throw std::runtime_error("");
}

void g1()
{
    f();
}

void g2() noexcept
{
    f();
}

void g3() noexcept
{
    try{ f(); } catch(...){ std::terminate(); }
}

int main()
{
    return 0;
}

No meu entendimento da noexceptespecificação, g2e g3são estritamente equivalentes. Mas, quando compilo no Compiler Explorer com GCC, o código gerado é estritamente equivalente para g1and g2, mas não para g3:

g1():
        push    rbp
        mov     rbp, rsp
        call    f()
        nop
        pop     rbp
        ret
g2():
        push    rbp
        mov     rbp, rsp
        call    f()
        nop
        pop     rbp
        ret
g3():
        push    rbp
        mov     rbp, rsp
        call    f()
        jmp     .L9
        mov     rdi, rax
        call    __cxa_begin_catch
        call    std::terminate()
.L9:
        pop     rbp
        ret

Por que ?

Estou escrevendo uma classe herdada de std::unique_ptrclasses que possuem uma função de clone:

template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
    public:
        cl_ptr() noexcept = default;
        cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
        cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
        cl_ptr(cl_ptr<T>&&) noexcept = default;
        cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
        cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
        ~cl_ptr() noexcept = default;
};

Recebo um erro ao tentar converter de uma instância com type Tpara uma instância com type T const:

cl_ptr<Foo> p1(new Foo);
cl_ptr<Foo const> p2 = p1; // <- Compiler error here
// error: conversion from ‘cl_ptr<Foo>’ to non-scalar type ‘cl_ptr<const Foo>’ requested

Mas não sei como implementá-lo .

Claro que não quero que este código seja compilado:

cl_ptr<Foo const> p1(new Foo);
cl_ptr<Foo> p2 = p1; // <- Always wrong

Exemplo mínimo reproduzível:

# include <memory>

template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
    public:
        cl_ptr() noexcept = default;
        cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
        cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
        cl_ptr(cl_ptr<T>&&) noexcept = default;
        cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
        cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
        ~cl_ptr() noexcept = default;
};

class Foo
{
    public:
        Foo() = default;
        Foo(Foo const&) = default;
        ~Foo() noexcept = default;
        Foo* clone() const { return new Foo(*this); }
};

int main()
{
    cl_ptr<Foo> p1(new Foo);
    cl_ptr<Foo const> p2 = p1;
    cl_ptr<Foo> p3 = p2; // must fail

    return 0;
}