Re[4]: Шаблонные функции, непонятно... - C/C++

Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Частичную специализацию шаблонов функций, в принципе, не поддерживают никакие компиляторы.
ПК>По крайней мере, стандарт ее точно не разрешает.

Точно. У БС пример с классами... Куда смотрели мои глаза?

А почему решили не делать такое с функциями?

U>>>

 U>>> template<class T> bool cmp( T a, T b)
 U>>> template<class T> bool cmp < T* > ( T* a, T* b)
 U>>>

P>> Это частичная специализация, которую версии Visual C++ меньше 7.1 не
P>> поддерживают в принципе

ПК> Частичную специализацию шаблонов функций, в принципе, не
ПК> поддерживают никакие компиляторы. По крайней мере, стандарт ее точно не
ПК> разрешает.
Просмотрел, что это не методы класса.

Пора отдыхать

Posted via RSDN NNTP Server 1.6 RC1

Здравствуйте, UGN, Вы писали:

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

Здравствуйте, UGN, Вы писали:

ПК>> Частичную специализацию шаблонов функций <...> стандарт <...> точно не разрешает.

U> А почему решили не делать такое с функциями?

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

Это, в некотором роде, спорное утверждение. См., например:
http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2001/n1295.htm.
Вкратце там сказано, что в namespace std нельзя добавлять перегруженные функции/шаблоны функций,
поэтому некоторые стандартные компоненты "подменить" нельзя. Следствием этого является, в частности,
то, что перегрузить std::swap для своих шаблонов нельзя.

С другой стороны, стандарт не вполне точен в отношении того, как именно разработчики стандартной
библиотеки должны вызывать стандартные функции: используя полностью квалифицированные имена, или
нет (дефекты #225 и #229 стандартной библиотеки), поэтому, вполне возможно, что поиска, зависящего
от аргументов, окажется достаточным для этих целей.

Posted via RSDN NNTP Server 1.6 RC1

Здравствуйте, Bell, Вы писали:

B>тут дело не в частичной специализации, а в overload resolution для шаблонных функций. А у VC6 с этим вроде не все в порядке.

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

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

Теперь по поводу указателей на константу.

Если определить int n, то &n имеет тип int*.
А для выведенных аргументов применять всяческие приведения нельзя,
поэтому второй шаблон с константными квалификаторами игнорировался
и оба раза использовался общий шаблон. Правильно?

Здравствуйте, UGN, Вы писали:

UGN>Т.е. на этапе перебора всех подходящих шаблонных функций и
UGN>определения более специализированных компилятор считает обе формы идентичными...
UGN>Отсюда и неопределенность.

Да.

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

Да. Обычная функция имеет преимущество перед шаблонной.

UGN>Теперь по поводу указателей на константу.

UGN>Если определить int n, то &n имеет тип int*.
UGN>А для выведенных аргументов применять всяческие приведения нельзя,
UGN>поэтому второй шаблон с константными квалификаторами игнорировался
UGN>и оба раза использовался общий шаблон. Правильно?

Не совсем понял о чем речь — "второй шаблон" — это где?

Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Потому что посчитали, что раз есть перегрузка шаблонов функций, то частичная специализация
ПК>для них не нужна.

Понятно...

А вот еще вопросик по 13 главе. С++ Programming Language SE (3)

В самом начале п.13.4.1 Default Template Parameters приводится пример

Explicitly specifying the comparison criteria for each call is tedious. Fortunately, it is easy to pick
a default so that only uncommon comparison criteria have to be explicitly specified. This can be
implemented through overloading:

template< class T, class C >
int compare( const String<T>& str1, const String<T>& str2 ); // compare using C

template< class T >
int compare( const String<T>& str1, const String<T>& str2 ); // compare using Cmp<T>

Собственно вопрос: А почему во втором случае будет использоваться Cmp<T>, откуда он там возьмется?
Я что-то упустил?

Здравствуйте, Bell, Вы писали:

UGN>>Если определить int n, то &n имеет тип int*.
UGN>>А для выведенных аргументов применять всяческие приведения нельзя,
UGN>>поэтому второй шаблон с константными квалификаторами игнорировался
UGN>>и оба раза использовался общий шаблон. Правильно?

B>Не совсем понял о чем речь — "второй шаблон" — это где?

здесь


template<class T> bool cmp(T a, T b) 
template<class T> bool cmp(const T* a, const T* b)

Здравствуйте, UGN, Вы писали:

U>

U> template< class T, class C >
U> int compare( const String<T>& str1, const String<T>& str2 ); // compare using C

U> template< class T >
U> int compare( const String<T>& str1, const String<T>& str2 ); // compare using Cmp<T>
U>

U> А почему во втором случае будет использоваться Cmp<T>, откуда он там возьмется?

Ее будет использовать реализация второго варианта. Например, так:

template< class T >
int compare( const String<T>& str1, const String<T>& str2 ) // compare using Cmp<T>
{
  return compare<Cmp<T>, T>(str1, str2);
}

Posted via RSDN NNTP Server 1.6 RC1

Здравствуйте, Павел Кузнецов, Вы писали:

U>> А почему во втором случае будет использоваться Cmp<T>, откуда он там возьмется?

ПК>Ее будет использовать реализация второго варианта. Например, так:

ПК>

ПК>template< class T >
ПК>int compare( const String<T>& str1, const String<T>& str2 ) // compare using Cmp<T>
ПК>{
ПК>  return compare<Cmp<T>, T>(str1, str2);
ПК>}
ПК>

А, просто другая реализация... А то я уж подумал, что там какая-то магия...
Для первого варианта реализация есть и там используется C, а что со вторым я ниппоньял...

Спасибо.

Здравствуйте, UGN, Вы писали:

UGN>Здравствуйте, Bell, Вы писали:

UGN>>>Если определить int n, то &n имеет тип int*.
UGN>>>А для выведенных аргументов применять всяческие приведения нельзя,
UGN>>>поэтому второй шаблон с константными квалификаторами игнорировался
UGN>>>и оба раза использовался общий шаблон. Правильно?

B>>Не совсем понял о чем речь — "второй шаблон" — это где?

UGN>здесь
UGN>


UGN>template<class T> bool cmp(T a, T b) 
UGN>template<class T> bool cmp(const T* a, const T* b) 
UGN>

Ага, теперь ясно.
Тут ты не прав: при overload resolution рассматриваются специализации обоих шаблонов, полученные во время дедуцирования аргументов. Они (специадизации) имеют такие сигнатуры:

bool <int*> cmp(int*, int*)//1
bool <int> cmp(const int*, const int*)//2

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

bool cmp(int* p1, int*p2)//1
{
//...
}

bool cmp(const int* p1, const int*p2)//2
{
//...
}

//...
int n;
cmp(&n, &n);

будет вызвана функция 1. Тут даже VC6 все делает так, как надо

Здравствуйте, Bell, Вы писали:

B>Ага, теперь ясно.
B>Тут ты не прав: при overload resolution рассматриваются специализации обоих шаблонов, полученные во время дедуцирования аргументов. Они (специадизации) имеют такие сигнатуры:
B>

B>bool <int*> cmp(int*, int*)//1
B>bool <int> cmp(const int*, const int*)//2
B>

B>очевидно, что специализация 1 выигрывает.

Дык и я о том же, наверное...

Почему выигрывает первая специализация?
Потому что const int* и просто int* — разные типы... Так?
Компилятор мог бы использовать второй шаблон,
сконвертировав типы аргументов, но это ему запрещено.
Поэтому он выводит нужную реализацию из общего шаблона. Так?

Здравствуйте, UGN, Вы писали:

UGN>Почему выигрывает первая специализация?
UGN>Потому что const int* и просто int* — разные типы... Так?
Да.
UGN>Компилятор мог бы использовать второй шаблон,
UGN>сконвертировав типы аргументов,
конечно, если бы не было более подходящего варианта.
UGN>но это ему запрещено.
Вовсе нет. убери из кода первый шаблон, и компилятор спокойно организует вызов ыторого.
UGN>Поэтому он выводит нужную реализацию из общего шаблона. Так?
Компилятор использует специализацию первого шаблона из-за того того, что полученные типы параметров ближе к реальному типу передаваемых аргументов.

Здравствуйте, Vamp, Вы писали:

так и должно быть. первое соответствие выбирается. попробуй тип шаблонного параметра укажи

V>

V>template<class T> bool cmp(T a, T b) {
V>    cout << "General template function called" << endl;
V>        return  (a<b);

V>}

V>template<class T> bool cmp(const T* a, const T* b) {
V>    cout << "Pointer template function called" << endl;
V>        return (*a<*b);
V>}

V>int j=5, i=7;
V>cmp<int>(g, j);
V>cmp<int>(&g, &j);
V>

	От:	UGN
	Дата:	17.07.03 14:02
	Оценка:

	От:	PM
	Дата:	17.07.03 14:04
	Оценка:

	От:	Bell
	Дата:	17.07.03 14:13
	Оценка:

	От:	Павел Кузнецов
	Дата:	17.07.03 14:30
	Оценка:	14 (1)

	От:	UGN
	Дата:	17.07.03 14:34
	Оценка:

	От:	ilnar
	Дата:	21.07.03 09:51
	Оценка: