Mga uri ng data ng Pascal
Ang anumang data (constants, variable, value ng function o expression) sa Turbo Pascal ay nailalarawan sa pamamagitan ng kanilang mga uri. Tinutukoy ng isang uri ang hanay ng mga wastong halaga na maaaring magkaroon ng isang bagay, pati na rin ang hanay ng mga wastong operasyon na maaaring mailapat dito. Tinutukoy din ng uri ang format ng panloob na representasyon ng data sa memorya ng computer.
Mayroong mga sumusunod na uri ng data sa Turbo Pascal.
1) Mga simpleng uri:
– tunay;
– simboliko;
– Boolean (lohikal);
– binanggit;
– limitado (saklaw).
2) Composite (structured) na mga uri:
– regular (mga array);
- pinagsama (mga talaan);
– file;
– maramihan;
– string;
– mga bagay.
3) Mga uri ng sanggunian (na-type at hindi na-type na mga pointer).
4) Mga uri ng pamamaraan.
Nagbibigay ang Turbo Pascal ng isang mekanismo para sa paglikha ng mga bagong uri ng data, salamat sa kung saan ang kabuuang bilang ng mga uri na ginamit sa programa ay maaaring maging kasing laki ng ninanais.
Uri ng integer. Ang mga halaga ng integer ay ang mga elemento ng isang subset ng mga integer. Mayroong limang uri ng integer sa Turbo Pascal. Ang kanilang mga pangalan, hanay ng mga halaga, haba ng representasyon sa mga byte ay ibinibigay sa talahanayan. 6.
Talahanayan 6
Mga uri ng data ng integer
Integer variable ay inilalarawan gamit ang mga nakalaan na salita sa itaas:
i, j, k: integer;
Ang data ng uri ng integer ay eksaktong nakaimbak sa memorya. Halimbawa, ang mga variable ng uri ng integer ay sumasakop ng 2 byte (16 bits) sa memorya, na inilalaan tulad ng sumusunod: 1 bit ay inilalaan upang iimbak ang tanda ng numero (0 kung ang numero ay positibo, at 1 kung ang numero ay negatibo) at 15 bits upang iimbak ang numero sa binary. Ang maximum na decimal na numero na maaaring isulat bilang 15-bit binary ay 32767.
Kapag gumagamit ng mga pamamaraan at pag-andar na may mga parameter ng integer, dapat kang magabayan ng "nesting" ng mga uri, i.e. saanman ginagamit ang salita, pinapayagan ang byte (ngunit hindi kabaligtaran), ang longint ay "kasama" ang isang integer, na kung saan, kabilang ang shortint.
Para sa uri ng integer, limang pangunahing operasyon ang tinukoy, ang resulta nito ay isang integer din: +, -, *, div, mod (pagdaragdag, pagbabawas, pagpaparami, integer division at natitira sa integer division). Sa mga expression ng arithmetic, ang mga operasyon *, div, mod ay may mas mataas na priyoridad kaysa sa mga operasyon +, -. Mga halimbawa ng pagsulat ng mga expression:
Ang listahan ng mga pamamaraan at function na naaangkop sa mga uri ng integer ay ibinibigay sa talahanayan. 7. Ang mga letrang b, s, w, i, l ay tumutukoy sa mga expression ng uri ng byte, shortint, salita, integer, at longint, ayon sa pagkakabanggit; x ay isang pagpapahayag ng alinman sa mga uri na ito; ang mga identifier na vb, vs, vw, vi, vl, vx ay tumutukoy sa mga variable ng mga kaukulang uri. Ang isang opsyonal na parameter ay ipinahiwatig sa mga square bracket.
Talahanayan 7
Mga karaniwang pamamaraan at pag-andar na naaangkop sa buong uri
| apela | Uri ng resulta | Aksyon |
| Abs(x) | x | Ibinabalik ang module x |
| Chr(b) | Char | Nagbabalik ng character sa pamamagitan ng code nito |
| Dis(vx[,i]) | - | Binabawasan ang halaga ng vx ng i, at sa kawalan ng i – ng 1 |
| Inc(vx[,i]) | - | Pinapataas ang halaga ng vx ng i, at sa kawalan ng i – ng 1 |
| Hi(i) | Byte | Ibinabalik ang mataas na byte ng argumento |
| Hi(i) | Byte | Pareho |
| Lo(i) | Byte | Ibinabalik ang mababang byte ng argumento |
| Mababa (w) | Byte | Pareho |
| Kakaiba(l) | Byte | Nagbabalik ng true kung ang argument ay isang kakaibang numero |
| Random (w) | Pareho sa parameter | Nagbabalik ng pseudo-random na numero na pantay na ipinamamahagi sa hanay na 0...(w-1) |
| Sqr(x) | x | Ibinabalik ang parisukat ng argumento |
| Pagpalitin(i) | Integer | |
| Magpalit (w) | salita | Nagpapalitan ng mga byte sa isang salita |
| Succ(x) | Pareho sa parameter | Ibinabalik ang susunod na integer value, i.e. x+1 |
| Pred(x) | Pareho sa parameter | Ibinabalik ang naunang integer value, i.e. x-1 |
Kapag gumagamit ng mga integer, ang uri ng resulta ay tumutugma sa uri ng operand, at kung ang mga operand ay may iba't ibang uri ng integer, ang uri ng operand na may pinakamataas na hanay ng mga halaga. Ang posibleng pag-apaw ng resulta ay hindi kinokontrol, na maaaring humantong sa mga error sa programa.
Tunay na uri. Ang mga halaga ng totoong uri ay tumutukoy sa isang arbitrary na numero na may ilang tiyak na katumpakan depende sa panloob na format ng tunay na numero. Mayroong limang tunay na uri sa Turbo Pascal (Talahanayan 8).
Talahanayan 8
Mga totoong uri ng data
Ang mga tunay na variable ay inilalarawan gamit ang mga nakalaan na salita sa itaas:
Ang isang tunay na numero sa memorya ng computer ay binubuo ng 3 bahagi:
Mag-sign digit ng isang numero;
Exponential na bahagi;
Mantissa ng numero.
Ang mantissa ay may haba mula 23 (Single) hanggang 63 (Extended) binary digit, na nagbibigay ng katumpakan ng 7-8 para sa Single at 19-20 para sa Extended decimal digit. Ang decimal point (comma) ay ipinahiwatig bago ang kaliwa (pinaka makabuluhang) digit ng mantissa, ngunit kapag gumagana sa isang numero, ang posisyon nito ay inililipat sa kaliwa o kanan alinsunod sa binary order ng numero na nakaimbak sa exponential na bahagi , samakatuwid ang mga operasyon sa mga tunay na numero ay tinatawag na floating point (comma) arithmetic .
Ang mga single, Double, at Extended na mga uri ay ina-access lamang sa ilalim ng mga espesyal na mode ng compilation. Upang paganahin ang mga mode na ito, piliin ang item sa menu Mga pagpipilian, Compiler... at paganahin ang opsyon 8087/80287 sa grupo Pagproseso ng numero.
Ang isang espesyal na posisyon sa Turbo Pascal ay inookupahan ng uri ng Comp, na itinuturing bilang isang tunay na numero nang walang exponential at fractional na mga bahagi. Sa katunayan, ang Comp ay isang malaking naka-sign integer na nag-iimbak ng 19...20 makabuluhang decimal digit. Kasabay nito, sa mga expression, ang Comp ay ganap na katugma sa anumang iba pang mga tunay na uri: ang lahat ng mga tunay na operasyon ay tinukoy dito, maaari itong magamit bilang isang argumento sa mga pagpapatakbo ng matematika, atbp.
Ang mga tunay na numero ay tinukoy sa sistema ng decimal na numero sa isa sa dalawang anyo.
SA fixed point form ang talaan ay binubuo ng isang integer at isang fractional na bahagi, na pinaghihiwalay ng isang tuldok sa isa't isa, halimbawa:
0.087 4.0 23.5 0.6
SA floating point form ang entry ay naglalaman ng titik E, na nangangahulugang "multiply sa sampu sa kapangyarihan", at ang kapangyarihan ay isang integer, halimbawa:
7E3 6.9E-8 0.98E-02 45E+04
Ang mga sumusunod na operasyon ay tinukoy sa mga bagay ng totoong uri: +, -, *, /.
Ang mga pagpapatakbong "*" at "/" ay may mas mataas na priyoridad kaysa sa mga pagpapatakbong "+" at "-".
Kung hindi bababa sa isang operand ay totoo, kung gayon ang mga operasyon +, -, *, / ay humahantong sa isang tunay na resulta. Ang operasyon ng paghahati / humahantong sa isang tunay na resulta kahit na sa kaso ng dalawang integer operand, halimbawa: 9/3 = 3.0.
Upang gumana sa totoong data, maaaring gamitin ang karaniwang mga function ng matematika na ipinakita sa talahanayan. 9. Ang resulta ng mga function na ito ay totoo rin.
Talahanayan 9
Mga function ng matematika na gumagana sa totoong data
Ang mga variable at constant ng uri ng REAL ay ipinagbabawal na gamitin:
– sa mga function pred(x), succ(x), ord(x);
– bilang mga index ng array;
– bilang mga label sa control transfer statement;
– bilang mga variable ng kontrol (mga parameter ng cycle).
Upang i-convert ang isang tunay na numero sa isang integer, maaari mong gamitin ang mga sumusunod na function:
trunc(x) – integer na bahagi ng x (x – real);
round(x) – rounding sa pinakamalapit na integer (x is real).
Uri ng karakter. Inilalarawan ang mga variable ng character gamit ang nakalaan na salitang char:
Ang mga halaga ng ganitong uri ay pinili mula sa isang ordered character set (ASCII set) na binubuo ng 256 character. Ang bawat karakter ay bibigyan ng integer mula sa hanay na 0..255. Halimbawa, ang malalaking titik ng alpabetong Latin A..Z ay may mga code na 65..90, at ang mga maliliit na titik ay may mga code na 97..122.
Ang halaga ng variable ng uri ng character ay isang character na napapalibutan ng mga apostrophe, halimbawa:
'F' '8' '*'
Ang mga variable ng character ay maaaring ihambing sa bawat isa, at ang mga code ng character ay inihambing.
May mga function na nagtatag ng isang sulat sa pagitan ng isang simbolo at code nito:
ord(c) – nagbibigay ng numero ng simbolo c;
chr(i) – nagbabalik ng character number i.
Ang mga pag-andar na ito ay kabaligtaran sa bawat isa.
Uri ng Boolean. Ang mga variable ng Boolean ay idineklara gamit ang nakareserbang salitang boolean:
p1, p2: boolean;
Ang mga variable ng uri ng Boolean ay tumatagal ng dalawang halaga: totoo(totoo), mali(kasinungalingan).
Ang mga halagang ito ay nakaayos tulad ng sumusunod: false< true. false имеет порядковый номер 0, true имеет порядковый номер 1.
Ang mga variable ng Boolean ay maaaring direktang magtalaga ng value o gumamit ng Boolean expression. Halimbawa,
a, d, g, b: boolean;
Mga pagpapatakbo ng kaugnayan (<, <=, >, >=, =, <>), na inilapat sa integer, tunay, at simbolikong mga variable, ay gumagawa ng isang lohikal na resulta.
Ang mga lohikal na operasyon sa mga operand ng lohikal na uri ay gumagawa din ng isang lohikal na resulta (ang mga operasyon ay nakalista sa pababang pagkakasunud-sunod ng priyoridad) (para sa higit pang mga detalye, tingnan ang Mga Talahanayan 3 at 5):
hindi – negasyon (WALANG operasyon);
at – lohikal na pagpaparami (AND operation);
o – lohikal na karagdagan (O operasyon);
xor – eksklusibo O.
Ang expression (hindi a) ay may kabaligtaran na kahulugan ng a.
Ang expression (a at b) ay nagsusuri sa true kung pareho lang ang a at b ay totoo, kung hindi, ang halaga ng expression na ito ay mali.
Ang expression (a o b) ay nagsusuri sa false kung ang parehong a at b ay nagsusuri sa false kung hindi, ang resulta ay totoo.
Uri ng enum. Ang isang hindi karaniwang uri ng enumeration ay tinukoy ng isang enumeration sa anyo ng mga pangalan ng mga halaga na maaaring kunin ng isang variable. Ang bawat halaga ay pinangalanan ng ilang identifier at matatagpuan sa isang listahan na napapalibutan ng mga panaklong. Pangkalahatang anyo ng enumerated type na paglalarawan:
x = (w1, w2, …, wn);
kung saan ang x ay ang pangalan ng uri, w1, w2,..., wn ay ang mga halaga na maaaring kunin ng variable ng uri x.
Ang mga halagang ito ay iniutos w1 Ang mga sumusunod na karaniwang function ay nalalapat sa argument w ng isang enumerated na uri: succ(w), pred(w), ord(w). kulay=(pula, itim, dilaw, berde) ww=(kaliwa, pataas, kanan, pababa); f: hanay ng ww; succ(d) = dilaw; Ang mga variable na a at b ay may uri ng w. maaari silang kumuha ng isa sa tatlong halaga, na may on Ang mga relational na operasyon ay naaangkop sa mga halaga ng enumerated na uri: =,<>, <=, >=, <, >. Pinapayagan na tukuyin ang mga enumerated na uri ng pare-pareho nang direkta sa seksyon var nang hindi gumagamit ng partisyon uri, Halimbawa c,d: (pula, itim, dilaw, berde); Uri ng saklaw (limitado).. Kapag tinutukoy ang isang limitadong uri, tinukoy mo ang mga inisyal at panghuling halaga na maaaring kunin ng isang variable ng uri ng hanay. Ang mga halaga ay pinaghihiwalay ng dalawang tuldok. Ang paglalarawan ng pinaghihigpitang uri ay nasa anyo Narito ang pangalan ng uri, min, max ay mga constant. Kapag tumutukoy ng pinaghihigpitang uri, dapat sundin ang mga sumusunod na patakaran: – ang parehong boundary constants min at max ay dapat magkaparehong uri; – ang isang limitadong uri ay nilikha mula sa data ng isang uri ng base, na maaaring isang integer, character o enumerated na uri. Halimbawa: col = pula.. dilaw; titik = 'a'..'f'; – Ang mga variable ng isang pinaghihigpitang uri ay maaaring ideklara sa seksyon ng var nang hindi tumutukoy sa seksyon ng uri: – ang isang restricted type ay nagmamana ng lahat ng mga katangian ng base type kung saan ito nilikha; – ang minimum na limitasyon ay dapat palaging mas mababa sa max na limitasyon. Mga array. Ang array ay isang kumplikadong uri na isang istraktura na binubuo ng isang nakapirming bilang ng mga bahagi ng parehong uri. Ang uri ng bahagi ay tinatawag na uri ng base. Ang lahat ng mga bahagi ng array ay madaling i-order at ang access sa alinman sa mga ito ay maaaring ibigay sa pamamagitan lamang ng pagpahiwatig ng serial number nito. Paglalarawan ng array sa seksyon var ay may anyo: a: array ng t2; kung saan ang a ay ang pangalan ng array, array, ng– mga salita ng serbisyo (nangangahulugang “array ng ...”), t1 – uri ng index; t2 - uri ng bahagi (uri ng base). Tinutukoy ng bilang ng mga indeks ang laki ng array. Ang mga index ay maaaring integer (maliban sa longint), character, logical, enumeration, at mga uri ng range. Ang mga subscript ay pinaghihiwalay ng mga kuwit at nakapaloob sa mga square bracket. Ang mga bahagi ng array ay maaaring maging anumang uri maliban sa file. Halimbawa 1. Isaalang-alang ang isang one-dimensional na array C, ang mga halaga nito ay limang tunay na numero: 4.6 6.23 12 -4.8 0.7 Ang paglalarawan ng array na ito ay ang mga sumusunod: c: array ng tunay; Batay sa isang partikular na halaga ng index, maaari kang pumili ng isang partikular na bahagi ng array (halimbawa, ang ibig sabihin ng C ay ang ikatlong elemento ng array C, ibig sabihin, ang numero 12). Halimbawa 2. Isaalang-alang ang isang two-dimensional array B (matrix B), ang halaga nito ay isang talahanayan ng mga integer: Ang paglalarawan ng array na ito ay ang mga sumusunod: b ng integer; Narito ang b ay ang pangalan ng array, ang unang index ay ang numero ng hilera at kumukuha ng mga halaga mula 1 hanggang 2, ang pangalawa ay ang numero ng hanay at kumukuha ng mga halaga mula 1 hanggang 4. Batay sa mga tiyak na halaga ng index, maaari mong pumili ng isang partikular na bahagi ng array (halimbawa, ang ibig sabihin ng b ay isang elemento ng talahanayan na matatagpuan sa unang hilera at ikatlong hanay, ibig sabihin, numero -4). Ang mga index ay maaaring mga arbitrary na expression na naaayon sa uri ng index mula sa paglalarawan ng array: a: array ng tunay; a[(i+1)*2] := 24; Ang hanay ng mga operasyon sa mga elemento ng array ay ganap na tinutukoy ng uri ng mga elementong ito. Uri ng string. Ang uri ng string ay isang hanay ng mga string ng character na may di-makatwirang haba (mula sa zero hanggang sa isang ibinigay na numero). Ang mga variable ng uri ng string ay inilalarawan gamit ang isang function na salita string: b: string ; Mga Katangian: – ang halaga ng string variable ay maaaring ipasok gamit ang keyboard, itinalaga sa isang assignment operator, o basahin mula sa isang file. Sa kasong ito, ang haba ng ipinasok na string ay maaaring maging anuman (mas mababa sa tinukoy na laki, katumbas ng laki o mas malaki, sa huling kaso, ang mga karagdagang character ay itatapon); a: = 'Mga Resulta'; – pinapayagang gamitin ang concatenation operation sa assignment operator, dahil ang mga string ay maaaring dynamic na magbago ng kanilang haba: a:= a + 'calculations'; – ang maximum na haba ng isang string variable ay 255 character, ang indikasyon ng haba na ito ay maaaring tanggalin: a: string; a1: string ; Ang mga variable na a at a1 ay pareho (katumbas na paglalarawan). – Ang memorya para sa mga variable ng uri ng string ay inilalaan sa maximum, ngunit ang bahagi lamang ng memorya na aktwal na inookupahan ng mga character na string sa sandaling ito ang ginagamit. Upang ilarawan ang string variable ng haba n, n+1 byte ng memory ang ginagamit: n bytes para mag-imbak ng mga string character, n+1 byte para iimbak ang kasalukuyang haba. – Ang mga pagpapatakbo ng paghahambing ay tinukoy sa mga halaga ng mga uri ng string:< <= > >= = <>. Ang isang maikling string ay palaging mas maliit kaysa sa isang mahaba. Kung magkapareho ang haba ng mga string, ihahambing ang mga code ng character. – ang pag-access sa mga indibidwal na elemento ng isang string ay posible sa parehong paraan tulad ng pag-access sa mga elemento ng array: a, a. Ang bilang ng elemento ng linya ay ipinahiwatig sa mga square bracket. Mga pamamaraan at pag-andar na nakatuon sa pagtatrabaho sa mga string. concat (s1, s2,…)- function ng pagsasama ng string, s1, s2,... - mga linya, ang bilang ng mga linya ay maaaring maging arbitrary. Ang resulta ng function ay isang string. Kung ang resultang string ay mas mahaba sa 255 character, ang string ay puputulin sa 255 character. kopya (mga, index, bilang)– function ng pag-extract ng string mula sa source string s haba bilangin mga character, simula sa numero ng character index. tanggalin ang (mga, index, bilang)– pamamaraan para sa pag-alis mula sa string s isang substring ng haba bilangin mga character, simula sa numero ng character index. insert(s1, s2, index)– pamamaraan ng pagpasok ng hilera s1 sa linya s2, na nagsisimula sa karakter na may numero index. (mga) haba– function para sa pagtukoy ng kasalukuyang haba ng string, nagbabalik ng numero na katumbas ng kasalukuyang haba ng string. pos(s1, s2)– function ng paghahanap sa isang string s2 mga substring s1. ibinabalik ang numero ng posisyon ng unang character ng isang substring s1 nasa linya s2(o 0 kung wala ang linyang ito). val (st, x, code)– pamamaraan para sa pag-convert ng mga string s sa isang integer o tunay na variable x. Parameter code naglalaman ng 0 kung matagumpay ang conversion (at sa x inilagay ang resulta ng conversion), o ang numero ng posisyon ng linya kung saan natukoy ang maling character (sa kasong ito, ang halaga x hindi nagbabago). Pagkatugma at Uri ng Conversion. Ang Turbo Pascal ay isang nai-type na wika. Ito ay binuo batay sa mahigpit na pagsunod sa konsepto ng uri, ayon sa kung saan ang lahat ng mga operasyon na ginagamit sa wika ay tinukoy lamang sa mga operand ng mga katugmang uri. Dalawang uri ang itinuturing na magkatugma kung: – pareho sila ng parehong uri; - pareho ay totoo; - pareho ay buo; – ang isang uri ay isang uri ng hanay ng pangalawang uri; – pareho ang mga uri ng hanay ng parehong pangunahing uri; – pareho ang mga set na binubuo ng mga elemento ng parehong pangunahing uri; – pareho ang mga naka-pack na string (tinukoy sa naunang salita na naka-pack) ng parehong maximum na haba; – ang isa ay isang uri ng string, at ang isa ay isang string o uri ng character; – ang isang uri ay anumang pointer, at ang isa ay pointer sa kaugnay nitong bagay; – pareho ang mga uri ng pamamaraan na may parehong uri ng resulta (para sa isang uri ng pag-andar), bilang ng mga parameter, at uri ng magkatugmang mga parameter. Ang pagiging tugma ng uri ay lalong mahalaga sa mga operator ng pagtatalaga. Hayaang t1 ang uri ng variable at t2 ang uri ng expression, iyon ay, ang takdang t1:=t2 ay ginanap. Posible ang pagtatalagang ito sa mga sumusunod na kaso: – Ang t1 at t2 ay magkaparehong uri, at ang uri na ito ay hindi tumutukoy sa mga file, array ng mga file, mga talaan na naglalaman ng mga field ng file, o mga array ng naturang mga talaan; – Ang t1 at t2 ay magkatugmang mga uri ng ordinal, at ang halaga ng t2 ay nasa hanay ng mga posibleng halaga ng t1; - Ang t1 at t2 ay mga tunay na uri, at ang halaga ng t2 ay nasa hanay ng mga posibleng halaga ng t1; – t1 – totoong uri at t2 – uri ng integer; – t1 – linya at t2 – karakter; – t1 – string at t2 – naka-pack na string; – t1 at t2 – magkatugmang naka-pack na mga string; – Ang t1 at t2 ay magkatugma na mga hanay at lahat ng miyembro ng t2 ay kabilang sa hanay ng mga posibleng halaga ng t1; – ang t1 at t2 ay magkatugma na mga payo; – ang t1 at t2 ay magkatugmang mga uri ng pamamaraan; – ang t1 ay isang bagay at ang t2 ay ang inapo nito. Sa isang programa, ang data ng isang uri ay maaaring ma-convert sa data ng ibang uri. Ang conversion na ito ay maaaring tahasan o implicit. Ang tahasang uri ng conversion ay tumatawag sa mga espesyal na function ng conversion na ang mga argumento ay kabilang sa isang uri at ang mga halaga ay kabilang sa isa pa. Ang isang halimbawa ay ang napag-usapan na mga function ord, trunc, round, chr. Ang implicit na conversion ay posible lamang sa dalawang sitwasyon: – sa mga expression na binubuo ng tunay at integer na mga variable, ang huli ay awtomatikong na-convert sa isang tunay na uri, at ang buong expression sa kabuuan ay nakakakuha ng isang tunay na uri; – ang parehong lugar ng memorya ay halili na itinuturing bilang naglalaman ng data ng isa o ibang uri (pagsasama-sama ng data ng iba't ibang uri sa memorya). LECTURE 2 Mga pangunahing kaalaman sa programming. Panimula kay Pascal. Mga uri ng data. Mga operasyon. Alpabeto ng wikaPascal Ang anumang natural na wika ay binubuo ng mga elemento tulad ng mga simbolo, salita, parirala, at pangungusap. Ang isang programming language ay mayroon ding mga katulad na elemento: mga simbolo, salita, expression (mga parirala), operator (mga pangungusap). Ang mga salita ay nabuo mula sa isang koleksyon ng mga simbolo. Mga expression
-
ito ay mga grupo ng mga salita, at mga operator -
Ito ay mga kumbinasyon ng mga salita at ekspresyon. Ang mga simbolo ng wika ay mga elementarya na palatandaan (titik) na ginagamit sa pagbuo ng ilang teksto. Kaya, ang hanay ng mga simbolo na ito ay bumubuo ng alpabeto ng wika. Ang alpabetong Pascal ay binubuo ng: 1.malaki at maliliit na titik ng alpabetong Latin, na kinabibilangan ng mga sumusunod na character: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z - malalaking titik; A b c d e f g h i j k l m n o p q r s t u v w x y z - maliliit na titik; 2. decimal Arabic numeral: 0 1 2 3 4 5 6 7 8 9; 3. hexadecimal digit (binuo mula sa decimal digit at letra mula A hanggang F); 4. 32 malaki at maliit na titik ng alpabetong Ruso; 5. mga espesyal na karakter: Ang mga kumbinasyon ng mga espesyal na character ay maaaring bumuo ng mga tambalang character: : = takdang-aralin; < >hindi pantay; >= mas malaki sa o katumbas ng; <= меньше или
равно; Saklaw ng mga halaga; (* *) o ( ) - komento. Istraktura ng programa ng Pascal Upang ang Passal compiler ay maunawaan nang tama kung ano ang mga aksyon na inaasahan dito, ang iyong programa ay dapat na idinisenyo nang buong alinsunod sa syntax (mga tuntunin ng pagbuo ng programa) ng wikang ito. Ang anumang programa ng Pascal ay maaaring binubuo ng mga sumusunod na bloke (mga opsyonal na bahagi ay minarkahan ng mga square bracket pagkatapos nito): programa<имя_программы>; [ginagamit<имена_подключаемых_модулей>;] [ label<список_меток>;] [ const<имя_константы>
= <значение_константы>;] [ uri<имя_типа>
= <определение_типа>;] [var<имя_переменной>
: <тип_переменной>;] [ pamamaraan<имя_процедуры>
<описание_процедуры>;] [ function<имя_функции>
<описание_функции>;] magsimula (simula ng pangunahing katawan ng programa) <операторы> wakas. (* dulo ng pangunahing katawan ng programa *) Ang mga susunod na bersyon ng mga compiler ng wikang Pascal ay hindi na nangangailangan ng pagtukoy sa pangalan ng programa, iyon ay, ang linya ng programa<имя_программы>; maaaring tanggalin. Ngunit ito ay posible lamang kung ang buong programa ay nakapaloob sa isang module file. Kung ang programa ay binubuo ng ilang mga independiyenteng piraso - mga module, kung gayon ang bawat isa sa kanila ay dapat magkaroon ng isang header (program o yunit). Ang alinman sa mga nakalistang opsyonal na seksyon ay maaaring lumitaw nang higit sa isang beses sa teksto ng programa, ang kanilang pangkalahatang pagkakasunud-sunod ay maaari ding magbago, ngunit ang pangunahing tuntunin ng wikang Pascal ay dapat palaging sundin: bago gamitin ang isang bagay, dapat itong ipahayag at ilarawan. Ang mga compiler ng Pascal ay hindi nakikilala sa pagitan ng maliliit at malalaking titik at binabalewala ang mga character na whitespace, kaya ang teksto ng programa ay maaaring isaayos sa paraang gawin itong pinaka maginhawang basahin at i-debug. Mga direktiba ng compiler Ang linya na nagsisimula sa mga simbolo ($ ay hindi isang komento, ngunit isang direktiba ng compiler - isang espesyal na utos kung saan nakasalalay ang proseso ng pagsasama-sama at pagpapatupad ng programa. Isasaalang-alang namin ang mga direktiba sa mga seksyong iyon kung saan nauugnay ang mga ito "sa kahulugan". Halimbawa, ang linya ($I-,Q+) ay hindi pinapagana ang I/O validation ngunit pinapagana ang computation overflow control. Mga identifier Ang mga pangalan na ibinigay sa mga bagay ng programa (constant, uri, variable, function at procedure, at ang buong program) ay tinatawag na mga identifier. Maaari lamang silang binubuo ng mga numero, mga letrang Latin at ang "_" (underscore) sign. Gayunpaman, ang isang numero ay hindi maaaring magsimula ng isang pangalan. Ang mga identifier ay maaaring maging anumang haba, ngunit kung ang dalawang pangalan ay may parehong unang 63 character, ang mga pangalan ay itinuturing na magkapareho. Maaari mong bigyan ng anumang pangalan ang mga object ng iyong program, ngunit dapat mong tiyakin na iba ang mga ito sa mga nakareserbang salita na ginamit ni Pascal, dahil hindi pa rin tatanggap ang compiler ng mga variable na may mga "banyagang" pangalan. Narito ang isang listahan ng mga pinakakaraniwang nakalaan na salita: pagpapatupad ng array shl string ng interface ng kaso const label noon ginagamit ng file pointer malayong pamamaraan var para sa programa habang forward record na may function ulitin xor Mga variable at uri ng data Ang variable ay isang object ng program na maaaring magbago ang value habang tumatakbo ang program. Ang uri ng data ay isang katangian ng hanay ng mga halaga na maaaring kunin ng mga variable na kabilang sa uri ng data na iyon. Ang lahat ng mga variable na ginamit sa programa ay dapat na inilarawan sa isang espesyal na seksyon ng var gamit ang sumusunod na template: var<имя_переменной_1> [, <имя_переменной_2,
_>] : <имя_типа_1>; <имя_переменной_3>
[, <имя_переменной_4, _>] : <имя_типа_2>; Ang wikang Pascal ay may malaking hanay ng iba't ibang uri ng data, ngunit ngayon ay iilan lamang sa mga ito ang ipapahiwatig namin. Pag-uusapan pa natin ang lahat ng uri ng data. Mga Constant Ang isang pare-pareho ay isang bagay na ang halaga ay kilala bago magsimulang tumakbo ang programa. Ang mga constant ay kinakailangan para sa disenyo ng mga visual na programa, ay kailangang-kailangan kapag gumagamit ng paulit-ulit na paulit-ulit na mga halaga sa teksto ng isang programa, at maginhawa kung kinakailangan upang baguhin ang mga halagang ito sa buong programa nang sabay-sabay. Mayroong tatlong uri ng mga constant sa Pascal: Mga hindi pinangalanang constant (mga digit at numero, simbolo at string, set); Pinangalanang untyped constants; Pinangalanang mga na-type na constant. Mga hindi pinangalanang constant
Ang mga hindi pinangalanang constant ay walang mga pangalan at samakatuwid ay hindi kailangang ideklara. Awtomatikong natutukoy ang uri ng hindi pinangalanang constant, bilang default: Anumang pagkakasunud-sunod ng mga numero (marahil ay pinangungunahan ng isang "-" o "+" na senyales, o pinaghiwa-hiwalay ng isang solong tuldok) ay itinuturing ng compiler bilang isang walang pangalan na pare-pareho - isang numero (integer o tunay); Anumang pagkakasunod-sunod ng mga character na nakapaloob sa mga kudlit ay itinuturing bilang isang hindi pinangalanang constant - isang string; Anumang pagkakasunud-sunod ng mga integer o simbolo na pinaghihiwalay ng mga kuwit, na naka-frame sa pamamagitan ng mga square bracket, ay itinuturing bilang isang hindi pinangalanang constant - isang set. Bilang karagdagan, mayroong dalawang espesyal na constant na totoo at mali na nauugnay sa uri ng data ng Boolean. Kasama sa mga halimbawa ng paggamit ng mga hindi pinangalanang constant ang mga sumusunod na operator: real2:= 12.075 + x; string4: = "abc" + string44; set5:= * set55; boolean6:= totoo; Mga Hindi Na-type na Constant
Ang pinangalanang mga constant, gaya ng ipinahihiwatig ng kanilang pangalan, ay dapat magkaroon ng pangalan. Samakatuwid, ang mga pangalang ito ay dapat iulat sa compiler, iyon ay, inilarawan sa isang espesyal na seksyon ng const. Kung hindi mo tinukoy ang uri ng isang pare-pareho, pagkatapos ay sa pamamagitan ng hitsura nito ang compiler mismo ay matukoy kung aling (base) na uri ito dapat italaga. Maaaring gamitin ang anumang pare-parehong inilarawan na kapag nagdedeklara ng iba pang mga constant, variable at uri ng data. Narito ang ilang halimbawa ng paglalarawan ng mga hindi na-type na pinangalanang constant: Mga na-type na Constant
Ang mga na-type na pinangalanang constant ay mga variable(!) na may paunang halaga na alam na sa oras na magsimula ang programa. Samakatuwid, una, ang mga na-type na constant ay hindi maaaring gamitin upang tukuyin ang iba pang mga constant, mga uri ng data at mga variable, at pangalawa, ang kanilang mga halaga ay maaaring mabago habang tumatakbo ang programa. Ang mga nai-type na constant ay inilalarawan gamit ang sumusunod na template: const<имя_константы> : <тип_константы>
= <начальное_значение>; Ipinapakita ng mga halimbawa sa ibaba kung paano ito gawin: const n: integer = -10; b: boolean = totoo; Magbibigay kami ng mga halimbawa ng mga na-type na constant ng iba pang mga uri habang pinag-aaralan namin ang mga kaukulang uri ng data. Mga uri ng data ng Pascal Ang mga compiler ng Pascal ay nangangailangan na ang impormasyon tungkol sa dami ng memorya na kinakailangan upang magpatakbo ng isang programa ay ibigay bago ito tumakbo. Upang gawin ito, sa seksyon ng paglalarawan ng variable (var), kailangan mong ilista ang lahat ng mga variable na ginamit sa programa. Bilang karagdagan, kailangan mo ring sabihin sa compiler kung gaano karaming memorya ang sasakupin ng bawat isa sa mga variable na ito. Ang lahat ng ito ay maaaring ipaalam sa programa sa pamamagitan lamang ng pagpahiwatig ng uri ng hinaharap na variable. Ang pagkakaroon ng impormasyon tungkol sa uri ng isang variable, ang compiler ay "naiintindihan" kung gaano karaming mga byte ang kailangang ilaan para dito, kung anong mga aksyon ang maaaring isagawa kasama nito, at sa kung anong mga konstruksyon ang maaari itong lumahok. Para sa kaginhawahan ng mga programmer, ang Pascal ay may maraming mga karaniwang uri ng data at, bilang karagdagan, ang kakayahang lumikha ng mga bagong uri ng data batay sa mga umiiral na (karaniwan o muling tinukoy ng programmer mismo), na tinatawag na constructed. Ang paghahati sa basic at constructed na mga uri ng data sa Pascal ay ipinapakita sa talahanayan: Ordinal (discrete) na mga uri ng data Mga uri ng data ng address Mga Uri ng Structured Data Mga uri ng data ng aritmetika Pangunahing Uri ng Data Lohikal Simboliko totoo Netipizi na-index na index Mga uri ng binuo Nakalista linggo = (su, mo, tu, kami, ika, fr,sa); Nag-type ng pointer Array String string record record Pamamaraan Bagay Interval (saklaw) Mga Uri ng Data na Binuo ng Programmer Mga uri ng ordinal na data
Kabilang sa mga pangunahing uri ng data, namumukod-tangi ang mga uri ng ordinal. Maaaring bigyang-katwiran ang pangalang ito sa dalawang paraan: 1. Ang bawat elemento ng isang uri ng ordinal ay maaaring iugnay sa isang natatanging (ordinal) na numero. Ang pagbilang ng mga halaga ay nagsisimula sa zero. Ang exception ay ang shortint, integer at longint na mga uri ng data. Ang kanilang pag-numero ay tumutugma sa mga halaga ng mga elemento. 2. Bilang karagdagan, sa mga elemento ng anumang uri ng ordinal, ang isang pagkakasunud-sunod ay tinukoy (sa matematikal na kahulugan ng salita), na direktang nakasalalay sa pagnunumero. Kaya, para sa alinmang dalawang elemento ng isang uri ng ordinal, masasabi nang eksakto kung alin sa mga ito ang mas maliit at alin ang mas malaki. Mga karaniwang gawain na humahawak ng mga ordinal na uri ng data
Ang mga sumusunod na function at pamamaraan ay tinukoy lamang para sa mga uri ng ordinal: 1. Ang ord(x) function ay nagbabalik ng ordinal na numero ng halaga ng variable na x (na may kaugnayan sa uri kung saan nabibilang ang variable na x). 2.Ibinabalik ng function na pred(x) ang value na sinusundan ng x (hindi naaangkop sa unang elemento ng uri). 3. Ibinabalik ng function na succ(x) ang value kasunod ng x (hindi naaangkop sa huling elemento ng uri). 4. Ibinabalik ng procedure inc(x) ang value kasunod ng x (para sa mga arithmetic data type na ito ay katumbas ng operator x:=x+1). 5. Ibinabalik ng procedure inc(x,k) ang kth value kasunod ng x (para sa mga arithmetic data type na ito ay katumbas ng operator x:=x+k). 6. Ibinabalik ng procedure dec(x) ang value na nauuna sa x (para sa mga uri ng data ng arithmetic ito ay katumbas ng operator x:=x-1). 7. Ibinabalik ng procedure dec(x,k) ang k-e value na nauuna sa x (para sa mga arithmetic data type na ito ay katumbas ng operator x:=x-k). Sa unang tingin, lumalabas na ang resulta ng paggamit ng inc(x) procedure ay eksaktong kapareho ng resulta ng paggamit ng succ(x) function. Gayunpaman, lumilitaw ang pagkakaiba sa pagitan ng mga ito sa mga hangganan ng pinapayagang hanay. Ang succ(x) function ay hindi naaangkop sa maximum na elemento ng isang uri, ngunit ang inc(x) na pamamaraan ay hindi gagawa ng anumang error, ngunit, sa pagkilos ayon sa mga panuntunan ng machine karagdagan, ay idaragdag ang susunod sa element number . Ang numero, siyempre, ay lalampas sa hanay at, dahil sa pagputol, ay magiging bilang ng pinakamababang halaga ng hanay. Lumalabas na ang mga pamamaraan inc() at dec() ay nakikita ang anumang uri ng ordinal na parang "nakasara sa isang singsing": kaagad pagkatapos ng huling halaga ay dumating muli ang unang halaga. Ipaliwanag natin ang lahat ng nasabi nang may halimbawa. Para sa uri ng data uri ng labing-anim = 0..15; Ang pagsubok na magdagdag ng 1 sa numerong 15 ay magbibigay ng sumusunod na resulta: Ang paunang yunit ay puputulin, at samakatuwid ay lumalabas na inc(15)=0. Ang isang katulad na sitwasyon sa mas mababang limitasyon ng pinahihintulutang hanay ng isang arbitrary na ordinal na uri ng data ay sinusunod para sa pamamaraan dec(x) at ang function na pred(x): dec(min_element)= max_element Mga uri ng data na nauugnay sa ordinal
1. Ang boolean type ay may dalawang value: false at true, at ang mga sumusunod na equalities ay may hawak para sa kanila: ord(false)=0, ord(true)=1, false pred(true)=false, succ(false)=true, inc(true)=false, inc(false)=true, dec(true)=false, dec(false)=true. 2. Ang uri ng character na char ay naglalaman ng 256 pinahabang ASCII character (halimbawa, "a", "b", "i", "7", "#"). Ang numero ng character na ibinalik ng ord() function ay kapareho ng numero ng character sa talahanayan ng ASCII. 3. Ibuod natin ang mga uri ng data ng integer sa isang talahanayan: Uri ng data Bilang ng mga byte Saklaw 2147483648..2147483647 4. Ang mga enumerated na uri ng data ay tinukoy sa seksyon ng uri sa pamamagitan ng tahasang paglilista ng mga elemento ng mga ito. Halimbawa: uri ng linggo =(araw,mon,Martes,wed,thu,fri,sat) Tandaan na para sa uri ng data na ito: inc(sat) = araw, dec(sun) = sat. 5. Ang mga uri ng data ng pagitan ay tinutukoy lamang ng mga hangganan ng kanilang hanay. Halimbawa: uri ng buwan = 1..12; budni = mon..fri; 6. Ang mga uri ng data na binuo ng programmer ay inilarawan sa seksyon ng uri ayon sa sumusunod na pattern: uri<имя_типа> =
<описание_типа>; Halimbawa: type lat_bukvy = "a".."z","A".."Z"; Ang mga pangunahing uri ng data ay karaniwan, kaya hindi na kailangang ilarawan ang mga ito sa seksyon ng uri. Gayunpaman, kung ninanais, maaari rin itong gawin, halimbawa, sa pamamagitan ng pagbibigay ng mahahabang kahulugan ng mga maikling pangalan. Sabihin natin sa pamamagitan ng pagpapakilala ng bagong uri ng data uri int = integer; Maaari mong paikliin ng kaunti ang teksto ng programa. Mga totoong uri ng data
Alalahanin na ang mga uri ng data na ito ay arithmetic, hindi ordinal. Uri ng data Bilang ng mga byte Saklaw (ganap na halaga) 1.5*10-45..3.4*1038 2.9*10-39..1.7*1038 5.0*10-324..1.7*10308 3.4*10-4932..1.1*104932 Mga uri ng data na binuo
Isasaalang-alang namin ang mga uri ng data na ito (kasama ang mga pagpapatakbo na tinukoy para sa kanila) nang higit pa sa kurso ng ilang mga lektura. Mga Operasyon at Ekspresyon Mga operasyon sa aritmetika
Pag-usapan natin ang tungkol sa mga pagpapatakbo - karaniwang mga pagkilos na pinapayagan para sa mga variable ng isa o isa pang pangunahing uri ng data. Ang magiging batayan ay arithmetic at logical operations. Tandaan: Ang lahat ng mga operator na nakalista sa ibaba (maliban sa unary "-" at hindi) ay nangangailangan ng dalawang operand. 1. Ang mga lohikal na operasyon (at - lohikal AT, o - lohikal O, hindi - lohikal na HINDI, xor - eksklusibo O) ay naaangkop lamang sa mga halaga ng uri ng boolean. Nagreresulta din ang mga ito sa mga boolean na halaga. Narito ang mga talahanayan ng mga halaga para sa mga operasyong ito: totoo mali totoo maling mali mali totoo mali mali 2. Mga operasyon sa paghahambing (=,<>, >, <, <=, >=) nalalapat sa lahat ng pangunahing uri. Ang kanilang mga resulta ay mga boolean value din. 3. Ang mga pagpapatakbo ng integer arithmetic ay naaangkop lamang sa mga uri ng integer. Ang kanilang resulta ay isang integer na ang uri ay nakasalalay sa mga uri ng mga operand. a div b - ganap na paghahati ng a sa b (marahil hindi na kailangang ipaalala sa iyo na ipinagbabawal ang paghahati sa 0, kaya sa mga ganitong kaso ang operasyon ay bumubuo ng isang error). Ang resulta ay isang uri ng data na karaniwan sa mga uri kung saan nabibilang ang mga operand. Halimbawa, (shortint div byte = integer). Ito ay maaaring ipaliwanag sa ganitong paraan: ang integer ay isang minimal na uri kung saan ang parehong byte at shortint ay mga subset. a mod b - kunin ang natitira kapag hinahati ang a sa b. Ang uri ng resulta, tulad ng sa nakaraang kaso, ay tinutukoy ng mga uri ng mga operand, at ang 0 ay isang ilegal na halaga para sa b. Hindi tulad ng mathematical operation mod, ang resulta nito ay palaging isang di-negatibong numero, ang tanda ng resulta ng "programmer" operation mod ay tinutukoy ng sign ng unang operand nito. Kaya, kung sa matematika (-2 mod 5) = 3, mayroon tayong (-2 mod 5) = -2. a shl k - inililipat ang halaga ng a by k bits sa kaliwa (ito ay katumbas ng pagpaparami ng value ng variable a sa 2k). Ang resulta ng operasyon ay magiging kapareho ng uri ng (mga) unang operand nito. a shr k - inililipat ang halaga ng a by k bits sa kanan (ito ay katumbas ng paghahati ng halaga ng variable a ng 2k nang buo). Ang resulta ng operasyon ay magiging kapareho ng uri ng (mga) unang operand nito. at, o, hindi, xor - binary arithmetic operations na gumagana sa mga bits ng binary representation ng integers, ayon sa parehong mga panuntunan tulad ng kaukulang logical operations. 4. Ang mga pangkalahatang pagpapatakbo ng arithmetic (+, -, *, /) ay nalalapat sa lahat ng uri ng arithmetic. Ang kanilang resulta ay nabibilang sa isang uri ng data na karaniwan sa parehong mga operand (ang tanging pagbubukod ay ang fractional division operation /, ang resulta nito ay palaging isang tunay na uri ng data). Iba pang mga operasyon
Mayroong iba pang mga operasyon na tiyak sa mga halaga ng ilan sa mga karaniwang uri ng data ng Pascal. Isasaalang-alang namin ang mga operasyong ito sa naaangkop na mga seksyon: #, in, +, *, : tingnan ang lecture 5 “Mga Simbolo. Mga linya. maraming tao" @, ^: tingnan ang lecture 7 "Mga Address at pointer" Mga karaniwang function ng arithmetic
Kasama rin sa mga operasyon ng aritmetika ang mga karaniwang function ng arithmetic. Nagbibigay kami ng isang listahan ng mga ito na may maikling paglalarawan sa talahanayan. Function Paglalarawan Uri ng argumento Uri ng resulta Ganap na halaga (modulus) ng isang numero Arithmetic Pareho sa uri ng argumento Arctangent (sa radians) Arithmetic totoo Cosine (sa radians) Arithmetic totoo Exponent (hal) Arithmetic totoo Pagkuha ng fractional na bahagi ng isang numero Arithmetic totoo Kinukuha ang buong bahagi ng isang numero Arithmetic totoo Natural logarithm (base e) Arithmetic totoo Sinusuri kung ang isang numero ay kakaiba Kahulugan ng numero totoo Bilugan sa pinakamalapit na integer Arithmetic Round down - sa pinakamalapit na mas maliit na integer Arithmetic Sine (sa radians) Arithmetic totoo Pag-squaring Arithmetic totoo Square Root Arithmetic totoo Arithmetic Expressions
Ang lahat ng mga pagpapatakbo ng aritmetika ay maaaring pagsamahin sa bawat isa - siyempre, isinasaalang-alang ang mga uri ng data na pinapayagan para sa kanilang mga operand. Ang mga operand ng anumang operasyon ay maaaring mga variable, constants, function call, o expression na binuo batay sa iba pang mga operasyon. Ang lahat ng magkasama ay tinatawag na isang expression. Mga halimbawa ng mga expression na aritmetika: (x<0) and (y>0) - isang expression na ang resulta ay uri ng boolean; z shl abs(k) - ang pangalawang operand ay isang tawag sa karaniwang function; (x mod k) + min(a,b) + trunc(z) - isang kumbinasyon ng mga arithmetic operations at function calls; kakaiba(round(x/abs(x))) - "multi-story" expression. Pagkakasunud-sunod ng pagkalkula
Kung ang expression ay naglalaman ng mga panaklong, kung gayon ang mga kalkulasyon ay isinasagawa sa sumusunod na pagkakasunud-sunod: mas maliit ang lalim ng nesting ng mga panaklong, mas huli ang operasyon na nakapaloob sa mga ito ay kinakalkula. Kung walang mga panaklong, kung gayon ang mga halaga ng mga operasyon na may mas mataas na priyoridad ay unang kinakalkula, pagkatapos ay ang mga may mas mababang priyoridad. Ang ilang magkakasunod na operasyon ng parehong priyoridad ay kinakalkula sa pagkakasunud-sunod mula kaliwa hanggang kanan. Talahanayan 2.1. Mga Priyoridad (para sa lahat) mga pagpapatakbo ng Pascal ... Halos lahat ng uri ng data ng integer ay . Ang mga uri ng data na ito ay kumakatawan sa mga integer sa loob ng isang partikular na hanay. Ang eksaktong mga pangalan ng mga uri ng integer at mga hanay ng mga halaga ay nakasalalay sa partikular na programming language, ang compiler, at ang compilation mode. Maaari kang matuto nang higit pa tungkol dito sa dokumentasyon ng compiler. Halimbawa, uri ng data Integer Halimbawa, uri ng data sa Delphi mayroon itong hanay na -2147483648…2147483647, habang sa Turbo Pascal ang uri ng data Halimbawa, uri ng data kumakatawan sa mga numero sa hanay -35768…32767. Sa Libreng Pascal, ang hanay ng mga halaga ng uri tinutukoy ng napiling mode. Dahil ginagamit ni Lazarus ang Free Pascal compiler, lahat ng sinabi tungkol sa mga uri ng data na may kaugnayan sa Free Pascal ay totoo din para kay Lazarus. Kaya, ang mga uri ng data ng integer ng Libreng Pascal ay nakalista sa Talahanayan 13.1. QWord ay hindi! Nangangahulugan ito na hindi mo magagamit ang mga ito, halimbawa, para sa mga variable ng index sa mga loop. Gayunpaman, ipinakita ko ang mga ito dito upang hindi ilarawan ang mga ito nang hiwalay sa hinaharap at upang mangolekta ng lahat ng Libreng Pascal integer na uri sa isang lugar. Kung hindi mo maintindihan ang ilang mga salita, huwag maalarma. Sa takdang panahon sasabihin ko sa iyo ang lahat nang mas detalyado. At ngayon ng ilang mga paliwanag tungkol sa talahanayan. Sa column URI At ngayon ng ilang mga paliwanag tungkol sa talahanayan. ibinibigay ang mga identifier ng uri ng data (mga keyword na nagpapahiwatig sa compiler kung anong uri ang pag-aari ng isang partikular na data). Matututuhan mo kung paano gamitin ang mga identifier na ito sa mga sumusunod na aralin. ay nagpapahiwatig ng laki na ang uri ng data ay sumasakop sa memorya ng computer. Halimbawa, ang isang positibong integer ay maaaring katawanin ng iba't ibang uri: Saklaw ng mga halaga,
Smallint, Depende sa compilation mode atbp. Gayunpaman, isang numero tulad ng Depende sa compilation mode ay sasakupin ang 4 na byte sa memorya, habang ang isang numero ay tulad ng Saklaw ng mga halaga– 1 byte lang. Samakatuwid, kung alam mong sigurado na ang numerong pinagtatrabahuhan mo ay hindi kailanman kukuha ng halagang higit sa 255, mas mabuting tukuyin ito bilang isang uri Saklaw ng mga halaga, dahil makakatipid ito ng espasyo sa memorya ng iyong computer. Bagaman hindi lahat ay napakasimple dito (ang mga nuances ng pamamahagi ng memorya at iba pang mga mapagkukunan ng computer ay lampas sa saklaw). At ngayon ng ilang mga paliwanag tungkol sa talahanayan. RANGE tumutukoy sa hanay ng mga halaga kung saan gumagana ang uri ng data. Halimbawa, isang numero tulad ng Saklaw ng mga halaga maaaring tumagal ng mga halaga mula 0 hanggang 255. Ngayon para sa pagsasanay. Sumulat tayo ng isang programa na nagpapakita ng mga saklaw ng mga halaga ng lahat ng mga uri ng data ng integer. Ang source code para sa program na ito ay ibinigay sa ibaba: Listahan 13.1. Isang programa para sa pagpapakita ng mga hanay ng mga integer. programa td; ($mode objfpc)($H+) ay gumagamit ng ($IFDEF UNIX)($IFDEF UseCThreads) cthreads, ($ENDIF)($ENDIF) Mga Klase ( maaari kang magdagdag ng mga unit pagkatapos nito ); begin Writeln("Byte: ", Low(Byte), "..", High(Byte)); Writeln("Shortint: ", Low(Shortint), "..", High(Shortint)); Writeln("Smallint: ", Low(Smallint), "..", High(Smallint)); Writeln("Word: ", Low(Word), "..", High(Word)); Writeln("Integer: ", Low(Integer), "..", High(Integer)); Writeln("Cardinal: ", Mababa(Cardinal), "..", Mataas(Cardinal)); Writeln("Longint: ", Low(Longint), "..", High(Longint)); Mga uri sa Libreng Pascal Writeln("Longword: ", Low(Longword), "..", High(Longword)); Writeln("Int64: ", Mababa(Int64), "..", Mataas(Int64)); Writeln("QWord: ", Mababa(QWord), "..", Mataas(QWord)); 10 Readln; wakas. Karaniwang pag-andar Takdang-Aralin: Lumikha ng isang programa na nagpapakita ng mga saklaw ng mga halaga ng integer (Listing 13.1). I-compile ang program at patakbuhin ito. Siguraduhin na ang mga halagang ito ay tumutugma sa mga ipinapakita sa Talahanayan 13.1. Sa source code ng program, hanapin ang linyang nagtatakda ng compilation mode: ($mode objfpc)($H+) Sa linyang ito, sa halip na salita objfpc isulat ang salita tp. Iyon ay, ang huling linya ay dapat magmukhang ganito: ($mode tp)($H+) Ilunsad ang programa. Tingnan ang hanay ng mga halaga ng uri Halimbawa, uri ng data. Gumawa ng mga konklusyon. Matutong mag-isip tulad ng isang programmer, iyon ay, lohikal. Walang sinuman ang ngumunguya sa lahat para sa iyo hanggang sa pagreretiro, tulad ng ginagawa ko ngayon. Kailangan mong masanay na mag-isip para sa iyong sarili. Kung hindi, mapapasama ka sa "prinsipyo sa pag-aaral ng unggoy," at pagkatapos ay ang iyong mga pagkakataon na maging isang mahusay na programmer ay malapit sa zero. Upang matulungan kang hindi dumausdos sa antas ng "cramming", pana-panahong mag-iiwan ako ng mga puwang sa iyong pag-aaral upang subukan mong malaman ang ilang mga bagay sa iyong sarili. Mas mabuti kung ikaw mismo ang mag-isip nito maling desisyon, ikaw mismo ang makakahanap ng pagkakamali at ikaw mismo ang magtatama nito, sa halip na palaging gumamit ng mga tamang solusyon ng ibang tao at hangal na kopyahin ang mga ito. Ang isang simpleng uri ay tumutukoy sa isang nakaayos na hanay ng mga halaga ng parameter. Ang Turbo Pascal ay may mga sumusunod na grupo ng mga simpleng uri: Ang lahat ng mga simpleng uri, maliban sa mga tunay na uri, ay tinatawag na mga uri ng ordinal. Para sa dami ng mga uri ng ordinal, ang mga karaniwang pamamaraan at paggana ay tinukoy: Dis, Inc, Ord, Pred, Succ (tingnan ang seksyon 13.1). Hindi tulad ng Pascal, na tumutukoy sa isang solong uri ng integer, Integer, ang Turbo Pascal ay may limang karaniwang uri ng integer: Shortint, Integer, Longint, Byte, Word. Ang mga katangian ng mga uri na ito ay ibinibigay sa talahanayan. 2. Talahanayan 2. Mga uri ng data ng integer Ang karaniwang uri ng Boolean (laki - 1 byte) ay isang uri ng data, anumang elemento na maaaring tumagal lamang ng dalawang halaga: True at False. Sa kasong ito, ang mga sumusunod na kondisyon ay wasto: Nagdagdag ang Turbo Pascal 7.0 ng tatlo pang lohikal na uri na ByteBool (laki - 1 byte), WordBool (laki - 2 byte) at LongBool (laki - 4 byte). Ipinakilala sila para sa pag-iisa sa iba pang mga programming language at sa kapaligiran ng Windows. Ang kanilang pagkakaiba mula sa karaniwang uri ng Boolean ay ang aktwal na halaga ng parameter ng ganitong uri, na tumutugma sa halagang True. Para sa lahat ng lohikal na uri, ang value na False ay tumutugma sa numero 0, na nakasulat sa katumbas na bilang ng mga byte. Ang value na True para sa Boolean type ay tumutugma sa numero 1 na nakasulat sa byte nito, at para sa iba pang mga uri ang value na True ay tumutugma sa anumang numero maliban sa zero (bagaman ang Ord function sa kasong ito ay nagbibigay ng value 1). Ang karaniwang uri ng character na Char ay tumutukoy sa isang buong hanay ng mga ASCII na character. Ang Ord function mula sa isang halaga ng uri ng Char ay nagbibigay ng code ng kaukulang karakter. Ang mga halaga ng uri ng character ay inihambing ayon sa kanilang mga code. Ang isang enumerated na uri ay hindi karaniwan at tinutukoy ng isang hanay ng mga identifier na maaaring tumugma sa mga value ng parameter. Ang listahan ng mga identifier ay ipinahiwatig sa mga panaklong, ang mga identifier ay pinaghihiwalay ng mga kuwit: Mahalaga sa kung anong pagkakasunud-sunod ang mga identifier ay nakalista kapag tinutukoy ang isang uri, dahil ang unang identifier ay itinalaga ang serial number 0, ang pangalawa - 1, atbp. Ang parehong identifier ay maaaring gamitin sa kahulugan ng isang enumerated type lamang. Ang function ng Ord mula sa isang halaga ng isang enumerated na uri ay nagbibigay ng ordinal na numero ng halaga nito. Halimbawa. Enumerated type. uri ng Operat = (Plus, Minus, Mult, Divide); Ang isang boolean na uri ay isang espesyal na kaso ng isang enumerated na uri: i-type ang Boolean = (Mali, Tama); Sa anumang uri ng ordinal, maaari kang pumili ng subset ng mga halaga, na tinukoy ng minimum at maximum na mga halaga, na kinabibilangan ng lahat ng mga halaga ng orihinal na uri na nasa loob ng mga hangganang ito, kabilang ang mga hangganan mismo. Tinutukoy ng subset na ito ang isang uri ng hanay. Tinukoy ang uri ng hanay sa pamamagitan ng pagtukoy sa minimum at maximum na mga halaga, na pinaghihiwalay ng dalawang tuldok: uri = . . ; Ang pinakamababang halaga kapag tinutukoy ang ganitong uri ay hindi dapat mas malaki kaysa sa maximum. Halimbawa. Kahulugan ng mga uri ng saklaw. uri Hindi tulad ng pamantayan ng wikang Pascal, kung saan isang tunay na uri lamang ang tinutukoy na Real, ang Turbo Pascal ay may limang karaniwang mga tunay na uri: Real, Single, Double, Extended, Comp. Para sa mga katangian ng mga ganitong uri, tingnan ang talahanayan. 3. Talahanayan 3. Mga totoong uri ng data Ang uri ng Comp ay talagang isang pinahabang uri ng integer na hanay, ngunit hindi itinuturing na isang uri ng ordinal. Ang mga uri ng Single, Double, Extended at Comp ay magagamit lamang sa mga programa kung mayroong arithmetic coprocessor o kapag pinagana ang coprocessor emulator (tingnan ang mga talata 17.5.8 at 17.7.1). Ang konsepto ng data ay isa sa mga susi sa programming, at sa computer science sa pangkalahatan. Sa halos pagsasalita, ang data sa computer science ay impormasyon na nasa isang estado ng pag-iimbak, pagpoproseso o paghahatid sa isang tiyak na tagal ng panahon. Sa Turing machine, ang impormasyon ay may isang uri, at ito naman ay depende sa uri ng impormasyon. Ang mga uri ng data sa Pascal ay tumutukoy sa mga posibleng halaga ng mga variable, constants, expression, at function. Ang mga ito ay built-in at custom. Ang mga built-in na uri ay unang nasa programming language, at ang mga custom na uri ay nilikha ng programmer. Ayon sa paraan ng pagtatanghal at pagproseso, ang mga uri ng data ay: Isasaalang-alang lamang ng artikulong ito ang mga pinakasimpleng uri ng data, dahil sa mga unang yugto ng pagsasanay, magiging mas madali para sa iyong programa na gawin nang walang, halimbawa, mga file at talaan kaysa walang mga variable na integer o string. Kabilang dito ang ilang uri ng integer, na naiiba sa hanay ng mga halaga, ang bilang ng mga byte na inilalaan para sa pag-iimbak ng mga ito, at ang salita kung saan ipinahayag ang uri. Maaari kang magdeklara ng integer variable sa seksyong Var, halimbawa: Ang lahat ng aritmetika at lohikal na operasyon ay maaaring isagawa sa mga variable sa kategoryang ito maliban sa dibisyon (/), na nangangailangan ng isang tunay na uri. Ang ilang karaniwang mga pag-andar at pamamaraan ay maaari ding ilapat. Sa Pascal mayroong mga sumusunod na tunay na uri ng data: Higit pang mga operasyon at function ang maaaring gawin sa mga ito kaysa sa mga integer. Halimbawa, ang mga function na ito ay nagbabalik ng isang tunay na resulta: kasalanan(x) – sine; cos(x) – cosine; arctan(x) – arctangent; ln(x) – natural logarithm; sqrt(x) – square root; exp(x) – exponent; Ang isang variable ng isang Boolean data type ay maaari lamang tumagal ng dalawang halaga: true at false. Dito, ang true ay tumutugma sa value 1, at false ay tumutugma sa zero. Maaari kang magdeklara ng Boolean variable tulad nito: Maaaring isagawa ang paghahambing at lohikal na mga operasyon sa data ng ganitong uri: hindi, at, o, xor. Ang uri ng data ng character ay isang koleksyon ng mga character na ginagamit sa isang partikular na computer. Ang isang variable ng ganitong uri ay tumatagal ng halaga ng isa sa mga character na ito at sumasakop ng 1 byte sa memorya ng computer. salita Char tumutukoy sa isang halaga ng ganitong uri. Mayroong ilang mga paraan upang magsulat ng isang variable ng character (o pare-pareho): Ang mga relational na operasyon at ang mga sumusunod na function ay naaangkop sa mga halaga ng isang uri ng data ng character: Succ(x)- ibinabalik ang susunod na karakter; Pred(x)- ibinabalik ang nakaraang karakter; Ord(x)- ibinabalik ang halaga ng code ng character; Chr(x)- ibinabalik ang halaga ng isang simbolo sa pamamagitan ng code nito; UpCase(x)- kino-convert ang mga titik mula sa pagitan ng 'a'..'z' sa uppercase. Upang gumana nang epektibo sa uri ng character, inirerekomenda ko ang paggamit ng . Ang isang string sa Pascal ay isang pagkakasunod-sunod ng mga character na nakapaloob sa mga kudlit, at tinutukoy ng salita String. Ang bilang ng mga character (haba ng linya) ay hindi dapat lumampas sa 255. Kung ang haba ng linya ay hindi tinukoy, awtomatiko itong matutukoy na 255 character. Ang pangkalahatang anyo ng isang string variable na deklarasyon ay ganito ang hitsura: Var<имя_переменной>:string[<длина строки>]; Ang bawat karakter sa isang linya ay may sariling index (numero). Ang index ng unang byte ay 0, ngunit hindi nito iniimbak ang unang character, ngunit ang haba ng buong string, na nangangahulugan na ang isang variable ng ganitong uri ay sasakupin ng 1 byte nang higit pa sa bilang ng mga variable sa loob nito. Ang bilang ng unang karakter ay 1, halimbawa, kung mayroon tayong string na S=‘stroka’, kung gayon S=s;. Sa isa sa mga sumusunod na aralin, ang uri ng data ng string ay tatalakayin nang mas detalyado. Ang isang enumerated na uri ng data ay kumakatawan sa isang limitadong bilang ng mga identifier. Ang mga identifier na ito ay nakapaloob sa mga panaklong at pinaghihiwalay ng mga kuwit. Uri ng Araw=(Lunes, Martes, Miyerkules, Huwebes, Biyernes, Sabado, Linggo); Maaari lamang kunin ng Variable A ang mga halagang tinukoy sa seksyong Uri. Maaari ka ring magdeklara ng variable ng enumerated type sa seksyong Var: Var A: (Lunes, Martes); Ang mga relational na operasyon ay naaangkop sa ganitong uri, at ito ay paunang natukoy sa Lunes na iyon Kapag kinakailangan upang tukuyin ang isang hanay ng mga halaga, pagkatapos ay sa ganitong mga sitwasyon ang uri ng data ng pagitan ay ginagamit. Ang konstruksiyon na ginamit para sa deklarasyon ay m..n, Saan m ay ang pinakamababang (paunang) halaga, at n– maximum (pangwakas); dito ang m at n ay mga constant, na maaaring integer, character, enumeration o boolean type. Ang mga halaga ng uri ng agwat ay maaaring ilarawan sa parehong seksyon ng mga uri at sa seksyon ng paglalarawan ng variable. Pangkalahatang view: URI<имя_типа> = <мин. значение>..<макс. значение>;
Mga Pangunahing Kaalaman sa Programming
Ang bawat propesyonal ay dating isang tsarera. Tiyak na pamilyar ka sa estado kapag "hindi mo alam kung paano magsimulang mag-isip upang makabuo ng ganoong bagay." Marahil ay nakatagpo ka ng isang sitwasyon kung saan hindi mo alam kung saan magsisimula. Ang aklat na ito ay tiyak na nakatuon sa mga taong gustong maging programmer, ngunit walang ideya kung paano sisimulan ang landas na ito.Talahanayan 13.1. Libreng Mga Uri ng Data ng Pascal Integer (Lazarus).
Uri
Sukat, byte
Saklaw ng mga halaga
1
0…255
Byte
1
-128…127
Shortint
2
-35768…32767
Smallint
2
0…65535
Halimbawa, uri ng data
salita
2 o 4
Depende sa compilation mode
4
0…4294967295
Cardinal
4
-2147483648…2147483647
Longint
4
0...4294967295
Mahabang salita
8
-9223372036854775808...9223372036854775807
Int64
8
0...18446744073709551615
TANDAAN Mahabang salita Mga uri sa Libreng Pascal Int64 At
178
352783.2. Mga simpleng uri ng data sa Turbo Pascal 7
3.2.1. Mga uri ng integer
Talahanayan 13.1. Libreng Mga Uri ng Data ng Pascal Integer (Lazarus).
Saklaw
Format
Sukat sa bytes
Byte
-128 .. 127
iconic
1
Halimbawa, uri ng data
-32768 .. 32767
iconic
2
Cardinal
-2147483648 .. 2147483647
iconic
4
Saklaw ng mga halaga
0 .. 255
Hindi nakapirma
1
Smallint
0 .. 65535
Hindi nakapirma
2
3.2.2. Uri ng Boolean
Maling Ord (Mali) = 0
Ord (Totoo) = 1
Succ (Mali) = Tama
Pred (Tama) = Mali3.2.3. Uri ng karakter
3.2.4. Uri ng enum
= ();)
3.2.5. Uri-range
Dosenang = 1..12; (mga numero mula 1 hanggang 12)
AddSub = Plus..Minus; (mga pagpapatakbo ng pagdaragdag at pagbabawas)3.2.6. Mga totoong tipo
Talahanayan 13.1. Libreng Mga Uri ng Data ng Pascal Integer (Lazarus).
Saklaw
Bilang ng mga makabuluhang numero
Sukat sa bytes
totoo
2.9*10-39..1.7*1038
11-12
6
Walang asawa
1.5*10-45..3.4*1038
7-8
4
Doble
5.0*10-324.-1.7*10308
15-16
8
Extended
3.4*10-4932..1.1*104932
19-20
10
Comp
-263+1..263-1
19-20
8
Uri ng integer
Talahanayan 13.1. Libreng Mga Uri ng Data ng Pascal Integer (Lazarus).
Saklaw
Sukat sa bytes
shortint
-128…127
1
integer
-32 768…32 767
2
matagal
-2 147 483 648…2 147 483 647
4
byte
0…255
1
salita
0…65 535
2
Tunay na uri
Talahanayan 13.1. Libreng Mga Uri ng Data ng Pascal Integer (Lazarus).
Saklaw
Memorya, byte
Bilang ng mga digit
totoo
2.9e-39 … 1.7e38
6
11-12
Walang asawa
1.5e-45 … 3.4e38
4
7-8
Doble
5.0e-324…1.7e308
8
15-16
Extended
3.4e-4932 … 1.1e493
10
19-20
Comp
-9.2e63…(9.2e63)-1
8
19-20
Uri ng Boolean
Uri ng karakter
Uri ng string
Enumerated data type
Uri ng data ng pagitan
