Чому б не зробити висновок параметра шаблону від конструктора?

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

template<typename obj>
class Variable {
      obj data;
      public: Variable(obj d)
              {
                   data = d;
              }
};

int main()
{
    int num = 2;
    Variable var(num); //would be equivalent to Variable<int> var(num),
    return 0;          //but actually a compile error
}

Як я кажу, я розумію, що це невірно, тому моє питання: чому це не так? Чи дозволить це створити якісь основні синтаксичні дірки? Чи є приклад, коли не хотілося б цього функціоналу (де виведення типу спричиняло б проблеми)? Я просто намагаюся зрозуміти логіку, що дозволяє виводити шаблони для функцій, але не для належним чином побудованих класів.

Я думаю, що це невірно, оскільки конструктор не завжди є єдиним пунктом вступу до класу (я говорю про конструктор копій та оператор =). Тож припустимо, що ви використовуєте свій клас так:

MyClass m(string s);
MyClass *pm;
*pm = m;

Я не впевнений, чи було б настільки очевидним, щоб парсер знав, який тип шаблону - це MyClass pm;

Не впевнений, що те, що я сказав, має сенс, але не соромтесь додати коментар, це цікаве питання.

C ++ 17

Прийнято, що C ++ 17 матиме виведення типу з аргументів конструктора.

Приклади:

std::pair p(2, 4.5);
std::tuple t(4, 3, 2.5);

Прийнятий папір .

Ви не можете робити те, що просите, з причин, з яких звернулися інші люди, але ви можете це зробити:

template<typename T>
class Variable {
    public: Variable(T d) {}
};
template<typename T>
Variable<T> make_variable(T instance) {
  return Variable<T>(instance);
}

що для всіх намірів і цілей - це те саме, що ви просите. Якщо ви любите інкапсуляцію, ви можете зробити make_variable статичною функцією члена. Ось що люди називають іменем конструктора. Отже, він не тільки робить те, що ви хочете, але майже називається тим, що ви хочете: компілятор виводить параметр шаблону з (названого) конструктора.

Примітка: будь-який розумний компілятор оптимізує тимчасовий об'єкт, коли ви пишете щось подібне

auto v = make_variable(instance);

У освічений вік 2016 року, з двома новими стандартами під нашим поясом, оскільки це питання було задано, і новий, прямо за рогом, важливо знати, що компілятори, що підтримують стандарт C ++ 17, скомпонують ваш код як є .

Вирахування шаблону-аргументу для шаблонів класу в C ++ 17

Тут (з редакції прийнятої Ольжасом Жумабеком прийнятої відповіді) є документ, в якому детально описані відповідні зміни до стандарту.

Вирішення проблем з інших відповідей

Поточна відповідь із найкращим рейтингом

Ця відповідь вказує, що "конструктор копіювання та operator=" не знав би правильних спеціалізацій шаблонів.

Це нісенітниця, оскільки стандартний конструктор копій і operator= існує лише для відомого типу шаблону:

template <typename T>
class MyClass {
    MyClass(const MyClass&) =default;
    ... etc...
};

// usage example modified from the answer
MyClass m(string("blah blah blah"));
MyClass *pm;   // WHAT IS THIS?
*pm = m;

Тут, як я зазначив у коментарях, немає підстав для MyClass *pmлегальної декларації з новою формою умовиводу або без неї: MyClass це не тип (це шаблон), тому не має сенсу оголошувати покажчик тип MyClass. Ось один із можливих способів виправити приклад:

MyClass m(string("blah blah blah"));
decltype(m) *pm;               // uses type inference!
*pm = m;

Тут pmє вже правильний тип, і тому висновок тривіально. Крім того, неможливо випадково змішати типи при виклику конструктора копій:

MyClass m(string("blah blah blah"));
auto pm = &(MyClass(m));

Тут pmбуде вказівник на копію m. Тут MyClassстворюється копія з - mякий має тип MyClass<string>(а не неіснуючий MyClass). Таким чином, в точці, де pmвиводиться тип, є достатньо інформації, щоб знати, що тип шаблону m, а отже, і тип шаблону pm, є string.

Більше того, наступне завжди призведе до помилки компіляції :

MyClass s(string("blah blah blah"));
MyClass i(3);
i = s;

Це відбувається тому, що декларація конструктора копіювання не шаблонована:

MyClass(const MyClass&);

Тут шаблон типу копіювання-конструктор аргумент відповідає шаблоном типу класу в цілому; тобто, коли MyClass<string>інстанціюється, MyClass<string>::MyClass(const MyClass<string>&);інстанціюється з нею, а коли MyClass<int>інстанціюється, MyClass<int>::MyClass(const MyClass<int>&);інстанціюється. Якщо це не вказано прямо або не буде оголошено шаблонований конструктор, компілятор не має жодних причин для ініціалізації MyClass<int>::MyClass(const MyClass<string>&);, що, очевидно, було б недоречно.

Відповідь Cătălin Pitiș

Pitiș наводить приклад виведення, Variable<int>а Variable<double>потім констатує:

У мене в коді однакове ім’я типу (Змінна) для двох різних типів (Змінна та Змінна). З моєї суб'єктивної точки зору, це сильно впливає на читабельність коду.

Як зазначалося в попередньому прикладі, Variableсама по собі не є назвою типу, хоча нова функція робить це схожим на одну синтаксичну.

Потім Piti asks запитує, що трапиться, якщо не буде надано жодного конструктора, який би дозволяв відповідне висновок. Відповідь полягає в тому, що не дозволяється робити висновок, оскільки висновок ініціюється викликом конструктора . Без конструктор-виклику немає висновку .

Це схоже на запитання про те, яка версія fooтут виведена:

template <typename T> foo();
foo();

Відповідь полягає в тому, що цей код є незаконним із зазначеної причини.

Відповідь MSalter

Наскільки я можу сказати, це єдина відповідь, щоб викликати законне занепокоєння щодо запропонованої функції.

Приклад:

Variable var(num);  // If equivalent to Variable<int> var(num),
Variable var2(var); // Variable<int> or Variable<Variable<int>> ?

Ключове питання полягає в тому, чи компілятор вибирає тут конструктор, що визначається типом, або конструктор копіювання ?

Випробувавши код, ми можемо побачити, що обрано конструктор копій. Щоб розгорнути на прикладі :

Variable var(num);          // infering ctor
Variable var2(var);         // copy ctor
Variable var3(move(var));   // move ctor
// Variable var4(Variable(num));     // compiler error

Я не впевнений, як це визначає пропозиція та нова версія стандарту; це, мабуть, визначається "посібниками щодо дедукції", які є новою частиною стандартів, які я ще не розумію.

Я також не впевнений, чому var4відрахування є незаконним; помилка компілятора від g ++, схоже, вказує на те, що оператор аналізується як оголошення функції.

Досі відсутній: Цей код робить досить неоднозначним:

int main()
{
    int num = 2;
    Variable var(num);  // If equivalent to Variable<int> var(num),
    Variable var2(var); //Variable<int> or Variable<Variable<int>> ?
}

Припустимо, що компілятор підтримує те, про що ви запитували. Тоді цей код дійсний:

Variable v1( 10); // Variable<int>

// Some code here

Variable v2( 20.4); // Variable<double>

Тепер у мене є одне й те саме ім'я (Variable) у коді для двох різних типів (Variable і Variable). З моєї суб'єктивної точки зору, це сильно впливає на читабельність коду. Маючи однакове ім’я типу для двох різних типів в одному просторі імен, мені здається оманливим.

Пізніше оновлення: ще одне, що слід врахувати: часткова (або повна) спеціалізація шаблонів.

Що робити, якщо я спеціалізуюся на змінній та не надаю такого конструктора, як ви очікуєте?

Тому я мав би:

template<>
class Variable<int>
{
// Provide default constructor only.
};

Тоді у мене є код:

Variable v( 10);

Що повинен робити компілятор? Використовуйте загальне визначення класу змінної, щоб визначити, що вона є змінною, а потім виявите, що змінна не забезпечує один конструктор параметрів?

Стандарт C ++ 03 і C ++ 11 не дозволяє виводити аргументи шаблону з параметрів, переданих конструктору.

Але є пропозиція "Вирахування параметрів шаблону для конструкторів", тож незабаром ви можете отримати те, про що ви просите. Редагувати: справді ця функція підтверджена для C ++ 17.

Дивіться: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.html та http://www.open-std.org/jtc1/sc22/wg21/docs/ документи / 2015 / p0091r0.html

Багато класів не залежать від параметрів конструктора. Є лише кілька класів, у яких є лише один конструктор, і параметризуються на основі типів (ив) цього конструктора.

Якщо ви дійсно потребуєте висновку шаблону, використовуйте функцію помічника:

template<typename obj>
class Variable 
{
      obj data;
public: 
      Variable(obj d)
      : data(d)
      { }
};

template<typename obj>
inline Variable<obj> makeVariable(const obj& d)
{
    return Variable<obj>(d);
}

Вирахування типів обмежується функціями шаблону в поточному C ++, але давно зрозуміло, що дедукція типів в інших контекстах була б дуже корисною. Звідси C ++ 0x auto.

Хоча саме те , що ви пропонуєте, буде неможливим у програмі C ++ 0x, наступні покази ви можете наблизитись:

template <class X>
Variable<typename std::remove_reference<X>::type> MakeVariable(X&& x)
{
    // remove reference required for the case that x is an lvalue
    return Variable<typename std::remove_reference<X>::type>(std::forward(x));
}

void test()
{
    auto v = MakeVariable(2); // v is of type Variable<int>
}

Ви маєте рацію, що компілятор може легко здогадатися, але це не в стандарті або C ++ 0x, наскільки я знаю, тому вам доведеться чекати принаймні ще 10 років (ISO-стандарти з фіксованим оборотом), перш ніж постачальники компіляторів додадуть цю функцію

Давайте розглянемо проблему з посиланням на клас, з яким всі повинні бути знайомими - std :: vector.

По-перше, дуже поширеним використанням вектора є використання конструктора, який не приймає жодних параметрів:

vector <int> v;

У цьому випадку, очевидно, ніякий висновок не може бути виконаний.

Друге поширене використання - це створення попереднього розміру вектора:

vector <string> v(100);

Ось, якщо були використані умовиводи:

vector v(100);

ми отримуємо вектор вставки, а не рядки, і, імовірно, він не розмір!

Нарешті, розглянемо конструктори, які приймають кілька параметрів - із "умовиводом":

vector v( 100, foobar() );      // foobar is some class

Який параметр слід використовувати для висновку? Нам знадобиться якийсь спосіб сказати компілятору, що він повинен бути другим.

З усіма цими проблемами для класу, простими як векторні, легко зрозуміти, чому умовивод не використовується.

Зробивши ctor шаблоном Змінна може мати лише одну форму, але різні цитри:

class Variable {
      obj data; // let the compiler guess
      public:
      template<typename obj>
      Variable(obj d)
       {
           data = d;
       }
};

int main()
{
    int num = 2;
    Variable var(num);  // Variable::data int?

    float num2 = 2.0f;
    Variable var2(num2);  // Variable::data float?
    return 0;         
}

Побачити? Ми не можемо мати декілька членів змінної :: даних.

Додаткову інформацію про це див. У розділі Виведення аргументів шаблону C ++ .