pernyataan return vs exit () di main ()

Haruskah saya menggunakan exit()atau hanya returnpernyataan dalam main()? Secara pribadi saya menyukai returnpernyataan karena saya merasa itu seperti membaca fungsi lain dan kontrol aliran ketika saya membaca kode halus (menurut saya). Dan bahkan jika saya ingin memperbaiki main()fungsi, memiliki pilihan yang returnsepertinya lebih baik daripada exit().

Apakah exit()melakukan sesuatu yang istimewa yang returntidak?

Sebenarnya, ada adalah perbedaan, tapi itu halus. Ini memiliki lebih banyak implikasi untuk C ++, tetapi perbedaannya penting.

Ketika saya sebut returndi main(), destructors akan dipanggil untuk objek saya scoped lokal. Jika saya panggil exit(), tidak ada destruktor yang akan dipanggil untuk objek yang dicakup secara lokal! Baca kembali itu. exit() tidak kembali . Itu berarti bahwa begitu saya menyebutnya, tidak ada "backsies." Objek apa pun yang Anda buat dalam fungsi itu tidak akan dihancurkan. Seringkali ini tidak memiliki implikasi, tetapi kadang-kadang tidak, seperti menutup file (pasti Anda ingin semua data Anda di-flush ke disk?).

Perhatikan bahwa staticobjek akan dibersihkan bahkan jika Anda menelepon exit(). Akhirnya perhatikan, bahwa jika Anda menggunakan abort(), tidak ada objek yang akan dihancurkan. Artinya, tidak ada objek global, tidak ada objek statis dan tidak ada objek lokal yang akan memanggil destruktornya.

Lanjutkan dengan hati-hati saat memilih jalan keluar daripada pulang.

http://groups.google.com/group/gnu.gcc.help/msg/8348c50030cfd15a

Perbedaan lainnya: exitadalah fungsi Perpustakaan Standar sehingga Anda harus menyertakan header dan tautan dengan perpustakaan standar. Untuk menggambarkan (dalam C ++), ini adalah program yang valid:

int main() { return 0; }

tetapi untuk menggunakan exitAnda harus menyertakan:

#include <stdlib.h>
int main() { exit(EXIT_SUCCESS); }

Plus ini menambahkan asumsi tambahan: bahwa panggilan exitdari mainmemiliki efek samping yang sama dengan mengembalikan nol. Seperti yang telah ditunjukkan orang lain, ini tergantung pada jenis executable yang Anda bangun (yaitu, siapa yang menelepon main). Apakah Anda mengkode aplikasi yang menggunakan runtime C? Plugin Maya? Layanan Windows? Supir? Setiap kasus akan membutuhkan penelitian untuk melihat apakah exitsetara dengan return. Menggunakan IMHO exitketika Anda benar-benar berarti return hanya membuat kode lebih membingungkan. OTOH, jika Anda benar-benar jahat exit , maka gunakanlah itu.

Setidaknya ada satu alasan untuk memilih exit: Jika salah satu atexitpenangan Anda merujuk ke data durasi penyimpanan otomatis main, atau jika Anda menggunakan setvbufatau setbufuntuk menetapkan salah satu aliran standar, buffer durasi penyimpanan otomatis masuk main, lalu kembali dari mainmenghasilkan perilaku tidak terdefinisi, tetapi panggilan exitvalid.

Namun potensi penggunaan lain (biasanya dicadangkan untuk program mainan) adalah untuk keluar dari program dengan doa rekursif main.

Saya selalu menggunakan returnkarena prototipe standar untuk main()mengatakan bahwa ia mengembalikan sebuah int.

Yang mengatakan, beberapa versi standar memberikan mainperlakuan khusus dan menganggap bahwa itu mengembalikan 0 jika tidak ada returnpernyataan eksplisit . Diberikan kode berikut:

int foo() {}
int main(int argc, char *argv[]) {}

G ++ hanya menghasilkan peringatan untuk foo()dan mengabaikan pengembalian yang hilang dari main:

% g++ -Wall -c foo.cc
foo.cc: In function ‘int foo()’:
foo.cc:1: warning: control reaches end of non-void function

SAYA SANGAT memberikan komentar kedua oleh R. tentang penggunaan exit () untuk menghindari penyimpanan otomatis di main()reklamasi sebelum program benar-benar berakhir. Sebuah return X;pernyataan di main()tidak tepat setara dengan panggilan untuk exit(X);, karena penyimpanan dinamis main()hilang ketika main()kembali, tapi itu tidak lenyap jika panggilan untuk exit()dibuat sebagai gantinya.

Selain itu, dalam bahasa C atau bahasa C-seperti returnpernyataan sangat mengisyaratkan kepada pembaca bahwa eksekusi akan melanjutkan dalam fungsi panggilan, dan sementara kelanjutan eksekusi ini biasanya benar secara teknis jika Anda menghitung rutin startup C yang disebut main()fungsi Anda , itu tidak persis apa yang Anda maksud ketika Anda bermaksud mengakhiri proses.

Lagi pula, jika Anda ingin mengakhiri program Anda dari dalam fungsi lain kecuali main()Anda harus memanggil exit(). Melakukannya secara konsisten main()juga membuat kode Anda jauh lebih mudah dibaca, dan juga membuatnya lebih mudah bagi siapa pun untuk memasukkan faktor ulang kode Anda; kode yaitu disalin dari main()ke beberapa fungsi lain tidak akan berperilaku tidak benar karena returnpernyataan tidak disengaja yang seharusnya menjadi exit()panggilan.

Jadi, menggabungkan semua poin ini bersama kesimpulannya adalah bahwa itu kebiasaan buruk , setidaknya bagi C, untuk menggunakan returnpernyataan untuk mengakhiri program main().

Apakah exit () melakukan sesuatu yang istimewa yang 'kembali' tidak?

Dengan beberapa kompiler untuk platform yang tidak umum, exit()mungkin menerjemahkan argumennya ke nilai keluar program Anda sementara pengembalian dari main()mungkin hanya meneruskan nilai langsung ke lingkungan host tanpa terjemahan apa pun.

Standar ini memerlukan perilaku yang identik dalam kasus ini (khususnya, ia mengatakan mengembalikan sesuatu yang int-compatible dari main()harus setara dengan memanggil exit()dengan nilai itu). Masalahnya adalah bahwa OS yang berbeda memiliki konvensi yang berbeda untuk menafsirkan nilai keluar. Pada banyak sistem (BANYAK!), 0 berarti sukses dan yang lainnya gagal. Tetapi pada, katakanlah, VMS, nilai ganjil berarti kesuksesan dan bahkan yang berarti kegagalan. Jika Anda kembali 0 dari main(), pengguna VMS akan melihat pesan buruk tentang pelanggaran akses. Sebenarnya tidak ada pelanggaran akses - itu hanya pesan standar yang terkait dengan kode kegagalan 0.

Kemudian ANSI datang dan memberkati EXIT_SUCCESSdan EXIT_FAILUREsebagai argumen Anda bisa lolos exit(). Standar ini juga mengatakan bahwa exit(0)harus bersikap identik dengan exit(EXIT_SUCCESS), sehingga sebagian besar implementasi mendefinisikan EXIT_SUCCESSuntuk 0.

Standar, oleh karena itu, membuat Anda terikat pada VMS, karena tidak meninggalkan cara standar untuk mengembalikan kode kegagalan yang kebetulan memiliki nilai 0.

Oleh karena itu, kompiler VAX / VMS C awal 1990-an tidak menafsirkan nilai balik dari main() , ia hanya mengembalikan nilai apa pun ke lingkungan host. Tetapi jika Anda menggunakannya exit()akan melakukan apa yang diperlukan standar: menerjemahkan EXIT_SUCCESS(atau 0) menjadi kode sukses dan EXIT_FAILUREmenjadi kode kegagalan umum. Untuk menggunakannya EXIT_SUCCESS, Anda harus meneruskannya exit(), Anda tidak dapat mengembalikannya main(). Saya tidak tahu apakah versi yang lebih modern dari kompiler itu mempertahankan perilaku itu.

Program C portabel digunakan untuk terlihat seperti ini:

#include <stdio.h>
#include <stdlib.h>

int main() {
  printf("Hello, World!\n");
  exit(EXIT_SUCCESS);  /* to get good return value to OS */
  /*NOTREACHED*/ /* to silence lint warning */
  return 0;  /* to silence compiler warning */
}

Selain itu: Jika saya mengingat dengan benar, konvensi VMS untuk nilai keluar lebih bernuansa daripada ganjil / genap. Ini sebenarnya menggunakan sesuatu seperti tiga bit rendah untuk mengkodekan tingkat keparahan. Secara umum, tingkat keparahan ganjil mengindikasikan keberhasilan atau informasi lain-lain dan bahkan genap mengindikasikan kesalahan.

Di C kembali dari mainpersis sama dengan meneleponexit dengan nilai yang sama.

Bagian 5.1.2.2.3 dari status standar C :

Jika tipe pengembalian fungsi utama adalah tipe yang kompatibel dengan int, pengembalian dari panggilan awal ke fungsi utama sama dengan memanggil fungsi keluar dengan nilai yang dikembalikan oleh fungsi utama sebagai argumennya ; 11) mencapai} yang menghentikan fungsi utama mengembalikan nilai 0. Jika tipe kembali tidak kompatibel dengan int, status terminasi yang dikembalikan ke lingkungan host tidak ditentukan.

Aturan untuk C ++ sedikit berbeda seperti yang disebutkan dalam jawaban lain.

Sebenarnya ADA perbedaan antara exit(0)dan return(0)di main- ketika mainfungsi Anda dipanggil beberapa kali.

Program berikut

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  if (argc == 0)
    return(0);
  printf("%d", main(argc - 1, argv));
}

Jalankan sebagai

./program 0 0 0 0

Akan menghasilkan output sebagai berikut:

00000

Namun yang ini:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  if (argc == 0)
    exit(0);
  printf("%d", main(argc - 1, argv));
}

Tidak akan mencetak apa pun terlepas dari argumen.

Jika Anda yakin tidak akan ada yang memanggil Anda mainsecara eksplisit, secara teknis tidak ada perbedaan besar, tetapi untuk mempertahankan kode yang lebih jelas exitakan terlihat jauh lebih baik. Jika Anda karena alasan tertentu ingin menelepon main- Anda harus menyesuaikannya dengan kebutuhan Anda.

Berbicara tentang C.