Início / coding / Perguntas / 79050362
Accepted
Paul Sheppard
Asked: 2024-10-03 19:39:20 +0800 CST

Usando operador de classe base = sobrecarga não está construindo

  • 772

Neste código de exemplo, por que não está using IParameterBase<TYPE>::operator=; funcionando e o operador de atribuição de classe base está funcionando?

Mudei recentemente para esta versão de modelo; antes eu escrevia classes de tipos individuais onde esse mecanismo funcionava.

#include <cstdint>
#include <cstddef>
    
    class IParameter
    {
    public:
        explicit IParameter(const size_t size) : size_{size} {};
        virtual ~IParameter() = default;

        virtual void copy(uint8_t*& addr) = 0;
    private:
        const size_t size_;
    };

    template <class TYPE>
    class IParameterBase : public IParameter
    {
    public:
        explicit IParameterBase(const TYPE value) : IParameter{sizeof(TYPE)}, value_{value} {};
        ~IParameterBase() = default;

        virtual void update(const TYPE value) = 0;

        operator auto() const {return get();};

        TYPE operator= (const TYPE value) { update(value); return get(); };

        TYPE get() const {return value_;};

        protected:
        TYPE value_;
    };

    template <class TYPE>
    class ParameterTx : public IParameterBase<TYPE>
    {
    public:
        explicit ParameterTx(const TYPE value) : IParameterBase<TYPE>{value} {};

        using IParameterBase<TYPE>::operator=;

        void copy(uint8_t*& addr) override
        {
            /* copy stuff */
        }
        void update(const TYPE value) override
        {
            this->value_ = value;
        }
    };


int main ()
{
    ParameterTx<uint16_t> param1{0};
    ParameterTx<uint16_t> param2{1};

    param1 = 16;
    param2 = 5;

    param1 = param2;
}

Código aqui: https://godbolt.org/z/3vqd4ebYM

Espero que a atribuição na parte inferior param1 = param2;seja resolvida para uint16_t, em vez disso, ela está tentando copiar o objeto, o que não é o que eu quero.

c++

2 respostas

  1. Best Answer

    o compilador incluiu esta função extra.

    template <class TYPE>
class IParameterBase : public IParameter
{
public:
...
  TYPE operator= (const TYPE value) { update(value); return get(); };

   // this next one
  IParameterBase<TYPE>& operator= (const IParameterBase<TYPE>& value) = delete;
...
};

    porque a base IParameternão é copiável, pois tem um membro const.

    Com o código acima, o compilador não tem permissão para compilar a atribuição param1 = param2porque o operador de atribuição excluído é uma correspondência exata, enquanto o outro requer uma conversão implícita.

    a solução aqui é recuperar o operador de atribuição excluído dentroIParameterBase

    TYPE operator= (const IParameterBase<TYPE>& value) 
{ update(value.value_); return this->get(); };

    demonstração de godbolt

    • 6

  2. por que usar IParameterBase::operator=; e o operador de atribuição de classe base não está funcionando? em vez disso, ele está tentando copiar o objeto.

    Porque quando você escreveu param1 = param2você está passando param2para o parâmetro da atribuição operator=e param2é do tipo ParameterTx<uint16_t>então somente a atribuição de cópia excluída operator= é um candidato porque aquele comprado por using IParameterBase<TYPE>::operator=;tem um parâmetro do tipo const uint16_t value.

    E como o operador de atribuição de cópia é excluído porque a base IParametertem um membro const, temos o erro mencionado.

    Para resolver isso, você pode fazer uma conversão explícita antes de passar param2ou permitir que o herdado operator=(via using) participe da resolução de sobrecarga, desfazendo a exclusão do dado, IParameterBasecomo feito em outra resposta.

    • 4

relate perguntas