Apakah ada kerugian untuk mendeklarasikan variabel dengan otomatis di C ++?

Tampaknya itu autoadalah fitur yang cukup signifikan untuk ditambahkan dalam C ++ 11 yang tampaknya mengikuti banyak bahasa yang lebih baru. Seperti bahasa seperti Python, saya belum melihat adanya deklarasi variabel eksplisit (saya tidak yakin apakah mungkin menggunakan standar Python).

Apakah ada kelemahan menggunakan autountuk mendeklarasikan variabel daripada secara eksplisit mendeklarasikannya?

Anda hanya bertanya tentang kekurangannya, jadi saya menyoroti beberapa di antaranya. Bila digunakan dengan baik, automemiliki beberapa keunggulan juga. Kekurangannya adalah karena mudahnya penyalahgunaan, dan dari meningkatnya potensi kode untuk berperilaku dengan cara yang tidak disengaja.

Kelemahan utama adalah bahwa, dengan menggunakan auto, Anda tidak perlu tahu jenis objek yang dibuat. Ada juga kesempatan di mana programmer mungkin mengharapkan kompiler untuk menyimpulkan satu jenis, tetapi kompiler dengan tegas menyimpulkan yang lain.

Diberikan deklarasi seperti

auto result = CallSomeFunction(x,y,z);

Anda tidak perlu memiliki pengetahuan tentang jenis apa resultitu. Itu mungkin sebuah int. Mungkin sebuah pointer. Mungkin sesuatu yang lain. Semua itu mendukung operasi yang berbeda. Anda juga dapat secara dramatis mengubah kode dengan perubahan kecil seperti

auto result = CallSomeFunction(a,y,z);

karena, tergantung pada kelebihan apa yang ada untuk CallSomeFunction()jenis hasil mungkin sama sekali berbeda - dan karena itu kode selanjutnya mungkin berperilaku sangat berbeda dari yang dimaksudkan. Anda mungkin tiba-tiba memicu pesan kesalahan dalam kode selanjutnya (mis. Kemudian intmencoba untuk mengubah referensi , mencoba mengubah sesuatu yang sekarang const). Perubahan yang lebih menyeramkan adalah saat perubahan Anda melewati kompiler, tetapi kode selanjutnya berperilaku dengan cara yang berbeda dan tidak diketahui - mungkin buggy.

Karena itu, tidak memiliki pengetahuan eksplisit tentang jenis beberapa variabel membuatnya lebih sulit untuk membenarkan klaim bahwa kode berfungsi sebagaimana dimaksud. Ini berarti lebih banyak upaya untuk membenarkan klaim "cocok untuk tujuan" dalam domain kritis tinggi (mis. Keselamatan kritis atau misi kritis).

Kelemahan lainnya, yang lebih umum, adalah godaan bagi seorang programmer untuk digunakan autosebagai instrumen tumpul untuk memaksa kode dikompilasi, daripada memikirkan apa yang dilakukan kode, dan bekerja untuk memperbaikinya.

Ini bukan kelemahan autodengan cara berprinsip persis, tetapi dalam hal praktis tampaknya menjadi masalah bagi sebagian orang. Pada dasarnya, beberapa orang entah: a) memperlakukan autosebagai penyelamat untuk jenis dan mematikan otak mereka saat menggunakannya, atau b) lupa bahwa autoselalu menyimpulkan jenis nilai. Ini menyebabkan orang melakukan hal-hal seperti ini:

auto x = my_obj.method_that_returns_reference();

Ups, kami baru saja menyalin beberapa objek. Seringkali bug atau kinerja gagal. Kemudian, Anda bisa mengayunkan ke arah lain juga:

const auto& stuff = *func_that_returns_unique_ptr();

Sekarang Anda mendapatkan referensi yang menggantung. Masalah-masalah ini tidak disebabkan oleh autosama sekali, jadi saya tidak menganggapnya sebagai argumen yang sah untuk menentangnya. Tapi sepertinya automembuat masalah ini lebih umum (dari pengalaman pribadi saya), untuk alasan yang saya sebutkan di awal.

Saya pikir ketika orang-orang akan menyesuaikan, dan memahami pembagian kerja: automenyimpulkan jenis yang mendasarinya, tetapi Anda masih ingin berpikir tentang referensi-ke-kekakuan dan kekekalan. Tapi itu butuh sedikit waktu.

Jawaban lain menyebutkan kelemahan seperti "Anda tidak benar-benar tahu apa jenis variabelnya." Saya akan mengatakan bahwa ini sebagian besar terkait dengan konvensi penamaan ceroboh dalam kode. Jika antarmuka Anda diberi nama yang jelas, Anda tidak perlu peduli dengan tipe yang tepat. Tentu, auto result = callSomeFunction(a, b);tidak banyak bercerita. Tetapi auto valid = isValid(xmlFile, schema);memberitahu Anda cukup untuk digunakan validtanpa harus peduli apa jenis persisnya. Lagi pula, hanya dengan if (callSomeFunction(a, b)), Anda tidak akan tahu jenisnya juga. Sama dengan objek sementara subekspresi lainnya. Jadi saya tidak menganggap ini sebagai kelemahan nyata auto.

Saya akan mengatakan kelemahan utamanya adalah bahwa kadang-kadang, tipe pengembalian yang tepat bukanlah yang ingin Anda kerjakan. Akibatnya, kadang-kadang jenis pengembalian aktual berbeda dari jenis pengembalian "logis" sebagai detail implementasi / optimisasi. Template ekspresi adalah contoh utama. Katakanlah kita punya ini:

SomeType operator* (const Matrix &lhs, const Vector &rhs);

Secara logis, kita berharap SomeTypedemikian Vector, dan kita pasti ingin memperlakukannya seperti itu dalam kode kita. Namun, ada kemungkinan bahwa untuk tujuan optimasi, perpustakaan aljabar yang kami gunakan mengimplementasikan templat ekspresi, dan tipe pengembalian sebenarnya adalah ini:

MultExpression<Matrix, Vector> operator* (const Matrix &lhs, const Vector &rhs);

Sekarang, masalahnya adalah bahwa MultExpression<Matrix, Vector>kemungkinan besar akan menyimpan const Matrix&dan secara const Vector&internal; ia mengharapkan bahwa itu akan dikonversi ke Vectorsebelum akhir dari ekspresi penuhnya. Jika kita memiliki kode ini, semuanya baik-baik saja:

extern Matrix a, b, c;
extern Vector v;

void compute()
{
  Vector res = a * (b * (c * v));
  // do something with res
}

Namun, jika kami digunakan di autosini, kami bisa mendapat masalah:

void compute()
{
  auto res = a * (b * (c * v));
  // Oops! Now `res` is referring to temporaries (such as (c * v)) which no longer exist
}

Salah satu kelemahan adalah bahwa kadang-kadang Anda tidak dapat mendeklarasikan const_iteratordengan auto. Anda akan mendapatkan iterator biasa (bukan const) dalam contoh kode yang diambil dari pertanyaan ini :

map<string,int> usa;
//...init usa
auto city_it = usa.find("New York");

Itu membuat kode Anda sedikit lebih sulit, atau membosankan, untuk dibaca. Bayangkan sesuatu seperti itu:

auto output = doSomethingWithData(variables);

Sekarang, untuk mengetahui tipe output, Anda harus melacak tanda tangan doSomethingWithDatafungsi.

Seperti pengembang ini , saya benci auto. Atau lebih tepatnya, aku benci bagaimana orang menyalahgunakan auto.

Saya berpendapat (kuat) autountuk membantu Anda menulis kode generik, bukan untuk mengurangi mengetik .
C ++ adalah bahasa yang tujuannya membiarkan Anda menulis kode yang kuat, bukan untuk meminimalkan waktu pengembangan.
Ini cukup jelas dari banyak fitur C ++, tapi sayangnya beberapa yang lebih baru seperti autoitu mengurangi mengetik orang yang menyesatkan sehingga berpikir mereka harus mulai malas mengetik.

Pada automasa pra- hari, orang menggunakan typedefs, yang sangat bagus karena typedef memungkinkan perancang perpustakaan untuk membantu Anda mengetahui apa yang seharusnya menjadi tipe pengembalian, sehingga perpustakaan mereka berfungsi seperti yang diharapkan. Saat Anda menggunakan auto, Anda mengambil kontrol itu dari desainer kelas dan alih-alih meminta kompiler untuk mencari tahu apa yang harus menjadi tipe, yang menghapus salah satu alat C ++ paling kuat dari kotak alat dan berisiko melanggar kode mereka.

Secara umum, jika Anda menggunakan auto, itu harus karena kode Anda berfungsi untuk semua jenis yang masuk akal , bukan karena Anda terlalu malas untuk menuliskan jenis yang harusnya bekerja. Jika Anda menggunakan autosebagai alat untuk membantu kemalasan, maka yang terjadi adalah Anda akhirnya mulai memperkenalkan bug halus di program Anda, biasanya disebabkan oleh konversi tersirat yang tidak terjadi karena Anda menggunakannya auto.

Sayangnya, bug ini sulit untuk diilustrasikan dalam contoh singkat di sini karena singkatnya mereka membuat mereka kurang meyakinkan daripada contoh aktual yang muncul dalam proyek pengguna - namun, mereka muncul dengan mudah dalam kode template-berat yang mengharapkan konversi implisit tertentu untuk mengambil tempat.

Jika Anda ingin contoh, ada satu di sini . Namun, sedikit catatan: sebelum tergoda untuk melompat dan mengkritik kode: perlu diingat bahwa banyak perpustakaan terkenal dan dewasa telah dikembangkan di sekitar konversi implisit, dan mereka ada di sana karena mereka memecahkan masalah yang bisa sulit jika bukan tidak mungkin untuk memecahkan sebaliknya. Cobalah mencari solusi yang lebih baik sebelum mengkritik mereka.

autotidak memiliki kelemahan per se , dan saya menganjurkan untuk (goyah) menggunakannya di mana-mana dalam kode baru. Ini memungkinkan kode Anda untuk secara konsisten mengetik-cek, dan secara konsisten menghindari pemotongan diam. (Jika Bberasal dari Adan fungsi yang kembali Atiba-tiba kembali B, maka autoberperilaku seperti yang diharapkan untuk menyimpan nilai pengembaliannya)

Meskipun, kode lama pre-C ++ 11 dapat mengandalkan konversi implisit yang disebabkan oleh penggunaan variabel yang diketik secara eksplisit. Mengubah variabel yang diketik secara eksplisit untuk autodapat mengubah perilaku kode , jadi sebaiknya Anda berhati-hati.

Kata kunci autocukup menyimpulkan jenis dari nilai pengembalian. Oleh karena itu, ini tidak setara dengan objek Python, mis

# Python
a
a = 10       # OK
a = "10"     # OK
a = ClassA() # OK

// C++
auto a;      // Unable to deduce variable a
auto a = 10; // OK
a = "10";    // Value of const char* can't be assigned to int
a = ClassA{} // Value of ClassA can't be assigned to int
a = 10.0;    // OK, implicit casting warning

Karena autodideduksi selama kompilasi, itu tidak akan memiliki kekurangan saat runtime sama sekali.

Apa yang tidak disebutkan di sini sejauh ini, tetapi untuk dirinya sendiri bernilai jawaban jika Anda bertanya kepada saya.

Karena (walaupun semua orang harus sadar bahwa C != C++) kode yang ditulis dalam C dapat dengan mudah dirancang untuk menyediakan basis untuk kode C ++ dan karenanya dirancang tanpa terlalu banyak upaya untuk menjadi kompatibel dengan C ++, ini bisa menjadi persyaratan untuk desain.

Saya tahu tentang beberapa aturan di mana beberapa konstruksi yang didefinisikan dengan baik Ctidak valid untuk C++dan sebaliknya. Tapi ini hanya akan menghasilkan executable yang rusak dan klausa UB yang berlaku berlaku yang paling sering diperhatikan oleh perulangan aneh yang mengakibatkan crash atau apa pun (atau bahkan mungkin tetap tidak terdeteksi, tetapi itu tidak masalah di sini).

Tapi autoapakah pertama kali ¹ ini berubah!

Bayangkan Anda digunakan autosebagai specifier kelas penyimpanan sebelum dan mentransfer kode. Bahkan tidak perlu (tergantung pada cara itu digunakan) "istirahat"; itu sebenarnya bisa mengubah perilaku program secara diam-diam.

Itu sesuatu yang harus diingat.

¹ _{Setidaknya pertama kali aku sadar.}

Salah satu alasan yang dapat saya pikirkan adalah bahwa Anda kehilangan kesempatan untuk memaksa kelas yang dikembalikan. Jika fungsi atau metode Anda mengembalikan panjang 64 bit, dan Anda hanya menginginkan 32 unsigned int, maka Anda kehilangan kesempatan untuk mengontrolnya.

Seperti yang saya jelaskan dalam jawaban auto ini kadang-kadang dapat menghasilkan situasi funky yang tidak Anda inginkan. Anda harus secara eksplisit mengatakan auto&memiliki tipe referensi saat melakukan saja autodapat membuat tipe pointer. Ini dapat menyebabkan kebingungan dengan menghilangkan specifier secara bersamaan, menghasilkan salinan referensi alih-alih referensi yang sebenarnya.

Contoh menjengkelkan lainnya:

for (auto i = 0; i < s.size(); ++i)

menghasilkan peringatan ( comparison between signed and unsigned integer expressions [-Wsign-compare]), karena iint yang ditandatangani. Untuk menghindari ini, Anda perlu menulis misalnya

for (auto i = 0U; i < s.size(); ++i)

atau mungkin lebih baik:

for (auto i = 0ULL; i < s.size(); ++i)

Saya pikir autobagus ketika digunakan dalam konteks lokal, di mana pembaca dengan mudah & jelas dapat mengurangi jenisnya, atau didokumentasikan dengan baik dengan komentar dari jenisnya atau nama yang menyimpulkan jenis yang sebenarnya. Mereka yang tidak mengerti cara kerjanya mungkin mengambilnya dengan cara yang salah, seperti menggunakannya sebagai gantinya templateatau serupa. Berikut adalah beberapa kasus penggunaan yang baik dan buruk menurut saya.

void test (const int & a)
{
    // b is not const
    // b is not a reference

    auto b = a;

    // b type is decided by the compiler based on value of a
    // a is int
}

Penggunaan yang baik

Iterator

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int> v();

..

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int>::iterator it = v.begin();

// VS

auto vi = v.begin();

Pointer fungsi

int test (ClassWithLongName1 a, ClassWithLongName2 b, int c)
{
    ..
}

..

int (*fp)(ClassWithLongName1, ClassWithLongName2, int) = test;

// VS

auto *f = test;

Penggunaan yang buruk

Aliran data

auto input = "";

..

auto output = test(input);

Fungsi Tanda Tangan

auto test (auto a, auto b, auto c)
{
    ..
}

Kasus-kasus sepele

for(auto i = 0; i < 100; i++)
{
    ..
}

Saya terkejut tidak ada yang menyebutkan ini, tetapi anggap Anda menghitung faktorial dari sesuatu:

#include <iostream>
using namespace std;

int main() {
    auto n = 40;
    auto factorial = 1;

    for(int i = 1; i <=n; ++i)
    {
        factorial *= i;
    }

    cout << "Factorial of " << n << " = " << factorial <<endl;   
    cout << "Size of factorial: " << sizeof(factorial) << endl; 
    return 0;
}

Kode ini akan menampilkan ini:

Factorial of 40 = 0
Size of factorial: 4

Itu jelas bukan hasil yang diharapkan. Itu terjadi karena automenyimpulkan jenis faktorial variabel intkarena ditugaskan 1.