Почему int * оценивается как int * вместо int * * при подстановке в шаблонный параметр?

Question

[Qubc]

template<typename T> 
void f1(T var) { }

template<typename T> 
void f2(T * var) { }

int main(void) 
{
  int i;
  int * pi;

  f1(i); // f1<int>(i); // T == int // OK
  f1(pi);// f1<int*>(pi); // T == int * //  OK
  
  f2(&i); // f2<int*>(&i); // i is int // &i is int* // T == int * // ???
  f2(pi); // f2<int*>(pi); // pi is int * // T == int * // ??? 
  
  f2(&pi); // f2<int*>(&pi);
}

Почему f2(&i) оценивается как написано, а не как int * * ? Шаблонный аргументы используется для подстановки в шаблонный параметр. Шаблонный аргумент имеет тип int *. Тот же вопрос касается f2(pi); Что я не так понимаю?

Comments

[res2001]

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

[Qubc]

Обычно, если шаблонный тип внутри класса - то там всё логично. T или T* -реализует ровно тот тип, который передан в шаблонном аргументе или который будет выведен. А вот в этом примере ничего не понятно в этом смысле.

//: C05:FuncDef.cpp
#include <iostream>
using namespace std;
template<class T> T sum(T* b, T* e, T init = T()) {
  while(b != e)
    init += *b++;
  return init;
}

int main() {
  int a[] = { 1, 2, 3 };
  cout << sum(a, a + sizeof a / sizeof a[0]) << endl; // 6
} ///:~

[shurshur]

Qubc, а откуда сделан вывод, что f2<int*> нет? Я только что скомпилял этот код gcc, и в нём есть два варианта функций f1 и f2 - для int и int*:

00000000000011b9 W _Z2f1IiEvT_
00000000000011c7 W _Z2f1IPiEvT_
00000000000011d6 W _Z2f2IiEvPT_
00000000000011e5 W _Z2f2IPiEvPT_

[Qubc]

shurshur, спасибо большое, это была ошибка. Но в остальном вопрос открыт. Я ожидал, что передаче int * в T * будет int * *, а получается как получается.

[shurshur]

Qubc, нет, это как раз нормально, ведь мы передаём указатель на любой_тип, и любой_тип считается за T. Это можно обойти прямым указанием типа int* у f2, но тогда копилятор ожидаемо упадёт:

$ g++ -g y.cpp 
y.cpp: In function ‘int main()’:
y.cpp:16:12: error: cannot convert ‘int*’ to ‘int**’
   16 |   f2<int*>(pi); // f2<int>(pi); // pi is int * // T == int * // ???
      |            ^~
      |            |
      |            int*
y.cpp:5:13: note:   initializing argument 1 of ‘void f2(T*) [with T = int*]’
    5 | void f2(T * var) { }
      |         ~~~~^~~

upd: ой не то... В общем, так нормально собирается:

f2<int>(pi); // f2<int>(pi); // pi is int * // T == int * // ??? 
  f2<int*>(&pi); // f2<int*>(&pi);

[rPman]

f2(&i); // T - int, var - int*
f2(&pi); // T - int*, var - int**

можешь перепроверить, добавив std::cout << typeid(var).name() в функцию f2

[Евгений Шатунов]

Qubc,

Обычно, если шаблонный тип внутри класса - то там всё логично. T или T* -реализует ровно тот тип, который передан в шаблонном аргументе или который будет выведен. А вот в этом примере ничего не понятно в этом смысле.

Тебе надо просто читать больше книг по метапрограмированию. Александреску, Саттера, Джосаттиса, например. Много и долго. У тебя сейчас нет понимания как язык работает с шаблонными аргументами. Описанное тобой в цитате неверно.

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

f1<int>(i); // f1<int>(i); // T == int // OK
f1<int*>(pi);// f1<int*>(pi); // T == int * //  OK

f2<int>(&i); // f2<int>(&i); // i is int // &i is int* // T == int * // неправильно, T == int
f2<int>(pi); // f2<int>(pi); // pi is int * // T == int * // неправильно, T == int

f2<int*>(&pi); // f2<int*>(&pi); // T == int*

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

[shurshur]

Короче, я сделал так:

template<typename T>
void f2(T * var) { std::cout << var << " " << *var << std::endl; }

Вывод:

0x7ffd85542ccc 22079
0x7ffd85542dd0 1
0x7ffd85542cd0 0x7ffd85542dd0

И видно, что реально указатели похожи на соседние адреса в стеке, как и должно быть. Первое равно случайному числу, третье - указателю на второе. Единственное что я не сразу понял - почему pi указывает на значение, равное 1, но потом я понял, что это случайно оказался указатель на argc, и если передавать параметры, то значение меняется. В теории могло указывать в никуда, ведь pi не инициализируется.

[Евгений Шатунов]

shurshur

int i;
int * pi;

Взятие значения неинициализированной переменной является UB.
Ты сейчас что-то сделал и что-то понял, но немного не то, что из этого кода можно понять. Просто потому что у тебя в коде теперь есть UB.

Правильно было бы написать так.

[shurshur]

Евгений Шатунов, я знаю что это неопределённое поведение и прямо написал об этом. Более того, я вообще ожидал, что в этом месте программа упадёт. Но по случайному совпадению вызывающая main функция оставила в этой части стека ссылку на argc, что забавно.

[Евгений Шатунов]

shurshur, ну, забавно - это правда. :)

[Qubc]

Короче, огромное большое спасибо за ответы, вернусь к этому чуть позже, пока сложно.

[Евгений Шатунов]

Qubc, а ты расскажи о своих сложностях. Тебе что-то конкретное не дается или в целом с выводом шаблонных аргументов не получается разобраться.
Я, может быть, смогу тогда и ответ тебе написать.

[Qubc]

template<typename T> void function1(T* begin ) { }

/* First instantiated from: insights.cpp:5 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void function1<int>(int * begin) { }
#endif

template<typename T> void function2(T begin ) { }

/* First instantiated from: insights.cpp:6 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void function2<int *>(int * begin) {  }
#endif

int main(void) {
  int * pointer;
  function1 (pointer);  
  function2 (pointer);
}

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