Seperti yang saya mengerti, kedua decltype
dan auto
akan mencoba untuk mencari tahu apa jenis sesuatu.
Jika kita mendefinisikan:
int foo () {
return 34;
}
Kemudian kedua deklarasi hukum:
auto x = foo();
cout << x << endl;
decltype(foo()) y = 13;
cout << y << endl;
Bisa anda jelaskan apa perbedaan utama antara decltype
dan auto
?
decltype
memberikan menyatakan jenis ekspresi yang melewati itu. auto
melakukan hal yang sama seperti template jenis pemotongan. Jadi, misalnya, jika anda memiliki sebuah fungsi yang mengembalikan referensi, auto
masih akan menjadi nilai (anda perlu auto&
untuk mendapatkan referensi), tapi decltype
akan persis jenis nilai kembali.
#include <iostream>
int global{};
int& foo()
{
return global;
}
int main()
{
decltype(foo()) a = foo(); //a is an `int&`
auto b = foo(); //b is an `int`
b = 2;
std::cout << "a: " << a << '\n'; //prints "a: 0"
std::cout << "b: " << b << '\n'; //prints "b: 2"
std::cout << "---\n";
decltype(foo()) c = foo(); //c is an `int&`
c = 10;
std::cout << "a: " << a << '\n'; //prints "a: 10"
std::cout << "b: " << b << '\n'; //prints "b: 2"
std::cout << "c: " << c << '\n'; //prints "c: 10"
}
Lihat juga David Rodríguez's jawaban tentang tempat-tempat di mana hanya satu dari auto
atau decltype
yang mungkin.
auto
(dalam konteks di mana ia menyimpulkan jenis) terbatas untuk mendefinisikan tipe dari variabel yang ada initializer. decltype
adalah konstruk yang lebih luas, dengan biaya tambahan informasi, akan menyimpulkan jenis ekspresi.
Dalam kasus-kasus di mana auto
dapat digunakan, hal ini lebih ringkas dari decltype
, seperti yang anda don't perlu untuk memberikan ekspresi yang jenis akan disimpulkan.
auto x = foo(); // more concise than `decltype(foo()) x`
std::vector<decltype(foo())> v{ foo() }; // cannot use `auto`
Kata kunci auto
juga digunakan dalam benar-benar tidak terkait konteks, ketika menggunakan trailing tipe hasil untuk fungsi-fungsi:
auto foo() -> int;
Ada auto
hanya seorang pemimpin agar kompiler tahu bahwa ini adalah sebuah deklarasi dengan trailing tipe kembali. Sedangkan contoh di atas dapat dengan mudah dikonversi ke gaya lama, dalam pemrograman generik hal ini berguna:
template <typename T, typename U>
auto sum( T t, U u ) -> decltype(t+u)
Perhatikan bahwa dalam kasus ini, auto
tidak dapat digunakan untuk menentukan jenis kembali.