Видимость члена класса в подписи объявления функции-члена

template <typename A>
struct S {
A a;
template <typename B>
auto f(B b) ->
decltype(a.f(b))
{
}
};

Это работает, потому что внутри конечного возвращаемого типа члены окружающего класса видны. Не все члены, а только члены, объявленные до этого (в конце типа возврата класс не считается завершенным, в отличие от функциональных органов). Итак, что здесь сделано:

• Поскольку мы находимся в шаблоне, выполняется поиск, чтобы увидеть, a зависит или нет. поскольку a было объявлено до f, a найдено, чтобы обратиться к члену класса.

• По правилам шаблонов в C ++ установлено, что a ссылается на член текущего экземпляра, так как он является членом экземпляров окружающего шаблона. В C ++ это понятие используется главным образом для определения того, являются ли имена зависимыми: если известно, что имя ссылается на члены окружающего шаблона, его не обязательно искать при создании экземпляра, поскольку компилятор уже знает код шаблона (который используется как основание для класса, созданного из него!). Рассматривать:

  template<typename T>
  struct A {
  typedef int type;
  void f() {
  type x;
  A<T>::type y;
  }
  };
  

В C ++ 03 вторая строка объявляется y было бы ошибкой, потому что A<T>::type был зависимым именем и нуждался в typename перед ней. Только первая строка была принята. В C ++ 11 это несоответствие было исправлено, и оба типа имен независимы и не нуждаются в typename, Если вы измените typedef на typedef T type; тогда обе декларации, x а также y будет использовать зависимый тип, но ни понадобится typenameпотому что вы все еще называете элемент текущего экземпляра, и компилятор знает, что вы называете тип.

• Так a является членом текущего экземпляра. Но это зависит, потому что тип используется для его объявления (A) зависит. Однако это не имеет значения в вашем коде. Независимо от того, зависим или нет, a найден и код действителен.

template <typename A>
struct S {
template <typename B>
auto f(B b) ->
decltype(a.f(b))
{
}
A a;
};

В этом коде снова a ищется, чтобы увидеть, является ли он зависимым и / или является ли он членом текущего экземпляра. Но так как мы узнали выше, что члены, объявленные после завершающего возвращаемого типа, не видны, мы не можем найти объявление для a, В C ++, кроме понятия «член текущего экземпляра», есть другое понятие:

• член неизвестной специализации. Это понятие используется для обозначения случая, когда имя может вместо этого ссылаться на члена класса, который зависит от параметров шаблона. Если бы мы получили доступ B::aтогда a будет членом неизвестной специализации, потому что это неизвестный какие объявления будут видны когда B заменяется при создании экземпляра.

• Ни член действующего, ни член неизвестной специализации. Это касается всех остальных имен. Ваш случай подходит здесь, потому что известно, что a никогда не может быть членом какого-либо экземпляра, когда это происходит (помните, что поиск имени не может найти a, так как он объявлен после f).

поскольку a не зависит от какого-либо правила, поиск, который не нашел никакого объявления переплет, это означает, что нет другого поиска в экземпляре, который мог бы найти объявление. Независимые имена ищутся во время определения шаблона. Теперь GCC по праву выдает ошибку (но учтите, что, как всегда, неправильно сформированный шаблон не требует немедленной диагностики).

template <typename A>
struct S {
template <typename B>
auto f(B b) ->
decltype(this->a.f(b))
{
}
A a;
};

В этом случае вы добавили this и GCC принято. Имя a что следует this-> снова ищем, может ли он быть членом текущего экземпляра. Но, опять же, из-за видимости члена в конечных типах возврата, объявление не найдено. Следовательно, имя считается не являющимся членом текущего экземпляра. Так как при реализации не существует способа, S может иметь дополнительных членов, которые a может соответствовать (нет базовых классов S которые зависят от параметров шаблона), имя также не является членом неизвестной специализации.

Снова C ++ не имеет правил, чтобы сделать this->a зависимый. Однако он использует this->так имя должен обратитесь к некоторому члену S когда он будет создан! Таким образом, стандарт C ++ говорит

Точно так же, если id-выражение в выражении доступа к члену класса, для которого тип выражения объекта является текущим экземпляром, не ссылается на член текущего экземпляра или член неизвестной специализации, программа является некорректной даже если шаблон, содержащий выражение доступа к элементу, не создан; Диагностика не требуется.

Опять же, для этого кода не требуется никакой диагностики (и GCC фактически не дает его). Id-выражение a в выражении доступа к члену this->a зависел в C ++ 03, потому что правила в этом стандарте были не такими сложными и отлаженными, как в C ++ 11. На мгновение представим, что C ++ 03 decltype и конечные типы возврата. Что бы это значило?

• Поиск был бы отложен до создания экземпляра, потому что this->a будет зависеть
• Поиск в экземпляре, скажем, S<SomeClass> потерпит неудачу, потому что this->a не будет найден во время создания экземпляра (как мы уже говорили, конечные типы возврата не видят члены, объявленные позже).

Следовательно, раннее отклонение этого кода на C ++ 11 хорошо и полезно.