Sa computing, ang console ay ang computer keyboard at ang computer monitor. Noong nakaraan, ang output ay direktang ipinadala sa monitor screen at hindi sa isang window na ipinakita sa monitor. Para sa ordinaryong gumagamit ng computer, ang mga application ngayon ay hindi gumagamit ng monitor nang malinaw. Ang mga application na ito ay gumagamit ng mga bintana na ipinapakita sa monitor. Gayunpaman, kailangan pa ring gamitin ng programmer ng computer ang monitor screen. Bagaman kailangan pa ring gamitin ng programmer ang monitor screen, hindi siya pinapayagan ng operating system na gawin iyon. Nagbibigay ang operating system ng isang window na kunwa ang screen ng monitor. Sa Windows Operating System, ang window na ito ay tinatawag na Command Prompt. Sa Linux Operating System at mga variant nito, ang window na ito ay tinatawag na terminal.
Inaasahan na alam na ng mambabasa kung paano gamitin ang Command Prompt o ang Terminal. Ipinapaliwanag ng artikulong ito kung paano basahin ang mga character at string mula sa keyboard at magpadala ng mga character at string sa terminal (o prompt ng command). Ang bawat C ++ programmer ay kailangang malaman sa artikulong ito.
Upang magkaroon ng input mula sa keyboard at output sa terminal, ang programa ay dapat magsimula sa:
# isama
gamit namespaceoras;
Nilalaman ng Artikulo
- Pakitid na Mga Bagay ng Stream ng Karaniwang iostream
- Pagkuha ng Mga Character at Strings mula sa Keyboard
- Pagpapakita at Pagtanggal ng Mga Character bago pindutin ang Enter
- Pagpapadala ng Mga Character at Strings sa Monitor
- Mga argumento para sa isang C ++ Program
- Konklusyon
Pakitid na Mga Bagay ng Stream ng Karaniwang iostream
Ang klase ng iostream, ang mga karaniwang bagay, cout, cin, cerr, at clog, ay na-instayate at nasa standard na library na. Ginagamit lamang ng programmer ang mga ito nang hindi muling binubuong muli.
gastos
Ang sumusunod na pahayag sa pangunahing () pagpapaandar ay nagpapadala ng teksto, Ito ang output. sa terminal:
gastos << 'Ito ang output.';
Ang cout ay isang output na iostream object sa karaniwang silid-aklatan, na naitaguyod na.<< is the insertion operator, which sent the bytes, This is output. to the output stream object, cout. When the statement is executed, the text appears on the screen.
Sa pahayag sa itaas, ang muling ipinakita na prompt ng utos ay lilitaw sa kanan ng parirala ng output. Hindi ito pupunta sa susunod na linya. endl sa dulo ng sumusunod na pahayag ay pipilitin ang anumang na-print ng screen sa susunod na linya:
gastos << 'Ito ang output.' <<endl;
ang endl ay isang paunang natukoy na variable. Maaari ring mapilit ang nilalaman ng screen sa susunod na linya na may:
gastos << 'Ito ang output.' << ' n';Gamit ang paggamit ng ‘ n’, ang lahat ng mga linya ng teksto ay maaaring hindi pa rin lumitaw agad sa screen. pinalabas ng endl ang kumpletong linya ng teksto sa screen.
Tandaan: ang isang string na ipinadala sa cout ay nasa dobleng quote, habang ang isang character na ipinadala ay nasa iisang mga quote. Ang isang serye ng mga string at chars ay maaaring maipadala sa isang pahayag, na nauna ang bawat isa<< . All that will appear in one line at the output if ‘ ’ is not in the series.
gin
ang cin ay ang karaniwang iostream input object, na instantiated na, at magagamit sa karaniwang library. Isaalang-alang ang sumusunod na segment ng code sa pangunahing () pagpapaandar:
chartxt[limampu];gastos << 'Magpasok ng isang salita at pindutin ang Enter:' txt;
gastos <<txt<<endl;
Ang unang pahayag ay nagdeklara ng isang walang laman na hanay ng 50 mga character. Inuutusan ng pangalawang pahayag ang gumagamit na mag-type ng isang salita sa susunod na linya ng screen at pindutin ang Enter key. Tandaan ang paggamit ng 'endl' na pinipilit ang gumagamit na maglagay ng teksto sa susunod na linya ng screen. Tulad ng pag-type ng teksto ng gumagamit, ang ipinasok na teksto ay na-echo sa screen habang papunta ito sa cin object. Pagkatapos ng pagpindot sa Enter, ang pangatlong pahayag sa segment ng code ay naisakatuparan. Ang pangatlong pahayag na ito ay nagpapadala ng ipinasok na teksto sa variable, txt. Ang ipinasok na teksto ay hindi dapat mas mahaba sa 50 mga character sa kasong ito. Tandaan ang paggamit ng operator ng pagkuha, >>. Ipinapakita ng huling pahayag ang ipinasok na teksto sa screen.
cin ay maaaring tumagal ng higit sa isang salita mula sa keyboard, pinaghiwalay ng mga puwang. Ang mga salitang ito ay kailangang i-extract sa iba't ibang mga variable. Ang sumusunod na segment ng code ay naglalarawan nito:
chartxt[dalawampu];intito;
lumutangft;
gastos << 'Ipasok ang 3 halaga at pindutin ang Enter:' txt>>ito>>ft;
gastos <<txt<< ' <<ito<< ' <<ft<<endl;
Tandaan ang pahayag:
gin >>txt>>ito>>ft;Ang unang salita ay nakuha sa txt, ang susunod dito, at ang huli sa ft. Kung ang input ay,
isa25 3.6pagkatapos ang output sa pamamagitan ng segment ng code ay,
isa25 3.6cerr
Ang sumusunod na programa ay may isang error:
# isamagamit namespaceoras;
intpangunahing()
{
sa akingInt;
bumalik ka 0;
}
Ang unang pahayag sa pangunahing () ay hindi tama. Kung ang pangalan ng file na may code ay temp.cc at ang nagresultang naisasagawa na file ay tatawaging temp, kung gayon ang sumusunod na utos na g ++ ay magpapadala ng mensahe ng error sa tagatala sa file, error.txt:
g++ -o temp temp.DC 2>kamaliantxtKung ang file error.txt ay wala, malilikha ito. Tandaan ang bahagi 2> error.txt ng utos na g ++.
Ang screen ay ang karaniwang patutunguhan sa output, at ito rin ang karaniwang patutunguhan ng error. Kung ang 2> error.txt ay tinanggal mula sa utos na g ++, ang mensahe ng error ng tagatala ay ipapadala sa karaniwang patutunguhan ng error, na ang screen pa rin (monitor).
Ang stream na bagay na kumakatawan sa karaniwang patutunguhan sa output ay cout. Ang stream na bagay na kumakatawan sa karaniwang patutunguhan ng error ay cerr. Ang isang error sa runtime ng programa ay maaaring maipadala sa screen tulad ng sumusunod:
cerr << 'Ang mensahe ng error!' << ' n';bakya
Ang isang application ay tumatagal ng iba't ibang mga input sa iba't ibang oras. Ang lahat ng mga input ay maaaring ipakita muli sa screen. Ang lahat ng mga input ay maaaring mai-save sa isang file. Ito ay pag-log. Ang karaniwang patutunguhan sa pag-log ay ang screen. Ang karaniwang object ng stream ng pag-log ay isang clog. Ipapakita muli ng sumusunod na code ang input na teksto sa screen:
chartxt[limampu];gastos<<'Ipasok ang teksto at pindutin ang Enter:'txt;
bakya<<txt<<endl;
Kung ang input text ay 'input_text', kung gayon ang clog ay muling ipapakita ang 'input_text' sa screen.
Sa pagsasagawa, ang pag-log ay karaniwang nai-redirect sa isang file. Inilalarawan ito ng sumusunod na programa:
# isamagamit namespaceoras;
intpangunahing()
{
freopen( 'log.txt','sa',stdout);
gastos << 'pagpapasok ng teksto' <<endl;
}
Tandaan ang paggamit ng pagpapaandar, freopen (), at mga argumento nito. Ang unang argumento nito ay ang pangalan ng file ng log. Kung wala ang file, malilikha ito. Ang pangalawang argumento ay 'w' para sa 'sumulat'. Ang pangatlong argumento nito ay stdout para sa standard-output. Ang pangalawang pahayag sa pangunahing () pagpapaandar ay gumagamit ng cout upang maipadala ang teksto ng pag-log sa file. Tandaan: Ang aktwal na input code ay hindi ipinakita sa program na ito.
Pagkuha ng Mga Character at Strings mula sa Keyboard
Habang ang gumagamit ay nagta-type ng input, ang mga character ay ipinapadala sa buffer ng input stream at ipinapakita sa screen. Kapag pinindot ng gumagamit ang Enter key, lahat ng mga character ay nasa buffer; Gayundin, ang cursor ay papunta sa simula ng susunod na linya sa ibaba, sa screen. Pagkatapos ay nagpapatuloy ang programa sa susunod na pahayag ng programa, pagkatapos ng pahayag sa input ng pagbabasa.
Ang cin object ay may mga pamamaraan, kung saan nababahala ang seksyong ito.
Pagbasa ng Unang Katangian
kumuha (char_type at c):
Ipinapakita ng sumusunod na code segment kung paano basahin ang unang character, mula sa buffer ng input stream:
gastos << 'Pagpapasok ng teksto:' <<endl;
gin.kumuha ka(ch);
gastos <<ch<<endl;
Ang unang pahayag ay nagdeklara ng isang character na walang takdang-aralin. Sinasabi ng pangalawang pahayag sa gumagamit na maglagay ng character. Kapag nag-type ang character ng character ng tao at pinindot ang Enter key, kinokopya ng pangatlong pahayag ang character mula sa input stream buffer patungo sa variable, ch.
Kahit na nag-type ang gumagamit ng higit sa isang character, ang unang character ay kukuha ng segment ng code.
kumuha ():
kumuha () nang walang pagtatalo, ibabalik ang decimal ASCII code. Isaalang-alang ang sumusunod na segment ng code:
gastos << gin.kumuha ka() <<endl;
Kung ang input ay 'asdfg', pagkatapos ay ibabalik ang 97, na kung saan ay ang decimal ASCII code para sa 'a'.
kumuha (char_type * s, streamize n)
Matapos ang gumagamit ay mag-input ng isang parirala at pinindot ang Enter key, ang isang bilang ng mga character na nagsisimula mula sa una, ay maaaring makuha mula sa cin stream buffer. Maaaring gamitin ang sumusunod na code:
charp[10];gastos << 'Pagpapasok ng teksto:' <<endl;
gin.kumuha ka(str,10);
gastos <<p<<endl;
Kung ang input ay 'mahusay na mga tao,' pagkatapos ang output ay magiging 'mahusay na mga tao', ng 9 na mga character at hindi 10. Ang string na character na NUL ( 0) ay tumatagal ng ikasampung posisyon sa get argument. Kaya, upang magkaroon ng 9 na character sa str, ang laki ng imbakan nito ay dapat na hindi bababa sa 10, at ang get () argument ay dapat na 11. Kung nais ang buong linya ng pag-input, kung gayon ang numero ng imbakan ng string ay dapat na hindi bababa sa bilang ng mga character na na-type, kasama ang 1. Kaya, kung ang 12 character ay na-type para sa buong linya, pagkatapos ang numero ay dapat na 13 para sa laki ng string (str) na imbakan at 13 para sa get () argument. Tandaan na ang isang puwang ay binibilang bilang isang character.
kumuha (char_type * s, streamize n, char_type delim)
Posibleng kumuha ng isang sub-string, na na-limit sa kanan, sa pamamagitan ng unang paglitaw ng isang partikular na karakter, o ng streamize ng sub-string, na kung saan ay mauna. Kung ang input na teksto sa sumusunod na code ay mahusay na mga tao, makukuha ang mahusay:
gastos << 'Pagpapasok ng teksto:' <<endl;
gin.kumuha ka(str,6,'o');
gastos <<p<<endl;
Ang pang-anim na posisyon mula sa simula ay ang karakter ng espasyo, at tinatanggal nito ang eksklusibong nakuha na substring. Una ang pang-anim na posisyon bago ang nag-iisang tauhan, 'o'. Tandaan na ang laki ng imbakan para sa str ay maaaring maging kasing taas hangga't maaari.
Kung ang input na teksto sa sumusunod na code ay mahusay na tao, pagkatapos ang gr ay makukuha:
charp[30];gastos << 'Pagpapasok ng teksto:' <<endl;
gin.kumuha ka(str,10,'At');
gastos <<p<<endl;
Ang unang paglitaw ng 'e', ay nauna bago ang ikasampung posisyon.
Pagkuha ng lahat ng mga Character ng isang Linya
Matapos pindutin ang Enter key, lahat ng mga character na na-type sa linya, ay maaaring makuha tulad ng ipinakita sa sumusunod na code:
gastos << 'Pagpapasok ng teksto:' <<endl;habang (1) {
charch= (char)gin.kumuha ka();
gastos <<ch;
kung (ch== ' n')
pahinga;
}
Ang paghahagis na may (char), binabago ang bawat decimal number sa naaangkop na ASCII character.
silip()
Ang get () mga pagpapaandar ng miyembro ay hindi lamang binabasa ang susunod na character; inaalis nila ito sa stream buffer. Gayunpaman, ang pag-andar ng miyembro () na simpleng pag-andar ng miyembro ay binabasa ang susunod na character (simula sa una) nang hindi inaalis ito mula sa buffer. Sa sumusunod na code, ang bawat character ay unang binasa gamit ang silip () na pag-andar bago alisin, sa pamamagitan ng pag-andar ng get (). Lahat ng iyon ay nangyayari pagkatapos pindutin ng gumagamit ang Enter key:
gastos << 'Pagpapasok ng teksto:' <<endl;habang (1) {
charch= (char)gin.silip();
gastos <<ch;
gin.kumuha ka();
kung (ch== ' n')
pahinga;
}
Kung ang mga susunod na character ay hindi tinanggal sa pamamagitan ng get (), silip () ay babasahin lamang ang unang character, at ang loop ay umuulit nang walang katiyakan.
Pagpapakita at Pagtanggal ng Mga Character bago pindutin ang Enter
Pansinin na sa cin object, ang Enter key ay dapat na pipi bago magkaroon ng pagkilos. Kaya, posible na maipakita ang mga character habang nai-type at binubura bago pindutin ang Enter key. Gayunpaman, nangangahulugan iyon ng pakikialam sa operating system. Ang mga operating system ay magkakaiba. Kaya't nangangahulugan ito ng iba't ibang pag-coding para sa iba't ibang mga operating system. Kaya't ang paksang ito ay nararapat sa isang buong iba't ibang mga tutorial - tingnan sa paglaon.
Pagpapadala ng Mga Character at Strings sa Monitor
Ang cout object ay isang output stream object, na instantiated at mayroon na sa standard na library ng C ++. ang cout ang pangunahing bagay na ginamit sa pagpapadala ng mga character at string sa monitor. Ginagawa ito sa operator ng pagpapasok,<< . With the cin object, the text is obtained line-by-line. With the cout object, the text is added onto the same line until ‘ ’ or endl is encountered.
Ang mga ekspresyon na nagreresulta sa mga scalar ay maaaring mga argumento para sa operator ng pagpapasok. Gina-convert ng operator ang scalar sa teksto at inilalagay ang teksto sa stream ng cout object. Kapag ipinadala ang teksto sa cout object, normal itong lilitaw sa screen (monitor). Gayunpaman, paminsan-minsan, maaaring hindi ito lumitaw kaagad. Upang sapilitang teksto sa screen, ipasok ang espesyal na halaga, endl, pagkatapos lamang na ipasok ang teksto. Magiging sanhi ito upang mai-flush sa teksto ang teksto, at idaragdag ang isang bagong linya. Tandaan: Ang ' n' ay nagdaragdag lamang ng isang bagong linya ngunit hindi nag-flush ng teksto sa screen.
Ipinapakita ng sumusunod na programa kung paano i-print ang mga halaga ng int, float, at ordinaryong teksto, papunta sa screen:
# isamagamit namespaceoras;
intpangunahing()
{
intito= 5;
lumutangft= 63.5;
gastos << 'Ang' <<ito<< 'mga item ay nagkakahalaga ng $' <<ft<< 'US.' <<endl;
bumalik ka 0;
}
Ang output ay:
Ang5ang mga item ay nagkakahalaga ng $63.5US.Ipinapakita ng sumusunod na programa kung paano naka-print ang string ng isang bagay mula sa isang klase:
# isamagamit namespaceoras;
istrukturaSt.{
charp[labing-isang] = 'ilang mga salita';
}obj;
intpangunahing()
{
gastos <<objp << ' n';
bumalik ka 0;
}
Ang output ay 'ilang mga salita'.
Mga argumento para sa isang C ++ Program
Nagsisimula ang pagpapatupad ng programa mula sa pangunahing () pagpapaandar. Ang pangunahing () pagpapaandar aktwal na mayroong dalawang mga opsyonal na parameter. Ang syntax ng pangunahing () pagpapaandar na may mga opsyonal na parameter, ay:
intpangunahing(intargc,char *argv[argc]){
bumalik ka 0;
}
Ipagpalagay na ang pangalan ng maipapatupad na C ++ file ay temp. Ipagpalagay na ang mga argumento na kailangan ng programa mula sa kapaligiran nito (operating system), na nai-type ng gumagamit, ay,
mga artikulo3panulat ng libro'malaking bahay'Mayroong 5 mga argumento dito: mga artikulo, 3, libro, panulat, at malaking bahay
Ang bawat isa ay teksto. Ang isang may bilang na argument sa isang programa ay teksto. Sa madaling salita, ang bawat argument ay isang string. malaking bahay ay nasa quote dahil ito ay isang parirala. Ang utos ng terminal na patakbuhin ang program na ito ay:
./temp artikulo3panulat ng libro'malaking bahay'Ipagpalagay na ang file temp ay nasa direktoryo ng bahay. Tandaan na ang mga puwang at hindi mga kuwit ay naghihiwalay sa mga argumento.
Ngayon, sa pangunahing () function syntax, ang argc ay ang bilang ng mga argumento para sa programa, kasama ang 1. Sa kasong ito, mayroong 5 mga argumento para sa programa. Kaya, ang argc ay 6. Sa syntax, ang argv [argc] ay isang hanay ng mga pahiwatig sa mga string. Ang unang halaga para sa array na ito sa argv [0] ay ibinibigay ng tagatala. Ito ay isang pointer sa pangalan ng file ng programa. Ang natitirang halaga ay tumuturo sa mga argumento ng programa sa naka-type na order ng gumagamit. Ang laki ng array na ito ay argc. Sa kasong ito ang laki ay 1 + 5 = 6.
Ipagpalagay na sa pagtitipon, ang sumusunod na programa ay pinangalanang temp:
# isamagamit namespaceoras;
intpangunahing(intargc,char**argv)
{
gastos <<argv[0] << ',' <<argv[1] << ',' <<argv[2] << ',' <<argv[3] << ',' <<argv[4] << ',' <<argv[5] <<endl;
bumalik ka 0;
}
Tandaan dito, na ang array na 'char * argv [argc]', ay idineklarang 'char ** argv'.
Kung ang program na ito ay pinatakbo kasama ang utos ng terminal,
./temp artikulo3panulat ng libro'malaking bahay'pagkatapos ang magiging output ay:
./temp, mga artikulo,3, libro, bolpen, malaking bahayTandaan na ang path ng direktoryo ay kasama ng pangalan ng maipapatupad na file.
Gayundin, tandaan na sa pagpapatakbo ng programa (pagtawag ng programa), ang halaga para sa argc ay hindi naipadala.
Konklusyon
Ang klase ng iostream ay may apat na mahahalagang bagay na cout, cin, cerr, at clog. ang cin ay isang input object, habang ang natitira ay mga output object. Habang tumatakbo ang isang programa, ang pag-input sa programa ay naiiba mula sa kung kailan magsisimulang tumakbo ang programa. Kapag nagsimulang tumakbo ang isang programa, ang input sa programa ay sumali sa utos na patakbuhin ang programa, na pinaghiwalay ng mga puwang.