Mengapa tidak menyimpulkan parameter kerangka dari konstruktor?

pertanyaan saya hari ini cukup sederhana: mengapa kompilator tidak dapat menyimpulkan parameter template dari konstruktor kelas, sebanyak yang dapat dilakukan dari parameter fungsi? Misalnya, mengapa kode berikut tidak valid:

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
}

Seperti yang saya katakan, saya mengerti bahwa ini tidak valid, jadi pertanyaan saya adalah mengapa tidak? Akankah membiarkan ini menciptakan lubang sintaksis utama? Apakah ada contoh di mana orang tidak menginginkan fungsionalitas ini (di mana menyimpulkan suatu jenis akan menyebabkan masalah)? Saya hanya mencoba untuk memahami logika di balik mengizinkan inferensi template untuk fungsi, namun tidak untuk kelas yang dibuat dengan sesuai.

Saya pikir itu tidak valid karena konstruktor tidak selalu satu-satunya titik masuk kelas (saya berbicara tentang copy konstruktor dan operator =). Jadi misalkan Anda menggunakan kelas Anda seperti ini:

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

Saya tidak yakin apakah akan begitu jelas bagi parser untuk mengetahui jenis template apa MyClass pm;

Tidak yakin apakah yang saya katakan masuk akal tetapi jangan ragu untuk menambahkan komentar, itu pertanyaan yang menarik.

C ++ 17

Diterima bahwa C ++ 17 akan memiliki deduksi tipe dari argumen konstruktor.

Contoh:

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

Kertas yang diterima .

Anda tidak dapat melakukan apa yang Anda minta karena alasan orang lain menjawab, tetapi Anda dapat melakukan ini:

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

yang untuk semua maksud dan tujuan adalah hal yang sama yang Anda minta. Jika Anda menyukai enkapsulasi, Anda dapat menjadikan make_variable sebagai fungsi anggota statis. Itulah yang disebut orang dengan nama konstruktor. Jadi tidak hanya melakukan apa yang Anda inginkan, tetapi juga hampir disebut apa yang Anda inginkan: kompilator menyimpulkan parameter template dari konstruktor (bernama).

NB: kompiler yang masuk akal akan mengoptimalkan objek sementara ketika Anda menulis sesuatu seperti

auto v = make_variable(instance);

Di era pencerahan tahun 2016, dengan dua standar baru di bawah ikat pinggang kami sejak pertanyaan ini diajukan dan yang baru sudah dekat, hal penting untuk diketahui adalah bahwa kompiler yang mendukung standar C ++ 17 akan mengkompilasi kode Anda apa adanya .

Pengurangan argumen template untuk template kelas di C ++ 17

Di sini (hasil edit oleh Olzhas Zhumabek dari jawaban yang diterima) adalah makalah yang merinci perubahan yang relevan dengan standar.

Mengatasi masalah dari jawaban lain

Jawaban peringkat teratas saat ini

Jawaban ini menunjukkan bahwa "copy konstruktor dan operator=" tidak akan mengetahui spesialisasi template yang benar.

Ini tidak masuk akal, karena konstruktor salinan standar dan operator= hanya ada untuk jenis template yang dikenal :

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;

Di sini, seperti yang saya catat di komentar, tidak ada alasan untuk MyClass *pmmenjadi deklarasi hukum dengan atau tanpa bentuk inferensi baru: MyClass bukan tipe (ini template), jadi tidak masuk akal untuk mendeklarasikan pointer dari tipe MyClass. Berikut salah satu cara yang mungkin untuk memperbaiki contoh:

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

Berikut, pmadalah sudah dari jenis yang tepat, dan kesimpulan yang sepele. Selain itu, tidak mungkin untuk mencampur tipe secara tidak sengaja saat memanggil konstruktor salinan:

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

Di sini, pmakan menjadi penunjuk ke salinan m. Di sini, MyClasssedang dikonstruksi dari m—yang bertipe MyClass<string>(dan bukan tipe yang tidak ada MyClass). Dengan demikian, pada titik di mana pmtipe 's disimpulkan, ada adalah informasi yang cukup untuk mengetahui bahwa template-jenis m, dan karena itu template-jenis pm, yangstring .

Selain itu, berikut ini akan selalu memunculkan kesalahan kompilasi :

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

Ini karena deklarasi konstruktor salinan tidak memiliki template:

MyClass(const MyClass&);

Di sini, tipe template argumen copy-constructor cocok dengan tipe template kelas secara keseluruhan; yaitu, saat MyClass<string>dibuat instance, MyClass<string>::MyClass(const MyClass<string>&);dibuat instance-nya, dan ketika MyClass<int>dibuat, MyClass<int>::MyClass(const MyClass<int>&);dibuat instance-nya. Kecuali ditentukan secara eksplisit atau konstruktor templatized dideklarasikan, tidak ada alasan bagi compiler untuk membuat instanceMyClass<int>::MyClass(const MyClass<string>&); , yang jelas tidak sesuai.

Jawabannya oleh Cătălin Pitiș

Pitiș memberikan contoh deduksi Variable<int>dan Variable<double>, kemudian menyatakan:

Saya memiliki nama jenis yang sama (Variabel) dalam kode untuk dua jenis yang berbeda (Variabel dan Variabel). Dari sudut pandang subjektif saya, ini mempengaruhi keterbacaan kode cukup banyak.

Seperti disebutkan dalam contoh sebelumnya, Variableitu sendiri bukanlah nama tipe, meskipun fitur baru membuatnya terlihat seperti nama secara sintaksis.

Pitiș kemudian menanyakan apa yang akan terjadi jika tidak ada konstruktor yang diberikan yang mengizinkan inferensi yang sesuai. Jawabannya adalah tidak ada inferensi yang diizinkan, karena inferensi dipicu oleh panggilan konstruktor . Tanpa panggilan konstruktor, tidak ada inferensi .

Ini mirip dengan menanyakan versi apa fooyang disimpulkan di sini:

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

Jawabannya adalah kode ini ilegal, karena alasan yang disebutkan.

Jawaban MSalter

Ini, sejauh yang saya tahu, satu-satunya jawaban untuk memunculkan kekhawatiran yang sah tentang fitur yang diusulkan.

Contohnya adalah:

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

Pertanyaan kuncinya adalah, apakah kompilator memilih konstruktor tipe-tersirat di sini atau konstruktor salinan ?

Mencoba kodenya, kita dapat melihat bahwa konstruktor salinan dipilih. Untuk memperluas contoh :

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

Saya tidak yakin bagaimana proposal dan versi baru standar menentukan ini; tampaknya ditentukan oleh "panduan deduksi," yang merupakan sedikit bahasa standar baru yang saya belum mengerti.

Saya juga tidak yakin mengapa var4pemotongan tersebut ilegal; kesalahan kompilator dari g ++ tampaknya menunjukkan bahwa pernyataan tersebut sedang diurai sebagai deklarasi fungsi.

Masih hilang: Itu membuat kode berikut cukup ambigu:

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

Misalkan kompilator mendukung apa yang Anda minta. Maka kode ini valid:

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

// Some code here

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

Sekarang, saya memiliki nama jenis yang sama (Variabel) dalam kode untuk dua jenis yang berbeda (Variabel dan Variabel). Dari sudut pandang subjektif saya, ini mempengaruhi keterbacaan kode cukup banyak. Memiliki nama jenis yang sama untuk dua jenis yang berbeda dalam namespace yang sama tampak menyesatkan bagi saya.

Pembaruan nanti: Hal lain yang perlu dipertimbangkan: spesialisasi template sebagian (atau penuh).

Bagaimana jika saya mengkhususkan Variabel dan tidak memberikan konstruktor seperti yang Anda harapkan?

Jadi saya ingin:

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

Lalu saya punya kode:

Variable v( 10);

Apa yang harus dilakukan kompilator? Gunakan definisi kelas Variabel generik untuk menyimpulkan bahwa itu adalah Variabel, lalu temukan bahwa Variabel tidak menyediakan satu konstruktor parameter?

C ++ 03 dan standar C ++ 11 tidak mengizinkan pengurangan argumen template dari parameter yang diteruskan ke konsturuktor.

Tapi ada proposal untuk "Pengurangan parameter template untuk konstruktor" sehingga Anda bisa mendapatkan apa yang Anda minta segera. Sunting: memang, fitur ini telah dikonfirmasi untuk C ++ 17.

Lihat: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3602.html dan http://www.open-std.org/jtc1/sc22/wg21/docs/ makalah / 2015 / p0091r0.html

Banyak kelas tidak bergantung pada parameter konstruktor. Hanya ada beberapa kelas yang hanya memiliki satu konstruktor, dan melakukan parameterisasi berdasarkan jenis konstruktor ini.

Jika Anda benar-benar membutuhkan inferensi template, gunakan fungsi helper:

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);
}

Pengurangan tipe terbatas pada fungsi template di C ++ saat ini, tetapi telah lama disadari bahwa pengurangan tipe dalam konteks lain akan sangat berguna. Oleh karena itu C ++ 0x auto.

Sementara persis apa yang Anda sarankan tidak akan mungkin di C ++ 0x, menunjukkan berikut Anda bisa mendapatkan cukup dekat:

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>
}

Anda benar, kompiler dapat dengan mudah menebaknya, tetapi itu tidak dalam standar atau C ++ 0x sejauh yang saya tahu sehingga Anda harus menunggu setidaknya 10 tahun lagi (standar ISO fixed turn around rate) sebelum penyedia compiller menambahkan fitur ini

Mari kita lihat masalah dengan mengacu pada kelas yang harus dipahami semua orang dengan - std :: vector.

Pertama, penggunaan vektor yang paling umum adalah menggunakan konstruktor yang tidak menggunakan parameter:

vector <int> v;

Dalam kasus ini, jelas tidak ada kesimpulan yang dapat dilakukan.

Penggunaan umum kedua adalah membuat vektor berukuran sebelumnya:

vector <string> v(100);

Di sini, jika inferensi digunakan:

vector v(100);

kita mendapatkan vektor int, bukan string, dan mungkin ukurannya tidak!

Terakhir, pertimbangkan konstruktor yang mengambil beberapa parameter - dengan "inferensi":

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

Parameter mana yang harus digunakan untuk inferensi? Kita memerlukan beberapa cara untuk memberi tahu kompilator bahwa itu harus yang kedua.

Dengan semua masalah ini untuk kelas yang sederhana seperti vektor, mudah untuk melihat mengapa inferensi tidak digunakan.

Membuat ctor sebagai template Variabel hanya dapat memiliki satu formulir tetapi beragam 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;         
}

Lihat? Kita tidak bisa memiliki beberapa Variable :: data members.

Lihat Pemotongan Argumen C ++ Template untuk info lebih lanjut tentang ini.