Início / coding / Perguntas / 79495616
Accepted
Yuxai
Asked: 2025-03-09 16:28:28 +0800 CST

qual é a melhor maneira de introduzir o operador de conversão de modelo `operador T ()` da classe base

  • 772

usingdeclaração é comum e funciona para outros métodos de membros, incluindo construtor, mas para operador de conversão não parece tão simples. GCC tem sintaxe using base::operator basepara introduzir, que é negada por Clang. Declarar uma função forward é aceito por ambos os compiladores, mas é um pouco complicado na minha opinião.

exemplo foi testado com gcc 14.2.0 e clang 19.1.7, std=c++20. Herança SFINAE rejeitada por clang.

struct base {
  template <typename T> requires (std::is_integral_v<T>)
  operator T() const { printf("to int\n"); return 0; }
};
struct derived: base {
  //using base::operator;        // denied by clang & gcc
  //using base::operator base;   // denied by clang 

  template <typename T> requires (std::is_floating_point_v<T>)
  operator T() const { printf("to float\n"); return 0; }

  // both accept
  template <typename T> requires requires { (T) std::declval<base>(); }
  operator T() const { return base::operator T(); }
};

derived D;
(int)   D;  // -> to int
(float) D;  // -> to float
c++

2 respostas

  1. Os modelos de função de conversão são uma das poucas coisas que você não pode herdar via using-declaration ( [namespace.udecl] p1 ):

    Cada using-declarator em uma using-declaration nomeia o conjunto de declarações encontradas por lookup ([basic.lookup.qual]) para o using-declarator , exceto que [...], modelos de função de conversão com um tipo de retorno dependente são ignorados, e [...].

    O fato é que o GCC aceita using base::operator base;o bug conhecido 29027 , que não foi resolvido desde 2006.

    Sua solução alternativa já está boa, mas pode ser ligeiramente melhorada:

    struct base {
  // use concept instead of requires with type trait
  template <std::integral T>
  operator T() const { printf("to int\n"); return 0; }
};

struct derived: base {
  // also use concept here
  template <std::floating_point T>
  operator T() const { printf("to float\n"); return 0; }

  // use std::convertible_to, which checks that implicit conversion is possible,
  // not just explicit conversion (like in your "(T) ..." test)
  template <typename T> requires std::convertible_to<base, T>
  operator T() const { return base::operator T(); }
};
    • 4
  2. Best Answer

    Usando declaração :

    Uma declaração de uso não pode se referir a um namespace, a um enumerador com escopo (até C++20), a um destruidor de uma classe base ou a uma especialização de um modelo de membro para uma função de conversão definida pelo usuário .

    Então, você terá que recorrer a soluções alternativas, como a que você tem atualmente.

    • 2

relate perguntas