Nilalaman

• Tsart ng paghahambing
• Kahulugan ng exit (0)
• Kahulugan ng exit (1)
• Pagkakapareho:
• Tandaan:
• Konklusyon:

Ang exit (0) at exit (1) ay ang mga jump statement ng C ++ na gumagawa ng control jump out ng isang programa habang ang programa ay sa pagpapatupad. Parehong mga function, exit (0) at exit (1), ay ginagamit upang lumabas sa programa, ngunit mayroong isang pangunahing pagkakaiba sa pagitan ng exit (0) at exit (1). Ang exit (0) ay nagpapakita ng matagumpay na pagtatapos ng programa at ang exit (1) ay nagpapakita ng abnormal na pagtatapos ng programa.

Hayaan ang pagkakaiba sa pag-aaral sa pagitan ng exit (0) at exit (1) sa tulong ng tsart ng paghahambing.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Konklusyon

Tsart ng paghahambing

Batayan Para sa Paghahambing	paglabas (0)	paglabas (1)
Pangunahing	Iniuulat ang operating system tungkol sa "matagumpay / normal" pagwawakas / pagkumpleto ng programa.	Iniuulat ang operating system tungkol sa "abnormal" na pagtatapos ng programa.
Syntax	paglabas (0);	exit (1);
Nagpapahiwatig	Ipinapahiwatig nito na ang gawain ay matagumpay na naisagawa.	Ipinapahiwatig nito na ang gawain ay na-abort sa pagitan ng dahil sa pagkakamali.
Macros	EXIT_SUCCESS	EXIT_FAILURE

Kahulugan ng exit (0)

Ang exit exit (0) ay isang jump statement ng C ++. Ginagamit ito upang wakasan ang programa o hayaan ang control na lumabas sa programa. Iniuulat nito ang operating system tungkol sa matagumpay na pagtatapos ng programa na nagpapahiwatig sa operating system na ang gawain ng programa ay matagumpay na nakumpleto. Ang macro na ginamit para sa return code na "0" ay "EXIT_SUCCESS", kaya, maaari mong gamitin ito sa isang exit exit (EXIT_SUCCESS). Ang pangkalahatang anyo ng exit (0) function ay: -

walang bisa exit (int return_code);

Dito, ang pormal na parameter na "return_code" ay ang halaga na ibinalik sa tungkulin sa pagtawag. Ang returen_code ay palaging uri ng integer dahil ang halaga na ibinalik sa tungkulin sa pagtawag ay magiging zero o isang halaga na hindi zero. Ang exit (0) ay isang karaniwang pag-andar ng aklatan, kung gumagamit kami ng exit (0) sa program na kailangan nating gamitin ang header file .
Unawain natin ang exit (0) na may isang halimbawa: -

#nagsama // standard library function int main () {FILE * ptrFile; ptrFile = fopen ("myfile.txt", "r"); // buksan ang file sa mode na basahin lamang kung (ptrFile == NULL) {cout << "Error sa pagbubukas ng file"; exit (1); // halili maaari mong gamitin ang exit (EXIT_FAILURE)} exit (0); // halili maaari mong gamitin ang exit (EXIT_SUCCESS)}

Sa code sa itaas sinusubukan naming buksan ang isang file na nagngangalang "myfile.txt". Nilikha namin ang isang pointer sa file na "myfile.txt". Kung ang file na "myfile.txt" ay umiiral, tuturo ang tumuturo sa address ng file na iyon at lumabas (0) ay isasagawa ang pag-uulat ng operating system na matagumpay na binuksan ang file. Kung sakaling ang file ay hindi naroroon ang pointer sa file na "myfile.txt" ay maglalagay ngayon ng NULL at exit (1) ay gagawa ng pagsasagawa ng pag-uulat ng operating system na ang file ay hindi binuksan dahil sa error o isang bagay.

Kahulugan ng exit (1)

Ang exit exit (1) ay isang jump statement ng C ++. Ang exit (1) ay nagtatapos din sa programa ngunit, abnormally. Ang exit (1) ay nag-uulat sa operating system na ang programa ay hindi matagumpay na naisakatuparan, o ito ay ipinagsama sa pagitan ng pagpapatupad dahil sa ilan o sa iba pang error. Ang exit (1) function ay tinukoy sa karaniwang pag-andar ng aklatan, kung gumagamit ka ng exit (1) sa iyong programa kailangan mong partikular na banggitin ang header file sa tuktok ng programa.
Ang macro para sa return code na "1" ay "EXIT_FAILURE", kaya, maaari itong isulat sa isang paraan na "exit (EXIT_FAILURE)".
Ngayon maunawaan natin ang exit (1) function sa tulong ng programa.

// pop ang elemento sa tuktok ng stack int pop (int stack_name, int size, int Top) {kung (Nangungunang == - 1) {cout << "stack ay underflow"; exit (1); } iba pa {int s = s; Nangungunang--; pagbabalik (s); }}

Dito, ang pag-andar ay tinukoy upang i-pop ang elemento sa tuktok ng salansan, kung ang tuktok ng salansan ay matatagpuan na walang laman i.e. Ang Tuktok ay -1. Pagkatapos ang gawain ng pag-pop out sa tuktok na pinaka elemento sa salansan ay hindi matagumpay na nakumpleto dahil walang laman ang salansan pagkatapos ay bumalik kami sa exit (1). Ipinapahiwatig nito na ang gawain ng pop function ay hindi nakumpleto. Samakatuwid, ang pagpapatupad ay natapos nang abnormally.

1. Ang tanging return_code na nagpapahiwatig ng matagumpay na pagtatapos ng programa ay "0". Para sa pag-uulat ng hindi normal na pagtatapos ng programa, maaari nating gamitin ang anumang halaga maliban sa "0" i.e. maaari nating gamitin ang "1", "2", "3" ... na nangangahulugang ang isang nonzero na halaga ay nagpapahiwatig ng hindi normal na pagtatapos ng programa.
2. Maaari ring magamit ang isang Macro sa halip na return_code. Tulad ng, sa lugar na "0" maaari mong gamitin ang "EXIT_SUCCESS" samantalang sa lugar ng "1" maaari mong gamitin ang "EXIT_FAILURE".

Pagkakapareho:

1. Parehong exit (0) at exit (1), ay ang mga pahayag ng jump + C.
2. Parehong exit (0) at exit (1), ay ginagamit upang wakasan ang programa.
3. Parehong exit (0) at exit (1), ay tinukoy sa header file.
4. Parehong exit (0) at exit (1), iulat ang katayuan ng pagtatapos ng programa sa operating system.

Tandaan:

Kung ang pag-andar (exit) ay hindi magbabalik ng anupaman, nangangahulugang hindi nito nais na ihayag ang katayuan ng pagwawakas ng programa sa operating system.

Konklusyon:

Upang maiulat ang katayuan ng pagwawakas ng programa, gumamit ang isang exit () function. Ang isang exit (0) ay naghayag sa operating system na ang gawain ng programa ay matagumpay na nakumpleto. Ang isang exit (1) ay naghayag na ang gawain ng programa ay hindi nakumpleto, at ang pagpapatupad ng programa ay napakalaki ng abnormally.