Где и почему я должен разместить шаблон & ldquo; template & rdquo; и & ldquo; typename & rdquo; ключевые слова?

Для парсинга программы C++ компилятор должен знать, являются ли определенные имена типами или нет. Следующий пример демонстрирует что:

t * f;

, Как это должно быть проанализировано? Для многих языков компилятор не должен знать значение имени, чтобы проанализировать и в основном знать, какое действие строка кода делает. В C++ вышеупомянутое однако может привести к весьма различным интерпретациям в зависимости от какой t средства. Если это будет тип, то это будет объявление указателя f. Однако, если это не будет тип, то это будет умножение. Таким образом, в Стандарте C++ говорится в абзаце (3/7):

Некоторые имена обозначают типы или шаблоны. В целом, каждый раз, когда с именем встречаются, необходимо определить, обозначает ли то имя один из этих объектов прежде, чем продолжить анализировать программу, которая содержит его. Процесс, который определяет это, называют поиском имени.

, Как компилятор узнает то, к чему относится имя t::x, если t относится к шаблонному параметру типа? x мог быть статический международный элемент данных, который мог быть умножен или мог одинаково хорошо быть вложенным классом или определением типа, которое могло уступить объявлению. Если имя имеет это свойство - что это нельзя посмотреть вплоть до фактических аргументов шаблона, известны - тогда оно звонило зависимое имя (оно "зависит" от шаблонных параметров).

Вы могли бы рекомендовать просто ожидать, пока пользователь не инстанцирует шаблона:

Позволяют нам ожидать, пока пользователь не инстанцирует шаблона, и затем позже узнайте реальное значение [1 115].

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

, Таким образом, должен быть способ сказать компилятору, что определенные имена являются типами и что определенные имена не.

ключевое слово

"имени типа" ответ: Мы решаем, как компилятор должен проанализировать это. Если t::x зависимое имя, то мы должны снабдить префиксом его [1 117], чтобы сказать компилятору анализировать его определенным способом. В Стандарте говорится в (14.6/2):

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

существует много имен, для которых typename не необходимо, потому что компилятор, с применимым поиском имени в шаблонном определении, может выяснить, как проанализировать саму конструкцию - например, с [1 119], когда T шаблонный параметр типа. Но чтобы t::x * f; было объявление, оно должно быть записано как [1 122]. Если Вы опускаете ключевое слово, и имя взято, чтобы быть нетипом, но когда инстанцирование находит, что обозначает тип, обычные сообщения об ошибках испускаются компилятором. Иногда, ошибка, следовательно, дана во время определения:

// t::x is taken as non-type, but as an expression the following misses an
// operator between the two names or a semicolon separating them.
t::x f;

синтаксис позволяет typename только перед полностью определенными именами - он для этого взят, как предоставлено, который дисквалифицированные имена, как всегда известно, отсылают к типам, если они делают так.

А подобный глюк существует для имен, которые обозначают шаблоны, как намекнули вводным текстом.

"шаблонное" ключевое слово

Помнит начальную кавычку выше и как Стандарт требует специальной обработки для шаблонов также? Давайте возьмем следующий невинно выглядящий пример:

boost::function< int() > f;

Это могло бы выглядеть очевидным для читателя. Не так для компилятора. Вообразите следующее произвольное определение boost::function и f:

namespace boost { int function = 0; }
int main() { 
  int f = 0;
  boost::function< int() > f; 
}

Это - на самом деле допустимое выражение ! Это использует меньше оператор для сравнения boost::function с нулем (int()) и затем использует большее - чем оператор для сравнения получающегося bool с [1 129]. Однако как Вы могли бы хорошо знать, boost::function в реальной жизни шаблон, таким образом, компилятор знает (14.2/3):

После того, как поиск имени (3.4) находит, что имя является шаблонным именем, если это имя сопровождается < < всегда берется в качестве начала шаблонного списка аргументов и никогда как имя, сопровождаемое меньше оператор.

Теперь мы вернулись к той же проблеме как с [1 131]. Что, если мы еще не можем знать, является ли имя шаблоном при парсинге кода? Мы должны будем вставить template сразу перед шаблонным именем, как определено [1 133]. Это похоже:

t::template f<int>(); // call a function template

Шаблонные имена могут не только произойти после ::, но также и после -> или . в членском доступе класса. Необходимо вставить ключевое слово там также:

this->template f<int>(); // call a function template

Зависимости

Для людей, которые имеют толстые книги Standardese по их полке и которые хотят знать то, о чем точно я говорил, я буду говорить немного о том, как это определяется в Стандарте.

В объявлениях шаблона некоторые конструкции имеют различные значения в зависимости от того, какие аргументы шаблона Вы используете для инстанцирования шаблона: Выражения могут иметь различные типы или значения, переменные могут иметь различные типы, или вызовы функции могли бы закончить тем, что вызвали различные функции. Такие конструкции обычно говорятся [1 173], зависят от шаблонных параметров.

template <typename T, typename Tail>
struct UnionNode : public Tail {
    // ...
    template<typename U> struct inUnion {
        typedef typename Tail::template inUnion<U> dummy;
    };
    // ...
};

typename t::template iterator<int>::value_type v;