разрешение перегрузки с использованием базовой функции-члена, введенной в производный класс

Question

Согласно некоторым цитатам в стандарте:
[over.match.funcs] / 4

[...] Для функций без преобразования, представленных Используя объявление в производном классе, функция считается членом производного класса с целью определения типа параметра неявного объекта.

И рассмотрим следующий код:

#include <iostream>
struct Base {
    void show(double) {
        std::cout << "0" << std::endl;
    }
};
struct Test :Base {
    using Base::show;  //#1
    void show(double) { //#2
        std::cout << "1" << std::endl;
    }
};
int main() {
    Test t;
    t.show(1.2);
}

В соответствии со стандартом, который я привел, это означает, что параметр объекта имплика типа Test принимается как #1 .
Для #1 объявление будет show(Test&,double).
Для #2 объявление будет show(Test&,double).
, поэтому в целях разрешения перегрузки каждая неявная последовательность преобразования #1 неотличим от #2, вызов t.show(1.2) будет неоднозначным, однако называется #2, почему? если я что-то пропущу в стандарте, поправьте меня.

Answer 1

Test::show(double) имеет такую ​​же подпись с Base::show(double); он просто скрывает тот из базового класса.

Для с использованием объявления ,

(выделение мое)

Если у производного класса уже есть член с тем же именем, списком параметров и квалификациями, член производного класса скрывает или переопределяет (не конфликтует) член, представленный в базовом классе.

Из стандарта [namespace.udecl] / 14

Когда объявление-использование переносит объявления из базового класса в производный класс , функции-члены и шаблоны функций-членов в производном классе переопределяют и / или скрывают функции-члены и шаблоны функций-членов с одним и тем же именем, тип-списка параметров ([dcl.fct]), конечный пункт require (если есть), cv -квалификация и ref-квалификатор (если есть) в базовом классе (а не конфликтующий). Такие скрытые или переопределенные объявления исключаются из набора объявлений, введенных с помощью-объявления. [Пример:

struct B {
  virtual void f(int);
  virtual void f(char);
  void g(int);
  void h(int);
};

struct D : B {
  using B::f;
  void f(int);      // OK: D​::​f(int) overrides B​::​f(int);

  using B::g;
  void g(char);     // OK

  using B::h;
  void h(int);      // OK: D​::​h(int) hides B​::​h(int)
};

...