Կարդացեքև ReadLnկարդալ տեղեկատվությունը ստանդարտ մուտքային սարքից: Վահանակի հավելվածներում այս սարքը կարող է լինել, օրինակ, ստեղնաշար (ավելի ճիշտ՝ ստեղնաշարից մուտքագրված տվյալներ), գրաֆիկական հավելվածներում՝ ֆայլ սկավառակի վրա։

Այսինքն՝ այս պրոցեդուրաները «անտիպոդներ» են՝ նրանք հակառակ գործողություններ են կատարում։

Read և ReadLn ընթացակարգերը կատարում են նմանատիպ գործողություններ: Նրանց հիմնական տարբերությունը հետևյալն է՝ ReadLn պրոցեդուրան մուտքագրումն ավարտելուց հետո կատարում է տողերի հոսք (իսկ ֆայլերի դեպքում ֆայլը տող առ տող է կարդում)։ Իսկ Read պրոցեդուրան անընդմեջ կարդում է տվյալները՝ առանց տողերի հոսքի:

ՆՇՈՒՄ:

Turbo Pascal-ում ես սա չեմ հիշում (գուցե պարզապես մոռացել եմ), բայց ստեղնաշարից մուտքագրումը կարող է կատարվել միայն ReadLn պրոցեդուրայով, իսկ Read պրոցեդուրան ինչ-ինչ պատճառներով չի աշխատում։

Վահանակով ելքի շարահյուսություն.

ընթացակարգըԿարդալ (Args: Փաստարկներ);

Ֆայլի ելքի շարահյուսություն.

ընթացակարգըԿարդացեք ( var F: Տեքստ; Արգս՝ փաստարկներ);

Փաստարկները ( Փաստարկներ) կարող է տարբեր լինել: Եթե ​​օգտագործվում են մի քանի փոփոխականներ, դրանք թվարկվում են՝ բաժանված ստորակետերով: Օրինակ:

Var x, y՝ ամբողջ թիվ; z: իրական; փող՝ տող; սկսել WriteLn («Մուտքագրեք երեք ամբողջ թիվ՝ բաժանված բացատով.»); ReadLn (x, y, z); WriteLn («Դուք մուտքագրել եք:», x, «,», y, «,», z: 0: 2); ReadLn (փողոց); WriteLn (str + str); ReadLn; վերջ.

Ինչպես արդեն ասվեց, վահանակից մուտքագրելիս այդ փոփոխականները կարող են լինել տարբեր տեսակներ... Բայց, ի տարբերություն Write / WriteLn պրոցեդուրաների, այն չի թույլատրվում օգտագործել (և դա տրամաբանական է))):

ԿԱՐԵՎՈՐ!
Տվյալներ մուտքագրելիս պետք է նկատի ունենալ, որ եթե օգտագործողի կողմից մուտքագրված արժեքն ունի տեսակ, որը տարբերվում է փոփոխականի տեսակից, որում մուտքագրված է այս արժեքը, ապա գործարկման ժամանակի սխալ կառաջանա: Եթե, օրինակ, վերը նշված օրինակում օգտագործողը որպես առաջին համար մուտքագրի իրական արժեք (օրինակ՝ 3.14), ապա ծրագիրը կխափանվի, քանի որ x փոփոխականն ունի ամբողջ թվի տեսակ։

Ֆայլից կարդալիս կարող եք աշխատել ինչպես մուտքագրված, այնպես էլ տեքստային ֆայլերի հետ:

Եթե Ֆ(տես շարահյուսություն) մուտքագրված ֆայլ է, այնուհետև որպես պարամետր փոխանցված փոփոխականները (Args) պետք է ունենան նույն տեսակը, ինչ նշված է ֆայլի համար: Ֆ... Չտիպված ֆայլերը չեն թույլատրվում: Եթե ​​պարամետրը Ֆնշված չէ, ենթադրվում է, որ այն կարդում է ստանդարտ մուտքագրումից:

Եթե ​​ֆայլը Ֆտեսակի է Տեքստ, ապա փոփոխականները պետք է լինեն տիպի, or.

Եթե ​​ֆայլը կարդալիս չկան տվյալներ կարդալու համար, ապա դատարկ արժեք է վերադարձվում F փոփոխականին (0 - համար, դատարկ տող - տողերի համար):

ReadLn պրոցեդուրա օգտագործելու դեպքում, այսինքն՝ տվյալների տող առ տող կարդալիս, տողի վերջը նշվում է նիշերի որոշակի հաջորդականությամբ (որը հենց կախված է. օպերացիոն համակարգ, DOS / Windows-ի համար սրանք երկու նիշ են՝ # 10 և # 13):

Տողի վերջի նշիչը ընթերցված տողի մաս չէ և անտեսվում է:

Եթե ​​«Read/ReadLn» ընթացակարգի կատարման ժամանակ սխալ է տեղի ունենում, ապա ստեղծվում է գործարկման ժամանակի սխալ: Այս պահվածքը միշտ չէ, որ ընդունելի է (օրինակ՝ ֆայլ կարդալիս): Հետևաբար, որոշ դեպքերում սխալի ստեղծումն անջատված է: Դուք կարող եք դա անել.

ՆՇՈՒՄ:

ReadLn ռեժիմը հաճախ օգտագործվում է տարբեր վրիպազերծման և ուսուցողական ծրագրերում, որպեսզի կանխվի վահանակի հավելվածի ինքնաբերաբար փակումը գործարկումից հետո: Դա անելու համար ծրագրի վերջում պարզապես գրեք (ինչպես վերը նշված օրինակում).

Այսինքն՝ միայն ընթացակարգի անվանումը՝ առանց պարամետրերի: Այս դեպքում ծրագիրը կսպասի ENTER ստեղնը սեղմելուն: Հետևաբար, ծրագիրը չի դադարեցվի մինչև ENTER ստեղնը սեղմված լինի, և դա թույլ կտա տեսնել ծրագրի արդյունքը: Իհարկե, օպերացիոն համակարգում

Կարծում եմ շատերին կհետաքրքրի)))

Կարդացեք և կարդացեք հայտարարությունները

Ընթերցման հրահանգը նախատեսված է ստեղնաշարից փոփոխականների (սկզբնական տվյալների) արժեքները մուտքագրելու համար: Ընդհանուր առմամբ, հրահանգը հետևյալն է.

կարդալ (Var1, Var2, ... VarN)

որտեղ փոփոխականները փոփոխականի անունն է, որի արժեքը պետք է մուտքագրվի ստեղնաշարից ծրագրի կատարման ժամանակ:

Ահա ընթերցված հայտարարություն գրելու օրինակներ.

կարդալ (ա); կարդալ (Cena, Kol);

Երբ ընթերցված հայտարարությունը կատարվում է, տեղի է ունենում հետևյալը.

1. Ծրագիրը դադարեցնում է իր աշխատանքը և սպասում, մինչև ստեղնաշարի վրա մուտքագրվեն անհրաժեշտ տվյալները և սեղմվի ստեղնը: .

2 http://tissot.ua/ գնել ժամացույց, գնել ժամացույց kiev. ... Բանալին սեղմելուց հետո մուտքագրված արժեքը վերագրվում է հայտարարության մեջ նշված փոփոխականին:

Օրինակ՝ հրահանգի կատարման արդյունքում

կարդալ (Temperat);

և մուտքագրելով տող 21, Temperat փոփոխականի արժեքը կլինի 21 թիվը։

Մեկ ընթերցված հայտարարությունը թույլ է տալիս ստանալ մի քանի փոփոխականների արժեքներ: Այս դեպքում մուտքագրված թվերը պետք է մուտքագրվեն մեկ տողով և բաժանվեն բացատներով: Օրինակ, եթե a, b, c փոփոխականների տեսակը իրական է, ապա հրահանգի կատարման արդյունքում կարդացեք (a, b, c); և ստեղնաշարի մուտքագրման տողը.

4.5 23 0.17

փոփոխականները կունենան հետևյալ արժեքները.

a = 4,5; b = 23.0; c = 0,17:

Եթե ​​տողը պարունակում է ավելի շատ թվեր, քան ընթերցման հրահանգում նշված փոփոխականները, տողի մնացած մասը կմշակվի հետևյալ հրահանգով, կարդացեք http://crystal.lviv.ua crystal crystal: ... https://mainvisa.com.ua լուսանկարչական հրավեր դեպի Ուկրաինա օտարերկրյա քաղաքացիների համար։ ... Օրինակ՝ հրահանգների կատարման արդյունքում

կարդալ (A, B); կարդալ (C);

և ստեղնաշարի մուտքագրման տողը

10 25 18

փոփոխականները կստանան հետևյալ արժեքները. A = 10, B = 25: Կարդացեք հրահանգը (C); կնշանակի 18 արժեք ունեցող փոփոխականին:

Readln հրահանգը տարբերվում է կարդալու հրահանգից նրանով, որ ստեղնաշարից մուտքագրված տողից հաջորդ համարն ընտրելուց և ընթերցման հրահանգի ցանկի վերջին փոփոխականին վերագրելուց հետո տողի մնացած մասը կորչում է, իսկ հաջորդ ընթերցումը կամ կարդալու հրահանգը կպահանջի նոր մուտքագրում:

Օրինակ՝ հրահանգի կատարման արդյունքում

կարդալ (A, B); կարդալ (C);

և մուտքագրելով տողը

10 25 18

Փոփոխականները կստանան հետևյալ արժեքները՝ A = 10, B = 25: Դրանից հետո ծրագիրը կսպասի նոր թվի մուտքագրմանը, որպեսզի այն վերագրի c փոփոխականին:

Յուրաքանչյուր կարդալու կամ կարդալու հրահանգին պետք է նախորդի գրելու հրահանգը, որպեսզի օգտագործողին ասի, թե ինչ տվյալներ է ակնկալում ծրագիրը նրանից: Օրինակ, գնման արժեքը հաշվարկելու ծրագրի մի հատվածը կարող է նման լինել.

writeln («Մուտքագրեք նախնական տվյալները»);

Գրեք («Ապրանքի գինը:»);

Readln (Сenа);

գրել («Քանակը խմբաքանակում.»);

Readln (Kol);

գրել («Զեղչ:»);

readln (Skidka);

Եթե ​​ստեղնաշարից մուտքագրված տվյալների տեսակը չի համընկնում կամ չի կարող փոխանցվել դրան փոփոխականների տեսակըորոնց անունները նշված են read (readin) հայտարարության մեջ, ծրագիրը խափանում է (ընթերցվելուց հետո հայտարարությունները չեն կատարվում), և էկրանին ցուցադրվում է սխալի հաղորդագրություն:

հեղինակ Ալեքսանդրհատվածում հարց տվեց Այլ լեզուներ և տեխնոլոգիաներ

Ինչու՞ է Պասկալը կարդացել և կարդալ, եթե կարդալը նաև տող է թարգմանում, թեև տեսականորեն չպետք է: և ստացավ լավագույն պատասխանը

Skipy _ [գուրու]-ի պատասխանը
readln - մուտքագրման բուֆերից արժեքը վերցնում է պարամետր, մաքրում է ստեղնաշարի մուտքագրման ամբողջ բուֆերը
և կարդալ - մուտքագրման բուֆերից արժեքը վերցնում է պարամետր և այն չի մաքրում բուֆերում, այլ թողնում է արժեքը !! !
Տողերի ավտոմատ սնուցում մուտքագրելիս՝ ամենուր
այսինքն readln-ն անվտանգ մուտքագրում է
կարդալ- անապահով մուտքագրում
օրինակ:
var
a, b: ամբողջ թիվ;
սկսել
կարդալ (ա); (օգտագործողը մուտքագրել է՝ 4, 5 a = 4)
(մուտքագրման բուֆերում թիվ 5!!}
կարդալ (բ); (այստեղ նա մուտքագրեց թիվ՝ 6, բայց b = 5)
(6 թիվը մնում է մուտքային բուֆերում:!}
---
readln (a); (օգտագործողը մուտքագրել է՝ 4, 5; a = 4)
(մուտքագրման բուֆերը պարզ է:!}
readln (a); (օգտվողը մուտքագրել է համարը 6 և b = 6)
(մուտքագրման բուֆերը պարզ է:!}
կարդալ (բ);
վերջ.
Ընդհակառակը, մուտքային արժեքի տեսակի ավտոմատ որոշում չկա, ամեն ինչ որոշված ​​է կոնվենցիաներձևաչափի ցուցիչում:

Պատասխան՝-ից Յոալի-Մալի[գուրու]
Դա կարելի է բացատրել ավելի պարզ ձևով, առանց հատուկ խնդիրների.
Երբ ընթերցման պրոցեդուրան կատարվում է, հաջորդ տվյալների արժեքը կարդացվում է նույն տողից, իսկ երբ readln պրոցեդուրան կատարվում է, հաջորդ տվյալների արժեքը կարդացվում է նոր տողից։
Հետևաբար, Readln օպերատորը (b1, b2, ... bn); ապահովում է տվյալների մուտքագրում BAR-ում:
Յուրաքանչյուր b1, b2, ..bn փոփոխական մուտքագրելուց հետո կուրսորը տեղափոխվում է նոր տողի սկիզբ:
Կարդացեք օպերատորը (b1, b2, ... bn); ապահովում է տվյալների մուտքագրում LINE

Պատասխան՝-ից VT-107 FIT[գուրու]
Այստեղ Դմիտրիի ինչ-որ բան սխալ էր, բայց ոչ ճիշտ: Եվ ամբողջովին մաքրված և չմաքրված բուֆերի և անվտանգության մասին: Սալին նույնպես ճիշտ չի պատասխանել։ Չկան սյունակներ և տողեր, բոլորովին այլ կանոններ:
Նախ, այս ընթացակարգերը ոչ միայն աշխատում են վահանակի մուտքագրման հետ, ուստի անհրաժեշտ է երկու գործառույթ:
ընթացակարգը Կարդացեք (F, V1 [, V2, ... Vn]);
կարդում է ամբողջ V1..Vn-ը հոսքից (հենց n պարամետր), բոլոր կարդացված տվյալները կջնջվեն: Այն ամենը, ինչ տեղի կունենա այս տվյալներից հետո, կմնա անփոփոխ։
Տող կարդալը կկարդա ամեն ինչ մինչև նոր տող կամ ֆայլի վերջ: Ընթերցանության հետագա զանգերը կվերադարձնեն դատարկ տող: Իսկ նոր տողի նիշը հոսքից չի հեռացվի:
Եթե ​​դուք կարդում եք նիշ, ապա կախված կարգավորումներից, նոր տողի նիշը կարող է կարդալ որպես char (26)
Թվերը կարդալիս բաց են թողնում բոլոր բացատները, ներդիրները, տողերի ընդմիջումները: Իսկ հաջորդ ընթերցումը կսկսվի կարդացված թվին հաջորդող գրանշանով։ Կրկին, ավելորդ կերպարները կարելի է բաց թողնել:
ընթացակարգ ReadLn ([var F: Text;] V1 [, V2, ..Vn]);
կարդում է V1, Vn հոսքից (այսինքն՝ այն աշխատում է կարդալու պես) և այնուհետև բաց է թողնում բոլոր նիշերը մինչև նոր տողը ներառյալ: Բոլոր նիշերը տողերի ընդմիջումից հետո կմնան անփոփոխ:
Գնալ նոր գիծիրականացվում է, քանի որ վահանակում սեղմում եք Enter:
Անվտանգության մասին անհասկանալի է: Սրանք տարբեր նպատակներով գործառույթներ են։ Դրանց ոչ պատշաճ օգտագործումը անվտանգ չէ, ցանկացած ճիշտ և համապատասխանաբար անվտանգ:

Ընթերցման հրահանգը նախատեսված է ստեղնաշարից փոփոխականների (սկզբնական տվյալների) արժեքները մուտքագրելու համար: Ընդհանուր առմամբ, հրահանգը հետևյալն է.

կարդալ (փոփոխական !, փոփոխական2, ... փոփոխական

Ահա ընթերցված հայտարարություն գրելու օրինակներ.

Կարդացեք (a); կարդալ (Cena, Kol);

Երբ ընթերցված հայտարարությունը կատարվում է, տեղի է ունենում հետևյալը.

1. Ծրագիրը դադարեցնում է իր աշխատանքը և սպասում, մինչև ստեղնաշարի վրա մուտքագրվեն անհրաժեշտ տվյալները և սեղմվի ստեղնը: .

2. Բանալին սեղմելուց հետո մուտքագրված արժեքը վերագրվում է հայտարարության մեջ նշված փոփոխականին:

Օրինակ՝ հրահանգի կատարման արդյունքում

Կարդալ (Tempérât);

և մուտքագրելով տող 21, Tempérât-ի արժեքը 21 է:

Մեկ ընթերցված հայտարարությունը թույլ է տալիս ստանալ մի քանի փոփոխականների արժեքներ: Այս դեպքում մուտքագրված թվերը պետք է մուտքագրվեն մեկ տողով և բաժանվեն բացատներով: Օրինակ, եթե a, b, c փոփոխականների տեսակը իրական է, ապա ընթերցման կատարման արդյունքում (a, b, c); և ստեղնաշարի մուտքագրման տողը.

4.5 23 0.17

փոփոխականները կունենան հետևյալ արժեքները. a = 4.5; b = 23, o; c = 0,17:

Եթե ​​տողը պարունակում է ավելի շատ թվեր, քան փոփոխականները, որոնք նշված են կարդալ հայտարարության մեջ, ապա տողի մնացած մասը կմշակվի հաջորդ ընթերցման հայտարարությամբ: Օրինակ, հրահանգների կատարման արդյունքում.

Կարդացեք (a, B); կարդալ (C);

և ստեղնաշարի մուտքագրման տողը

10 25 18

փոփոխականները կստանան հետևյալ արժեքները. a = 10, b = 25: Կարդացեք հրահանգը (C); կնշանակի 18 արժեք ունեցող փոփոխականին:

Readln հրահանգը տարբերվում է կարդալու հրահանգից նրանով, որ ստեղնաշարից մուտքագրված տողից հաջորդ համարն ընտրելուց և այն readln հրահանգի ցանկի վերջին փոփոխականին վերագրելուց հետո մնացած տողը կորչում է, իսկ հաջորդ ընթերցումը կամ readln հրահանգը կպահանջի նոր մուտքագրում:

Օրինակ, հրահանգի կատարման արդյունքում.

Readln (a, B); կարդալ (C);

և մուտքագրելով տողը

10 25 18

փոփոխականները կստանան հետևյալ արժեքները՝ a = 10, b = 25: Դրանից հետո ծրագիրը կսպասի նոր թվի մուտքագրմանը, որպեսզի այն վերագրի c փոփոխականին:

Յուրաքանչյուր կարդալու կամ կարդալու հրահանգին պետք է նախորդի գրելու հրահանգը, որպեսզի օգտագործողին ասի, թե ինչ տվյալներ է ակնկալում ծրագիրը նրանից: Օրինակ, գնման արժեքը հաշվարկելու ծրագրի մի հատվածը կարող է նման լինել.

Writeln («Մուտքագրեք բնօրինակ տվյալները»); գրել («Ապրանքի գինը:»); readln (Sepa); գրել («Քանակը խմբաքանակում.»); readln (Kol); գրել («Զեղչ:»); readln (Skidka);

Եթե ​​ստեղնաշարից մուտքագրված տվյալների տեսակը չի համընկնում կամ չի կարող փոխարկվել փոփոխականների տեսակին, որոնց անունները նշված են read (readln) հայտարարության մեջ, ծրագիրը խափանում է (ընթերցման հաջորդ հրահանգները չեն կատարվում), և հաղորդագրություն է ցուցադրվում: էկրանին սխալի մասին:

Թեմա:Մուտքային ելք. Կարդացեք (Readln), Գրեք (Writeln) հայտարարությունները: Ամենապարզ գծային ծրագրերը.

Եկեք խնդիրը լուծենք՝ մեկնաբանելով մեր յուրաքանչյուր գործողությունը գանգուր բրեկետներ... Հիշեցնենք, որ մեկնաբանությունը համակարգչի կողմից չի ընկալվում, սակայն այն մեզ անհրաժեշտ է, որպեսզի ավելի լավ հասկանանք, թե ինչպես է աշխատում ծրագիրը:

Առաջադրանք ... Գրեք ծրագիր, որը մաքրում է էկրանը և հաշվարկում օգտագործողի կողմից տրամադրված երկու թվերի արտադրյալը:

Proizv2 ծրագիր; Օգտագործումներ Crt; (Մենք միացնում ենք Crt մոդուլը) Վար թիվ 1, (փոփոխական, որը կպահի առաջին թիվը) թիվ 2, (փոփոխական, որը կպահպանի երկրորդ թիվը) rezult (փոփոխական, որը կպարունակի արդյունքը) : ամբողջ թիվ; Սկսել ClrScr; (Մենք օգտագործում ենք էկրանը Crt մոդուլից մաքրելու կարգը) Գրեք («Մուտքագրեք առաջին համարը»); Readln (թիվ 1); (Օգտագործողի կողմից մուտքագրված թիվը կարդացվում է թիվ 1 փոփոխականի մեջ) Գրեք («Մուտքագրեք երկրորդ համարը»); (Ապաստրոֆների միջև գրված նիշերի ցուցադրում) Readln (թիվ 2); (Օգտագործողի կողմից մուտքագրված թիվը կարդացվում է թիվ 2 փոփոխականի մեջ) rezult: = թիվ 1 * թիվ 2; (Գտեք մուտքագրված թվերի արտադրյալը և վերագրեք այն rezult փոփոխականին) Գրել («Թվերի արտադրյալ», թիվ 1, «և», թիվ 2, «հավասար է», արդյունք); (Մենք ցուցադրում ենք խնդրի պատասխանը պարունակող տող) Readln; (Էկրանի հետաձգման ընթացակարգ) Վերջ.

Ծրագրի գործողությունն ավելի լավ հասկանալու համար մուտքագրեք այն ձեր համակարգչում և փորձարկեք դրա գործողությունը: Պատասխանել հարցերին:

• ինչու է ծրագիրը կոչվում Proizv2:
• Ինչո՞ւ եք Crt մոդուլը դրել Uses բաժնում:
• Ո՞րն է թիվ 1, թիվ 2, rezult փոփոխականների նպատակը:
• ինչ տեսակի են այս փոփոխականները: ինչ է դա նշանակում?
• Եթե ​​թիվ 1 և համար 2 փոփոխականները վերագրենք համապատասխանաբար 5 և 7 արժեքներին, ապա ի՞նչ տող կառաջացնի համակարգիչը վերջին Write պրոցեդուրան կատարելիս: Գրեք այն ձեր նոթատետրում:
• ո՞ր տողերում է օգտվողին հուշում փոփոխականների արժեքները:
• Ո՞ր տողում է տեղի ունենում թվերի բազմապատկումը.
• ի՞նչ է անում հանձնարարության օպերատորը այս ծրագրում:

Զորավարժություններ ... Փոփոխեք ծրագիրը այնպես, որ այն օգտագործողին հուշի մեկ այլ փոփոխական և թողարկի երեք թվերի արտադրյալ:

Գրեք և գրեք հայտարարություններ

Մենք արդեն օգտագործել ենք Write և WriteLn օպերատորները, սակայն պետք է ավելի մանրամասն անդրադառնալ այս օպերատորների օգտագործման կանոններին:

Write-ը օպերատոր է, որն օգտագործվում է էկրանին տեղեկատվություն ցուցադրելու համար: WriteLn օպերատորը կատարում է նույն գործողությունը, բայց քանի որ ունի նաև Ln (տող) վերջավորությունը, ցանկալի հաղորդագրությունը էկրանին ցուցադրելուց հետո լրացուցիչ կուրսորը տեղափոխում է հաջորդ տող։

Ընդհանուր ձև.
Գրել (արտահայտությունների ցանկ)
WriteLn (արտահայտությունների ցանկ)

Write և WriteLn պրոցեդուրաներն օգտագործվում են ոչ միայն արդյունքը ցուցադրելու, այլև տարբեր հաղորդագրություններ կամ հարցումներ ցուցադրելու համար: Սա թույլ է տալիս երկխոսություն վարել օգտատիրոջ հետ, ասել նրան, թե երբ է պետք արժեքներ մուտքագրել, երբ արդյունք է ստանում, երբ սխալ է թույլ տվել և այլն։

Օրինակ՝ WriteLn պրոցեդուրան («Գտնված թիվ», ա) կատարելիս կտպվի ապոստրոֆներով փակված տող, այնուհետ կցուցադրվի a փոփոխականի արժեքը։

WriteLn հայտարարությունը կարող է օգտագործվել առանց պարամետրերի: Այս դեպքում բացատներից բաղկացած տողը կտպվի, և կուրսորը կտեղափոխվի այլ տող: Երբեմն դա մեզ անհրաժեշտ է տվյալների մուտքագրման ավելի լավ ընկալման համար:

Կարդացեք և ReadLn օպերատորներ

Հիշենք, որ համակարգչի հիմնական նպատակը մարդկային աշխատուժի խնայումն է։ Ուստի անհրաժեշտ է հնարավորություն տալ, մեկ անգամ ծրագիր գրելով, այն նորից օգտագործել՝ ամեն անգամ տարբեր տվյալներ մուտքագրելով։ Լեզվի այս ճկունությունը ապահովված է Read և ReadLn հայտարարություններով: Այս օպերատորները տեղեկատվություն են մուտքագրում ստեղնաշարից:

Ընդհանուր ձև.
Կարդացեք (փոփոխական, փոփոխական ...)
ReadLn (փոփոխական, փոփոխական ...)

Read ընթացակարգը ակնկալում է, որ մուտքագրվեն փակագծերում նշված արժեքները: Մուտքագրված տվյալները պետք է բաժանվեն միմյանցից բացատներով: Արժեքների նշանակումը տեղի է ունենում իր հերթին:

Օրինակ, եթե մուտքագրված են 53 և X արժեքները, ապա, երբ կատարվում է Read (a, b) հայտարարությունը, 53 թիվը վերագրվելու է a փոփոխականին, իսկ X տառը՝ X փոփոխականին: Ավելին, Արտակարգ իրավիճակներից խուսափելու համար անհրաժեշտ է ճիշտ որոշել տվյալների տեսակը Var բաժնում; մեր դեպքում՝ a՝ ամբողջ թիվ և b՝ char.

Read և ReadLn օպերատորների օգտագործման մեջ առանձնահատուկ տարբերություններ չկան կարդալու և գրելու մեջ: Հաճախ առանց պարամետրերի ReadLn պրոցեդուրան օգտագործվում է ծրագրի վերջում՝ հետաձգելու համար՝ նախքան ստեղնը սեղմելը: ծրագրի կատարման արդյունքը մնում է էկրանին: Սա շատ օգտակար է արդյունքները վերլուծելու համար։

Նշում ... Երբ դուք սահմանում եք էկրանի հետաձգումը, ուշադրություն դարձրեք նախորդ մուտքին: Եթե ​​տվյալները պահանջվել են «Ընթերցման» ընթացակարգով, ապա ուշացում չի լինի:

Եկեք լուծենք մի խնդիր, որում մենք կքննարկենք այս ընթացակարգերի բոլոր հնարավոր կիրառությունները:

Առաջադրանք ... Գտեք երեք թվերի միջինը:

Նշում ... Մի քանի թվերի միջինը գտնելու համար գումարեք այս թվերը և գումարը բաժանեք այդ թվերի թվի վրա։

Մուտքագրեք խնդրի տեքստը և ուշադիր դիտարկեք յուրաքանչյուր տող: Srednee ծրագրի անվանումը արտացոլում է առաջադրանքի բովանդակությունը: Ի դեպ, համաձայնենք, որ ծրագրի անվանումը և այս ծրագիրը պարունակող ֆայլի անվանումը նույնն են։ Հաջորդը գալիս է Crt մոդուլի միացումը: Var բաժնում First, Second, Third-ը նկարագրվում են որպես ամբողջ թվի տիպի փոփոխականներ, իսկ Sum-ը իրական տիպի է: Օպերատորների բաժինը սկսվում է ստանդարտ ընթացակարգՄաքրել ClrScr էկրանը (Clear Screen), որը գտնվում է Crt մոդուլում: Այնուհետև Write քաղվածքով ցուցադրում ենք «Enter the first number» հաղորդագրությունը, որը ստանալուց հետո օգտատերը պետք է մուտքագրի համարը։

Այժմ համակարգիչը պետք է կարդա մուտքագրված նիշերը և տեղադրի դրանք Առաջին փոփոխականում, դա տեղի կունենա, երբ հաջորդ ReadLn (Առաջին) հայտարարությունը կատարվի: Այնուհետև, օգտագործելով Write հայտարարությունը, մենք պահանջում ենք ևս երկու թվերի արժեքներ և դրանք կարդում Երկրորդ և Երրորդ փոփոխականների մեջ: Այնուհետև հաշվում ենք դրանց գումարը և ստացված թիվը վերագրում Sum փոփոխականին։ Միջինը գտնելու համար այժմ պետք է ստացված թիվը բաժանել 3-ի և արդյունքը պահել որոշ փոփոխականում:

Արդյունքը պահպանելու համար ամենևին էլ պարտադիր չէ այլ փոփոխական հայտարարել։ Դուք կարող եք, ինչպես մեր ծրագրում, Sum փոփոխականի արժեքը բաժանել 3-ի և արդյունքը կրկին վերագրել նույն Sum փոփոխականին։ Այժմ դուք կարող եք հաշվարկների արդյունքը ցուցադրել էկրանին, օգտագործելով Գրել ընթացակարգը: Վերջապես, ReadLn-ի վերջնական ռեժիմը կհետաձգի մեր ելքը դեպի էկրան, մինչև սեղմվի ստեղնը:

Սեղմեք ստեղները +... Մուտքագրեք 5, 7 և 12 փոփոխականների արժեքները, էկրանին կտեսնեք հետևյալը.

5-ի, 7-ի և 12-ի միջինը 8.00 է

Ուշադիր նայեք այս տողին և համեմատեք այն մեր ծրագրի արդյունքի դուրսբերման տողի հետ: Փորձարկեք ծրագիրը ևս մի քանի անգամ տարբեր փոփոխական արժեքների համար:

Ուսուցչի հետ ընտրեք լուծելիք խնդիրները հետևյալ ցանկից.

1. Մուտքագրեք երկու թվեր a և b: Օգտագործեք հանձնարարության օպերատորը՝ դրանց արժեքները փոխանակելու համար.
   ա) օգտագործելով միջանկյալ փոփոխական (x: = a; a: = b; b: = x);
   բ) առանց միջանկյալ փոփոխական օգտագործելու (a: = a-b; b: = a + b; a: = b-a):
2. Գրեք ծրագիր, որը օգտատիրոջից խնդրում է ամբողջ թիվ, իրական թիվ, կամայական նիշ և տող, ապա ամեն ինչ տպում է մեկ տողով:
3. Ցուցադրեք ձեր ազգանունը, անունը և հայրանունը, իսկ երկու տողից հետո՝ ձեր ծննդյան ամսաթիվը:
4. Գրեք ծրագիր աստղանիշներով պատկերներից մեկը տպելու համար.
   ա) տոնածառեր (մի քանի տոնածառ).
   բ) ձյան փաթիլներ (մի քանի ձյան փաթիլներ);
   գ) տուն, օրինակ.

   *
   * *
   * *
   ***********
   * *
   * *
   * *
   * *
   ***********

5. Կազմեք ձեր այցեքարտը:

   
   * Իվանով Սերգեյ *
   * Պրոլետարսկայա 74 քառ. 55 *
   * Հեռ. 45-72-88 *
   *******************************

6. Կազմեք երկխոսություն օգտագործողի և համակարգչի միջև կամայական թեմայի շուրջ:
   Օրինակ, մեքենան տալիս է երկու հարց՝ «Ինչ է քո անունը»: քանի տարեկան ես?"; անունը (Անտոն) և համարը (15) մուտքագրելուց հետո էկրանին կցուցադրվի «Այո… 50 տարի հետո դուք կդառնաք 65 տարեկան, և ձեր անունը կլինի ոչ թե Անտոն, այլ Անտոն պապիկ»:
7. Օգտագործողից խնդրեք երկու թիվ և ամբողջական պատասխանով ցուցադրեք այս թվերի գումարի, տարբերության, արտադրյալի և գործակիցի արդյունքը:
8. Օգտագործողին հուշեք երկու թվեր և ցուցադրեք ամբողջ թվերի բաժանման արդյունքը և ամբողջ թվի բաժանման մնացորդը աղյուսակի տեսքով: Օրինակ, 5 և 3 համարները մուտքագրելիս էկրանին պետք է ցուցադրվի հետևյալ աղյուսակը.

   **************************
   * X * Y * div * mod *
   **************************
   * 5 * 3 * 1 * 2 *
   **************************

9. Գրեք ծրագիր, որը հարցնում է կենդանու անունը և համարը, այնուհետև ցուցադրում է «Սկյուռիկը 10 սունկ կուտի» արտահայտությունը (երբ մուտքագրում եք «սկյուռ» բառը և 10 թիվը):
10. Կազմակերպել երկխոսություն վաճառողի (համակարգչի) և գնորդի (օգտագործողի) միջև ցանկացած ապրանք գնելիս հետևյալ սխեմայով. գնորդը պետք է վճարի գնման համար: