Ang mga nakabalangkas na uri ay nailalarawan sa pamamagitan ng multiplicity ng mga elemento na bumubuo sa ganitong uri, i.e. may ilang bahagi. Ang bawat bahagi, sa turn, ay maaaring kabilang sa isang nakabalangkas na uri, i.e. Pinahihintulutan ang nesting ng mga uri.
Mga array kumakatawan sa isang pormal na unyon ng ilang mga bagay ng parehong uri (mga numero, simbolo, string, atbp.), na itinuturing bilang isang solong kabuuan. Ang lahat ng mga bahagi ng array ay data ng parehong uri.
Pangkalahatang view ng isang kahulugan ng array:
Uri A = array [uri ng index ng array] ng [uri ng bahagi ng array]
Halimbawa, M1=array ng real;
Mga string ay isang hanay ng mga character, ngunit ang bilang ng mga character sa isang linya ay maaaring mag-iba. Ang string ay itinuturing bilang isang hanay ng mga character na may di-makatwirang haba. Ang maximum na bilang ng mga character ay hindi hihigit sa 255. Ang bawat karakter sa linya ay may sariling index (numero).
Itala ay isang istraktura ng data na binubuo ng isang nakapirming bilang ng mga bahagi na tinatawag na mga field ng talaan. Hindi tulad ng isang array, ang mga bahagi ng record (mga field) ay maaaring may iba't ibang uri. Pinapayagan ka ng mga rekord na pagsamahin ang mga halaga ng iba't ibang uri.
Buwan: (Ene, Peb, Mar, Abr, Mayo, Hun, Hulyo, Agosto, Setyembre, Okt, Nob, Dis);
Taon: 2000..2050;
Mga set– ito ay mga hanay ng magkatulad na mga bagay na lohikal na konektado sa isa't isa. Ang bilang ng mga elementong kasama sa isang set ay maaaring mag-iba mula 0 hanggang 256. Ito ay ang pabagu-bago ng kanilang mga elemento na nagtatakda ng mga set ay naiiba sa mga array at record.
Mga Digit = Set ng 1..5;
file- pinangalanang lugar ng panlabas na memorya. Ang isang file ay naglalaman ng mga bahagi ng parehong uri maliban sa mga file (ibig sabihin, hindi ka maaaring lumikha ng isang "file ng mga file"). Ang haba ng file ay hindi tinukoy at nalilimitahan lamang ng kapasidad ng mga external na memory device.
F: File ng Integer;
Mas magiging pamilyar tayo sa mga structured na uri habang pinag-aaralan pa natin ang wika.
Pointer (uri ng sanggunian)
Naglalaman ng address ng isang memory byte na naglalaman ng halaga ng data ng isang partikular na uri. Ang uri na ito ay tinatawag ding uri ng sanggunian. Ang paglalarawan ay gumagamit ng ^ character at isang uri ng pagkakakilanlan. Halimbawa, P=^integer;
Ang paggamit ng mga pointer ay isang flexible na paraan ng pamamahala ng dynamic na memory at nagbibigay ng kakayahang magproseso ng malalaking data array.
Mga Constant
pare-pareho ay isang dami na ang halaga ay hindi nagbabago sa panahon ng pagpapatupad ng programa.
Numerical Ang mga constant ay ginagamit sa pagsulat ng mga numero. Ang mga sumusunod na uri ay nakikilala:
buo mga numero: nakasulat na may + o - sign, o walang sign, ayon sa karaniwang mga panuntunan sa aritmetika: -10 +5 5
totoo Ang mga numero ay maaaring isulat sa isa sa dalawang anyo:
regular na pagpasok : 2.5 -3.14 2. - tandaan na ang integer na bahagi ay pinaghihiwalay mula sa fractional na bahagi ng simbolo ng tuldok;
exponential form: sa notasyong ito, ang isang tunay na numero ay kinakatawan bilang m*10 p, kung saan ang m ay mantissa o base ng numero, 0.1≤|m|≤1, p – utos mga numero, ito ay isang integer constant. Sa katunayan, ang anumang tunay na numero ay maaaring katawanin sa exponential form:
153.5 -0.1535*10 3
99.005 0.99005*10 2
Ang lahat ng mga computer na katugma sa IBM ay nag-iimbak ng mga tunay na numero bilang kumbinasyon ng mantissa at exponent, na nagpapahintulot sa mga operasyon sa mga ito na pasimplehin gamit ang espesyal na arithmetic na humahawak ng mantissa at exponent nang hiwalay. Para programmatically magsulat ng isang numero sa exponential form, sa halip na "multiply by 10 to the power", gamitin ang notation E o e(Latin):
153.5 -0.1535*10 3 -0.1535E3 o -1.535E02
99.005 0.99005*10 2 0.99005E+2 o 9.9005e+01
Nang walang mga espesyal na hakbang, ang isang Pascal program ay magpapakita ng mga totoong numero sa screen at printer sa eksaktong form na ito. Bilang karagdagan, ang form na ito ay maginhawa para sa pagsulat ng napakaliit at napakalaking numero:
Dahil ang laki ng memorya na inilalaan para sa mantissa at order ay limitado, kung gayon Ang mga tunay na numero ay palaging kinakatawan sa memorya ng computer na may ilang error. Halimbawa, ang pinakasimpleng real fraction na 2/3 ay nagbibigay ng 0.666666 sa decimal na representasyon... at, anuman ang laki ng memorya na inilalaan upang iimbak ang numero, imposibleng mag-imbak Lahat ang mga palatandaan nito sa fractional na bahagi. Ang isa sa mga karaniwang problema sa programming ay isinasaalang-alang ang mga posibleng error kapag nagtatrabaho sa mga tunay na numero.
Ang mga hexadecimal na numero ay binubuo ng mga hexadecimal na digit na pinangungunahan ng isang $ sign. Ang hanay ng mga hexadecimal na numero ay mula $00000000 hanggang $FFFFFFFF.
Bilang karagdagan sa mga numerical constant, mayroong iba pang mga uri ng constants:
pang-aasar ng utak mga pare-pareho.
Nagsisilbi silang suriin ang katotohanan o kamalian ng ilang mga kundisyon sa programa at maaari lamang tanggapin isa sa dalawang halaga: function na salita totoo naninindigan para sa katotohanan at mali- kasinungalingan;
karakter mga pare-pareho.
Maaaring kunin ang halaga ng anumang napi-print na character at isinusulat bilang character na nakapaloob mga kudlit("single quotes"):
Sa huling kaso, ang halaga ng character constant ay katumbas ng space character. Kung gusto mong isulat ang simbolo ng apostrophe mismo bilang isang character constant, ito ay dinoble sa loob ng mga panlabas na apostrophe: """"
Kasama rin sa mga character constant ang mga constant ng form na #X, kung saan ang X ay isang numeric na value mula 0 hanggang 255 inclusive, na kumakatawan sa isang decimal ASCII-code simbolo. Ang mga talahanayan ng mga ASCII code na ginagamit ng mga operating system ng DOS at Windows ay ibinibigay sa Appendix 1. Halimbawa, ang value #65 ay tumutugma sa Latin character code na "A".
String mga pare-pareho.
Ito ay anumang pagkakasunud-sunod ng mga character na nakapaloob sa mga kudlit. Bilang isang patakaran, ang mga string constant ay ginagamit upang mag-record ng mga senyas para sa data input na ibinigay ng programa, magpakita ng mga diagnostic na mensahe, atbp.:
"Ipasok ang halaga ng X:"
Kung kinakailangan na isulat ang kudlit na karakter mismo sa isang string constant, ito ay ginagawa sa parehong paraan tulad ng para sa character constants.
Ang mga Constant sa Turbo Pascal ay maaaring pangalanan. Walang pangalan Ang mga constant ay ginagamit, halimbawa, kapag ipinapakita ang teksto ng mga mensahe sa nakaraang halimbawa. Pinangalanang Constants ay inilarawan sa seksyon ng paglalarawan ng programa ng isang operator ng sumusunod na form:
const Pangalan1=Halaga1;
Pangalan2=Halaga2;
PangalanN=HalagaN;
Dito, ipinapahiwatig ng const na keyword ang simula ng seksyon para sa pinangalanang mga pare-parehong deklarasyon. Malinaw na madalas na mas maginhawang sumangguni sa isang pare-pareho sa pamamagitan ng pangalan kaysa muling isulat ang numeric o string value nito sa bawat pagkakataon. Halimbawa ng isang seksyon ng constants:
const e=2.7182818285;
lang="Turbo Pascal 7.1";
Inilalarawan nito ang isang numeric constant e na may halaga ng base ng natural na logarithm at isang string constant na pinangalanang lang na naglalaman ng string na "Turbo Pascal 7.1".
Ang bawat pangalan na ibinigay ng programmer ay dapat na kakaiba sa loob ng isang programa. Kung isasama namin ang seksyong ito sa aming programa, hindi na kami makakagawa ng iba pang mga bagay na pinangalanang e at lang dito.
Ang structural algorithmization method ay isa sa mga sistematikong pamamaraan para sa pagbuo ng mga algorithm. Ito ay batay sa isang visual na representasyon ng mga algorithm sa anyo ng mga pagkakasunud-sunod ng control structural fragment.
Ang bawat algorithm ay binubuo ng mga elementarya na hakbang na maaaring pagsamahin sa ilang partikular na algorithmic na istruktura: linear (sequential), sumasanga , paikot .
Kahulugan 1
Linear ay isang disenyo ng algorithm na ipinatupad bilang isang pagkakasunud-sunod ng mga aksyon (hakbang), na ang bawat aksyon (hakbang) ay gumanap lamang ng 1 beses, pagkatapos ng bawat aksyon (hakbang) ang aksyon (hakbang) ay nadagdagan ng 1 hanggang ang halaga ay mas malaki kaysa sa huling parameter ng ang algorithm.
Ang mga linear na proseso ay kinakatawan gamit ang mga linear na algorithm. Ang mga algorithm ng ganitong uri ay ginagamit upang ilarawan ang isang pangkalahatang solusyon sa mga problema sa anyo ng mga pagkakasunud-sunod ng mga module.
Kahulugan 2
Sumasanga (branching) tumawag ng algorithmic na disenyo na nagbibigay ng pagpipilian sa pagitan ng 2 solusyon depende sa mga halaga ng data ng input.
Mayroong dalawang uri ng sangay: hindi kumpleto (kung ang isang bagay) At kumpleto (kung sakali ay). Gamit ang buong branching, maaari mong ayusin ang 2 branch sa algorithm ( yun o kung hindi), ang bawat isa ay hahantong sa isang karaniwang punto ng kanilang pagsasama, ang algorithm ay isasagawa anuman ang landas na tinahak ng solusyon. Sa pagkakaroon ng hindi kumpletong pagsasanga, ang ilang mga aksyon ng algorithm ay ipinapalagay sa isang sangay lamang ( yun), dahil ang pangalawa ay nawawala, hindi na kailangang magsagawa ng anumang aksyon para sa isa sa mga resulta ng pagsusuri; ang kontrol ay agad na ipapasa sa merge point. Mayroong 4 na pangunahing variant ng branching structure:
- Hindi kumpletong uri ng pagsasanga "kung-kung ganun ", kung saan isasagawa ang lahat ng aksyon kung totoo ang kundisyon.
- Buong uri na sumasanga "kung - kung gayon - kung hindi" , kung saan 2 aksyon ang isasagawa depende sa katotohanan ng kundisyon.
- Sumasanga na may pagpili ng uri "yan" , kung saan isasagawa ang aksyon 1 sa ilalim ng kundisyon 1, pagkilos 2 sa ilalim ng kundisyon 2, atbp.
- Sumasanga na may pagpili ng uri "kung hindi" , kung saan, sa ilalim ng kundisyon 1, ang pagkilos 1 ay isasagawa, sa ilalim ng kundisyon 2, pagkilos 2, atbp., at kung hindi man ay isasagawa ang lahat ng iba pang pagkilos.
Nasa ibaba ang mga block diagram ng mga branching algorithm.
Kahulugan 3
Paikot (o cycle) ay isang disenyo ng algorithm kung saan ang isang tiyak na pangkat ng magkakasunod na pagkilos (mga hakbang) ay ginaganap nang maraming beses depende sa mga kondisyon ng problema at data ng pag-input.
Kahulugan 4
Ang ganitong grupo ng mga paulit-ulit na aksyon sa bawat hakbang ng cycle ay tinatawag katawan ng loop .
Ang anumang cyclic na istraktura ay naglalaman ng mga elemento ng isang sumasanga na istraktura ng algorithm.
Mayroong 3 uri ng cyclic algorithm:
- loop na may parameter (arithmetic loop);
- loop na may precondition;
- isang loop na may postcondition (ang huling dalawa ay tinatawag na iterative).
Arithmetic loop
Sa isang cycle ng ganitong uri, ang bilang ng mga hakbang ay natatanging tinutukoy ng panuntunan para sa pagbabago ng parameter, na tinukoy gamit ang mga inisyal at panghuling halaga nito, pati na rin ang hakbang ng pagbabago nito. Ibig sabihin, sa bawat hakbang ng cycle, nagbabago ang halaga ng parameter ayon sa hakbang ng cycle hanggang umabot ito sa halagang katumbas ng panghuling halaga ng parameter.
Loop na may precondition
Sa loop na ito, ang bilang ng mga hakbang ay hindi natutukoy nang maaga; depende ito sa data ng pag-input. Sa cyclic na istrakturang ito, ang halaga ng conditional expression (kondisyon) bago isagawa ang susunod na hakbang ng cycle ay unang sinusuri. Kung totoo ang conditional expression, ang katawan ng loop ay isasagawa. Pagkatapos nito ay susuriin muli ang kundisyon. Uulitin ang mga pagkilos na ito hanggang sa maging false ang value ng conditional expression, pagkatapos ay magtatapos ang loop.
Ang kakaiba ng ganitong uri ng loop ay kung ang halaga ng conditional expression ay hindi totoo sa simula, ang katawan ng loop ay hindi isasagawa sa lahat.
Loop na may postcondition
Sa paikot na konstruksyon na ito, tulad ng sa nauna, ang bilang ng mga pag-uulit ng katawan ng loop ay hindi natukoy nang maaga; ito ay depende sa mga parameter ng input. Ang isang natatanging tampok ng isang loop na may precondition ay ang katawan ng loop na may isang postcondition sa anumang kaso ay isasagawa nang hindi bababa sa isang beses at pagkatapos lamang na ang kundisyon ay susuriin. Sa konstruksiyon na ito, ang katawan ng loop ay isinasagawa hanggang sa ang halaga ng conditional expression ay hindi totoo. Kapag naging totoo ito, hihinto ang pagpapatupad ng command.
Sa mga totoong problema, bilang panuntunan, mayroong anumang bilang ng mga cycle.
Nasa ibaba ang mga block diagram ng cyclic algorithm.
Mga uri ng data: simple at structured
Ang totoong data na naproseso ng programa ay may kasamang integer at totoong mga numero, lohikal na halaga at simbolo. Nabibilang sila sa mga simpleng uri ng data at tinatawag na basic. Ang lahat ng data na naproseso ng isang computer ay naka-imbak sa mga cell ng memorya nito, bawat isa ay may sariling address. Sa mga programming language, may mga variable na nagbibigay-daan sa iyo na huwag pansinin ang mga address ng mga memory cell at i-access ang mga ito gamit ang isang pangalan (identifier).
Kahulugan 5
Variable ay isang pinangalanang object (memory cell) na nagbabago ng halaga nito.
Ang variable na pangalan ay nagpapahiwatig ng halaga, ngunit ang address at paraan ng pag-iimbak nito ay nananatiling nakatago mula sa programmer. Bilang karagdagan sa pangalan at halaga, ang mga variable ay may sariling uri, na tumutulong na matukoy kung anong uri ng impormasyon ang nasa memorya.
Ang uri ng variable ay tinukoy ng:
- ang paraan na ginagamit para sa pagtatala ng impormasyon sa mga cell ng memorya;
- ang kinakailangang halaga ng memorya upang maiimbak ito.
Para sa bawat uri, tinutukoy ang dami ng memorya upang mailagay dito ang anumang halaga mula sa pinapayagang hanay ng mga halaga para sa ganitong uri.
Kahulugan 6
Ang mga variable na naroroon sa programa sa buong panahon ng operasyon nito ay tinatawag static .
Kahulugan 7
Ang mga variable na nilikha at sinisira sa iba't ibang yugto ng pagpapatupad ng programa ay tinatawag pabago-bago .Kahulugan 10
Array Tinatawag nila ang isang nakaayos na hanay ng mga dami ng parehong uri na may karaniwang pangalan at mga serial number ng mga elemento (mga indeks).
Ang mga elemento ng isang array ay naka-imbak sa memorya ng computer sa malapit, hindi tulad ng mga solong elemento. Ang mga array ay nakikilala sa pamamagitan ng bilang ng mga indeks ng elemento.
Ang isang one-dimensional array ay nailalarawan sa pagkakaroon ng isang index lamang para sa bawat elemento. Ang mga halimbawa ng mga one-dimensional na array ay geometric at arithmetic sequence, na tumutukoy sa may hangganan na serye ng mga numero.
Kahulugan 11
Ang bilang ng mga elemento sa isang array ay tinatawag sukat .
Para sa isang one-dimensional na array, ang dimensyon nito ay nakasulat sa tabi ng pangalan sa mga panaklong.
Ang mga elemento ng isang one-dimensional na array ay inilalagay sa bawat elemento, sa pagkakasunud-sunod na kinakailangan upang malutas ang isang partikular na problema. Kung kinakailangan upang ipasok ang buong array, ang mga elemento ay ipinasok sa pataas na pagkakasunud-sunod ng index.
Kabanata 6. STRUCTURED
MGA URI NG DATA Ang mga istrukturang uri ng data ay tumutukoy sa mga hanay ng mga bahagi ng pareho o magkakaibang uri. Ang mga uri ng bahagi ay nabuo mula sa iba pang mga uri ng data (simple, structured, pointer, atbp.). Sa wikang Pascal mayroong mga sumusunod na uri ng istruktura: - uri ng array; - uri ng record; - uri-set; - uri ng file. Ang Turbo Pascal ay may dalawa pang structured na uri: - ang string type string at - ang PChar string type, na mga uri ng array. Sa mga sumusunod, para sa ikli, ang mga bagay na may mga structured na uri ay tatawagin sa parehong mga pangalan tulad ng kanilang mga uri, nang hindi tinukoy ang salitang "uri": array, record, set, file, string. Sa pamantayan ng wika, may mga naka-package at naka-unpack na mga structured na uri. Sa Turbo Pascal, ang salitang naka-pack, na nagpapakilala sa isang naka-pack na uri, ay walang epekto; Hangga't maaari, awtomatikong ginagawa ang packaging ng data. 6.1. Ang Array Type-array ay isang nakapirming bilang ng mga nakaayos na bahagi ng parehong uri, na nilagyan ng mga indeks. Maaari itong maging one-dimensional o multidimensional. Upang tumukoy ng uri ng array, gamitin ang nakalaan na hanay ng salita, pagkatapos nito ay dapat mong isaad ang uri ng (mga) index ng mga bahagi (sa mga square bracket) at pagkatapos ay pagkatapos ng salita ng - ang uri ng mismong mga bahagi: i-type<имя типа>= array[<тип индекса(индексов)>] ng<тип компонент> ; Halimbawa. uri Arr = array ng Real; (uri ng array ng 3 totoong numero) Matrix = array ng Integer; (Ang uri ay isang dalawang-dimensional na hanay ng mga integer, na binubuo ng 3 row at 2 column) Sa pamamagitan ng pagpapakilala ng isang uri ng array, maaari mong tukuyin ang mga variable o nai-type na mga constant ng ganoong uri. Ang dimensyon ng array ay maaaring maging anuman, ang mga bahagi ng array ay maaaring maging anumang uri, kabilang ang mga structured, ang index (mga indeks) ay maaaring maging anumang uri ng ordinal, maliban sa Longint na uri. Kapag nagtatalaga ng mga halaga sa isang pare-parehong array, ang mga bahagi ay ipinahiwatig sa mga panaklong at pinaghihiwalay ng mga kuwit, at kung ang array ay multidimensional, ang mga panlabas na panaklong ay tumutugma sa kaliwang index, ang mga panaklong na nested sa loob ng mga ito ay tumutugma sa susunod na index, atbp. Kaya, para sa mga uri na ipinakilala sa itaas, maaari mong tukuyin, halimbawa, ang mga sumusunod na variable at constants: var Ml, M2: Arr; Matr: Matrix; const M3: Arr =(1, 2, 3); Banig: Matrix = ((1, 2), (3, 4), (5, 6)); Ang huling pare-pareho ay tumutugma sa sumusunod na istraktura: 1 2 3 4 5 6 Tandaan. Ang isang uri ng array ay maaari ding direktang ipasok kapag tinutukoy ang mga kaukulang variable o nai-type na mga constant. Halimbawa: var Ml, M2: array of Real; Matr: hanay ng Integer; Ang parehong mga array ay tinukoy dito tulad ng sa nakaraang halimbawa. Kapag nagdedeklara ng mga arrays sa ganitong paraan, tandaan na ang kanilang mga uri ay hindi magiging magkapareho sa anumang iba pang mga uri, kahit na mayroon silang parehong istraktura. Samakatuwid, hindi mo maipapasa ang mga ito bilang mga parameter sa isang subroutine (tingnan ang seksyon 10.3); hindi mo rin maaaring italaga sa kanila ang mga halaga ng iba pang mga array (at kabaliktaran), kahit na ang kanilang mga istruktura ay pareho. Ang mga bahagi ng array ay ina-access sa pamamagitan ng pagtukoy sa pangalan ng array na sinusundan ng halaga ng (mga) index ng bahagi sa mga square bracket. Sa pangkalahatan, ang bawat component index ay maaaring tukuyin sa pamamagitan ng isang expression ng naaangkop na uri, halimbawa: M1, Matrix, M2, atbp. Isang array ay maaaring italaga ang halaga ng isa pang array, ngunit lamang ng isang magkaparehong uri. Kaya, kung ang mga sumusunod na array ay ibinigay: var A, B: array ng Integer; C: array ng Integer; pagkatapos ay sabihin natin ang sumusunod na operator: A:= B; Sa kabilang banda, ang operator C:= A; ay hindi wasto, dahil ang mga array A at C ay hindi magkaparehong uri. Mayroong ilang mga pagkakaiba sa pagtatrabaho sa mga one-dimensional na array ng mga character (huwag malito sa mga halaga ng string - tingnan ang seksyon 6.2). Kaya, ang mga na-type na constant ng ganitong uri ay maaaring magtalaga ng isang halaga tulad ng ordinaryong string constants sa pamamagitan ng pagtukoy ng isang string ng mga character sa mga apostrophe, halimbawa const A: array ng Char="aaaaa"; B: hanay ng Char="bbb"; Para sa mga naturang array, tulad ng para sa mga string, maaari mong gamitin ang mga operasyon ng paghahambing (kahit na hindi sila magkaparehong mga uri at kahit na may iba't ibang laki ang mga ito) at concatenation (unyon) - tingnan. sugnay 6.2. Magagamit ang mga ito sa mga pahayag ng output ng Write at WriteLn. Halimbawa, para sa mga arrays na inilagay sa itaas, maaari mong isulat kung A > B pagkatapos ay WriteLn(A) else WriteLn(B); 6.2. String ng uri ng string Sa Turbo Pascal, ang uri ng string (karaniwang uri ng string) ay isang pagkakasunud-sunod ng mga character na may arbitraryong haba (hanggang 255 character). Ang isang string ay maaaring isipin bilang isang hanay ng mga character, ngunit dahil sa malawakang paggamit ng mga string at ilang mga tampok kumpara sa mga karaniwang array, sila ay pinaghihiwalay sa isang hiwalay na uri ng data. Ang isang uri ng string ay maaaring ipahiwatig ang laki nito sa mga square bracket (mula 1 hanggang 255). Kung ang laki ng string ay hindi tinukoy, ito ay ipinapalagay na 255, halimbawa: var Str: string; MaxStr: string; (255 character string) const January: string = "Enero"; Ang concatenation (+) at paghahambing na mga operasyon ay naaangkop sa mga string. Ang operasyon ng concatenation ay nagdaragdag ng pangalawang string sa una. Halimbawa. Pagsamahin ang dalawang string. Str, Strl, Str2:string; simulan ang Strl: = "Turbo"; Str2: = "Pascal"; Str:= Strl + Str2; (sa Str variable - "Turbo Pascal") dulo. Maaari mong ihambing ang mga string na may iba't ibang haba. Isinasagawa ang paghahambing mula kaliwa hanggang kanan alinsunod sa mga ASCII code ng kaukulang mga character. Ang mga nawawalang character sa mas maikling string ay itinuturing na may code na mas mababa kaysa sa anumang wastong character. Halimbawa, ang "XS" ay mas malaki kaysa sa "X". Halimbawa. Suriin kung ang ipinasok na hanay ng mga character ay ang pangalan ng buwan sa Russian. programa HALIMBAWA11; const Instance: array of string!10]= ("ENERO", "PEBRERO", "MARSO", "ABRIL", "MAY", "HUNYO", "HULYO", "AGOSTO", "SETYEMBRE", "OCTOBER" , "NOBYEMBRE DISYEMBRE"); Buwan: Boolean = Mali; var Str: string; i: Integer; simulan ang Writeln("Ipasok ang malalaking character: "); ReadLn(Str); para sa i:= 1 hanggang 12 gawin kung Str = Instance[i] pagkatapos Month:=True; kung Buwan pagkatapos ay ang WriteLn("Ang pangalan ng buwan ay inilagay") kung hindi ang WriteLn("Ang pangalan ng buwan ay hindi nailagay") magtatapos. Sa katunayan, ang isang string ng N character ay isang array ng N+1 character: string[N] = array ng Char. Ang null na character ay inilaan upang ipahiwatig ang bilang ng mga character sa isang string na gagamitin at maaaring mag-iba mula sa isang character na may code 0 hanggang sa isang character na may code N. Maaari mong gamitin ito tulad ng iba pang mga character sa isang string (isulat at basahin ang halaga nito , atbp.), ngunit hindi nalilimutan ang pangunahing layunin nito. 6.3. ASCIIZ string Sa bersyon 7.0, para sa pagiging tugma sa iba pang mga programming language at sa kapaligiran ng Windows, isa pang uri ng string ang ipinakilala - mga string na nagtatapos sa zero byte - isang character na may code 0 (tinatawag na ASCIIZ string). Hindi tulad ng mga string, ang mga string na ito ay walang limitasyon sa laki (sa katunayan, maaari silang umabot sa 65535 bytes). Ang mga string na ito ay binibigyan ng karaniwang uri ng PChar. Sa katunayan, ang ganitong uri ay isang pointer sa isang character (tungkol sa mga pointer, tingnan ang talata 7): PChar = ^Char; Gayunpaman, ang paggamit ng pinahabang syntax (key (X+) - tingnan ang seksyon 17.7.1) ay nagbibigay-daan sa iyong gumamit ng naturang variable bilang katumbas ng string sa isang array ng uri ng pChar = array ng Char, kung saan ang K ay ang bilang ng mga character sa ang string, hindi binibilang ang trailing character na may code 0 Hindi tulad ng string type, ang character na may index 0 dito ay ang unang character ng string, at ang huling character na may index K ay ang huling character na may code 0. Kapag nagtatrabaho sa ASCIIZ strings , ipinapayong tumukoy ng pinahabang syntax; sa kasong ito, walang mga paghihirap kapag gumagamit ng iba't ibang mga karaniwang gawain na gumagana sa mga string. Halimbawa. Paggamit ng mga string ng PChar na may pinahabang syntax. programa HALIMBAWA12; ($X+) (hindi kailangan dahil ito ang default) uri T = array ng Char; (array para sa isang 7 character na string) var Str: PChar; const A: T = "hello!"#0; begin Str:= "HELLO!"; WriteLn(Str); (linya ng output: HI
Str:= @А; {допустимо также: Str:=A}
WriteLn(Str); {вывод строки: привет!}
WriteLn(Str);{вывод символа "р"}
ReadLn
end.
Если используется ключ {$Х-}, переменная типа PChar в этом случае рассматривается
как указатель на один единственный символ. В этом случае ни один из операторов
предыдущего примера, за исключением операторов Str:=@A; и ReadLn, недопустимы, а
оператор WriteLn(Str^), выполненный после оператора Str:=@A;, выдаст один символ "п".
Для работы с ASCIIZ-строками в версии 7.0 используются специальные стандартные модули
Strings (см. п. 16.2) и WinDos (см. п. 16.6).
6.4. Запись
Тип-запись включает ряд компонент, называемых полями, которые могут быть разных типов.
При задании типа-записи после зарезервированного слова record следует перечислить все
поля типа-записи с указанием через двоеточие их типов и завершить задание типа словом
end. Поля отделяются друг от друга точкой с запятой. Количество полей записи может быть
любым.
Пример.
type
Complex = record {Тип комплексных чисел}
Re: Real;
Im: Real
end;
Data = record {Тип - дата рождения}
Year: Integer;
Month: 1..12;
Day: 1..31
end;
Person = record {Тип - сведения о сотруднике}
Name: string;
Sex: (Male, Female);
Age: Integer;
Married: Boolean
end;
Примечание. Если несколько полей типа-записи имеют один и тот же тип, то их имена можно
перечислить через запятую и затем указать этот общий тип. Так, рассмотренный в примере
тип комплексных чисел можно ввести и другим образом:
type
Complex = record
Re, Im: Real
end;
После введения типа-записи можно затем задать переменные или типизированные константы
этого типа - записи.
При задании значений константе ее поля записываются в круглых скобках через точку с
запятой. Для задания значения каждого поля сначала указывается имя поля, а затем через
двоеточие - его значение.
Так, для введенных выше типов можно задать, например, следующие переменные и константы:
var
X, У, Z: Complex;
Dat: Data;
const
Birthday: Data = (Year: 1971; Month: 12; Day: 9);
Ivanov: Person = (Name: "Иванов"; Sex: Male; Age: 40; Married: True);
Примечание. Тип-запись можно вводить и непосредственно при определении переменных или
типизированных констант. Например, фрагмент
var
X, Y, Z: record
Re, Im: Real
end;
определяет те же комплексные переменные, что и в предыдущем примере.
Доступ к полям записи осуществляется указанием имени переменной (константы) и имени поля,
записываемого через точку, например:
Ivanov.Age, X.Re, Dat.Day и т. д.
Пример. Использование полей записей.
X.Re:= 1.5;
X.Im:=1.7; Y.Re:= -X.Re;
Y.Im:= -X.Im;
Ivanov.Married:= False;
Для того чтобы не выписывать каждый раз имя записи при обращении к ее полям, можно
использовать оператор над записями WITH. Его структура выглядит следующим образом:
with !}<имя записи>gawin<оператор> ; Sa kasong ito, tanging ang field ng record ang maaaring tukuyin sa loob ng pahayag. Halimbawa, ang fragment: with X do begin Re:= 1.5; Ako:= 1.7; Y.Re:= -Re; Y.Im:= -Im end; kasama si Ivanov do Married:= False; ay katumbas ng fragment mula sa nakaraang halimbawa. Ang isang uri ng talaan ay maaaring magkaroon ng isang variant na bahagi na nagbabago sa iba't ibang mga pagpapatupad, halimbawa, sa isang uri ng talaan para sa mga parameter ng mga geometric na numero, ang isang gilid ay tinukoy para sa isang parisukat, dalawang panig at ang anggulo sa pagitan ng mga ito para sa isang tatsulok, isang radius para sa isang bilog, atbp. Ang variant na bahagi ay maaaring isa lamang at dapat na matatagpuan sa dulo ng entry. Halimbawa. Gamit ang isang variant na bahagi. uri Figure = (Square, Triangle, Circle); Param = record X, Y: Real; (coordinate ng anchor point) case Fig: Figure ng (figure parameters) Square: (Side: Real); Triangle: (Sidel, Side2, Angle: Real); Circle: (Radius: Real) dulo; var MySquare, MyCircle: Param; Nagsisimula ang variant na bahagi sa word case, na sinusundan ng variant selection variable (sa halimbawa ng Fig) na nagsasaad ng uri. Susunod ay ang mga constant na ang mga halaga ay maaaring kunin ng variable ng pagpili ng opsyon (sa halimbawa, Square, Triangle, Circle). Pagkatapos ng bawat pare-pareho, ang mga patlang ng ibinigay na opsyon sa pag-record ay isinusulat, na pinaghihiwalay ng isang tutuldok sa panaklong, na nagpapahiwatig ng kanilang mga uri. Kinakailangan ang mga panaklong kahit na walang variant na bahagi para sa isang ibinigay na opsyon. Dapat tandaan na ang variant na bahagi ay hindi tinapos ng sarili nitong pahayag ng pagtatapos, tulad ng sa isang regular na konstruksyon ng CASE, dahil sinusundan ito ng pagtatapos na pahayag ng buong uri. Sa pamantayan ng wikang Pascal, bago gamitin ang isa sa mga opsyon sa pagre-record, ang variable ng pagpili ng opsyon ay dapat na italaga ng naaangkop na halaga: Fig:= Square; MySquare.Side:=5.0; Fig:= Circle; MyCircle.Radius:=7.5; Sa Turbo Pascal ang operasyong ito ay hindi kinakailangan, bagama't kung ang isang pagpipilian na variable ay tinukoy, maaari itong tingnan sa programa upang matukoy kung aling pagpipilian ang nakatakda. Bukod dito, ang pagtatakda ng halaga ng variable ng pagpili ay walang epekto sa anuman, at ang sumusunod na fragment ay katumbas ng tinalakay sa itaas: Fig:= Circle; MySquare.Side:= 5.0; Fig:= Square; MyCircle.Radius:-7.5; Sa uri ng record, pinahihintulutan na huwag magpasok ng variable para sa pagpili ng mga opsyon, ngunit maglista lamang ng iba't ibang opsyon, halimbawa: Transf = record case Integer ng 1: (_Word: Word); 2: (_TwoSymb: array ng Char) dulo; 6.5. Itakda Sa wikang Pascal, ang uri ng hanay ay isang set-degree ng orihinal na hanay ng mga bagay ng isang uri ng ordinal, iyon ay, isang hanay ng lahat ng posibleng kumbinasyon ng mga bagay ng orihinal na hanay. Ang bilang ng mga elemento ng orihinal na hanay sa Turbo Pascal ay hindi maaaring higit sa 256, at ang mga ordinal na numero ng mga elemento (iyon ay, ang halaga ng Ord function) ay dapat nasa hanay mula 0 hanggang 255. Upang tumukoy ng uri ng hanay , dapat mong gamitin ang mga nakalaan na salita set at ng, at pagkatapos ay ipahiwatig ang mga elemento ng set na ito, kadalasan sa anyo ng isang enumeration o range, halimbawa: type Alfa = set ng "A".."Z"; Bilang = set ng (Plus, Minus, Mult, Divid); Sampu = set ng 0..9; Numero = set ng "0".."9" ; Sa pamamagitan ng paglalagay ng isang set na uri, maaari mong tukuyin ang mga variable o na-type na mga constant ng ganoong uri ng hanay. Kapag nagtatalaga ng mga halaga sa isang pare-parehong hanay, ang mga elemento nito ay nakalista na pinaghihiwalay ng mga kuwit (ito ay katanggap-tanggap na tukuyin ang mga saklaw) at inilagay sa mga square bracket. Halimbawa, para sa mga uri na ipinakilala sa itaas, maaari mong itakda ang mga sumusunod na variable at mga na-type na constant: var CharVal: Alfa; Operasyon: Bilang; const Index: Ten = ; Digit: Numero = ["0".."9"]; Tandaan. Tulad ng iba pang mga structured na uri, ang isang set na uri ay maaaring direktang ipakilala kapag tinutukoy ang mga variable o nag-type ng mga constant: var CharVal: set ng "A."."Z"; Operasyon: set ng (Plus, Minus, Mult, Divid); const Index: set ng 0..9 = ; Digit: set ng "0".."9"=["0".."9"]; Ang isang set ay maaaring magtalaga ng isa o ibang halaga sa isang programa. Karaniwan ang halaga ay itinakda gamit ang set constructor. Tinutukoy ng constructor ang isang hanay ng mga elemento sa pamamagitan ng paglilista ng mga expression sa mga square bracket na ang mga halaga ay ibinibigay ng mga elemento ng set na ito. Ito ay katanggap-tanggap na gumamit ng mga hanay ng mga elemento. Halimbawa. Ang mga sumusunod na istruktura ay mga set constructor: Ang bawat set ay kinabibilangan ng tinatawag na. isang walang laman na set na walang mga elemento. Ang set constructor ay maaari ding gamitin nang direkta sa mga operasyon sa mga set. Ang mga sumusunod na operasyon ay tinukoy para sa mga set: + - unyon ng mga set; - - pagkakaiba ng mga hanay; * - intersection ng marami; = - pagsuri sa equivalence ng dalawang set;<>- pagsuri sa hindi pagkakapantay-pantay ng dalawang hanay;<= - проверка, является ли левое множество подмножеством правого множества;
> = - pagsuri kung ang kanang hanay ay isang subset ng kaliwang hanay; in - sinusuri kung ang elementong tinukoy sa kaliwa ay kasama sa set na tinukoy sa kanan. Ang resulta ng pagpapatakbo ng unyon, pagkakaiba o intersection ay ang kaukulang hanay, ang iba pang mga operasyon ay nagbibigay ng resulta ng lohikal na uri. Halimbawa. Maglagay ng string ng character na binubuo ng mga Latin na letra, numero at espasyo. Suriin ang kawastuhan ng mga inilagay na character. programa HALIMBAWA13; var Str: string; L: Byte; Tru: Boolean; simulan ang WriteLn("Magpasok ng linya"); ReadLn(Str); L:= Haba(str); (bilang ng mga character na ipinasok) Tru:= L > 0; (true kung hindi isang walang laman na string) habang ginagawa ang Tru at (L > 0) (suriin mula sa dulo ng linya) simulan ang Tru:=Str[L] sa ["0".."9", "A"., "Z" , "a".."z", " "]; (character validity check) Disyembre(L) (nakaraang karakter) katapusan; kung Tru pagkatapos ay ang WriteLn("Tamang linya") kung hindi ang WriteLn("Maling linya") ay magtatapos. 6.6. Ang uri ng file na file ay isang pagkakasunud-sunod ng mga bahagi ng parehong uri na matatagpuan sa isang panlabas na aparato (ang pamantayan ng wika ay batay sa lokasyon ng data sa mga magnetic tape). Ang mga bahagi ay maaaring maging anumang uri, maliban sa uri ng file (o naglalaman ng mga bahagi ng isang uri ng file) at uri ng bagay. Ang bilang ng mga bahagi sa file ay hindi idineklara. Upang tukuyin ang isang uri ng file, gamitin ang mga nakalaan na salita file at ng, na sinusundan ng uri ng bahagi ng file. Halimbawa. uri Numero = file ng Integer; (integer file type) Symb = file ng "A".."Z"; (Upper case na uri ng file) Ang karaniwang uri ng Teksto ay tumutukoy sa isang uri ng file na naglalaman ng mga character na pinagsama-sama sa mga string. Tandaan na ang uri ng Teksto sa Turbo Pascal ay hindi katumbas ng file ng uri ng Char. Sa pamamagitan ng pagpasok ng uri ng file, maaari mong tukuyin ang mga variable ng uri ng file: var Fl, F2: Numero; F3: Teksto; FF4: Simbolo; Sa Turbo Pascal, maaari kang gumamit ng isang file na walang uri, ang kahulugan nito ay hindi tumutukoy sa uri ng bahagi. Sa kasong ito, ang trabaho sa file ay isinasagawa sa pisikal na antas alinsunod sa panloob na format ng data nito. Sa kasong ito, ang aktwal na mga bahagi ng file ay maaaring may iba't ibang uri. Halimbawa. i-type ang UnType = file; Ang uri ng file ay maaari ding direktang tukuyin kapag nagdedeklara ng mga variable ng file: var Fl, F2: file ng Integer; Ang mga variable ng file ay may mga partikular na gamit. Hindi ka maaaring magsagawa ng anumang mga operasyon sa mga ito (magtalaga ng isang halaga, maghambing, atbp.). Magagamit lang ang mga ito para magsagawa ng mga operasyon sa mga file (pagbasa, pagsusulat, pagtanggal ng file, atbp.). Ang pagtatrabaho sa mga file ay tatalakayin sa talata 11. Bilang karagdagan, sa pamamagitan ng isang variable ng file maaari kang makakuha ng impormasyon tungkol sa isang partikular na file (uri, mga parameter, pangalan ng file, atbp.). d.)
algorithm discrete programming
Ang totoong data na pinoproseso ng programa ay mga integer, totoong numero, simbolo, at lohikal na halaga. Ang mga simpleng uri ng data na ito ay tinatawag basic. Ang lahat ng data na naproseso ng isang computer ay naka-imbak sa mga cell ng memorya ng computer, bawat isa ay may sariling address. Upang hindi masubaybayan kung saang address ito o ang data na iyon isusulat, ginagamit ng mga programming language ang konsepto ng isang variable , na nagpapahintulot sa iyo na huwag pansinin ang address ng isang memory cell at i-access ito gamit ang pangalan ( identifier).
Variable - may pinangalanang object (memory cell) na maaaring magbago ng halaga nito. Pangalan variable ay nagpapahiwatig ibig sabihin, at ang paraan ng imbakan at address nito ay nananatiling nakatago mula sa programmer. Bilang karagdagan sa pangalan at halaga nito, mayroong isang variable uri, pagtukoy kung anong impormasyon ang nasa memorya. Uri variable set:
- * ang paraan na ginagamit para sa pagtatala ng impormasyon sa mga cell ng memorya;
- * ang kinakailangang halaga ng memorya upang maiimbak ito.
Ang dami ng memorya para sa bawat uri ay tinutukoy sa paraang maaari itong tumanggap ng anumang halaga mula sa wastong hanay ng mga halaga ng ganitong uri. Halimbawa, ang uri ng byte ay maaaring tumagal ng mga halaga mula 0 hanggang 255, na sa binary code (255 = 11111111 2) ay tumutugma sa isang memory cell na 8 bits ang haba (o 1 byte).
Sa mga algorithm na inilarawan sa itaas, ang lahat ng data ay naka-imbak sa anyo ng mga variable. Halimbawa, ang pagtuturo na "Magpasok ng dalawang numero A, b" nangangahulugang ipinapasok ng gumagamit ang mga halaga ng dalawang variable, at ang pagtuturo na "K=K+1" ay nangangahulugang pagtaas ng halaga ng variable K ng isa.
Kung ang mga variable ay naroroon sa isang programa sa buong tagal ng operasyon nito, ang mga ito ay tinatawag static. Ang mga variable na nilikha at sinisira sa iba't ibang yugto ng pagpapatupad ng programa ay tinatawag pabago-bago.
Ang lahat ng iba pang data sa programa, ang mga halaga na hindi nagbabago sa buong operasyon nito, ay tinatawag mga pare-pareho o permanente. Ang mga constant, tulad ng mga variable, ay may isang uri. Maaari silang ipahiwatig nang tahasan, halimbawa, sa pagtuturo na "K = K + 1" 1 mayroong isang pare-pareho, o para sa kaginhawahan maaari silang italaga ng mga identifier: pi = 3.1415926536. Ibig sabihin lang pi hindi maaaring baguhin dahil ito ay isang pare-pareho, hindi isang variable.
Upang mapabuti ang pagiging produktibo at kalidad ng trabaho, kinakailangan na magkaroon ng data na mas malapit hangga't maaari sa mga tunay na analogue. Ang isang uri ng data na nagbibigay-daan sa ilang mga variable na maiimbak nang magkasama sa ilalim ng isang pangalan ay tinatawag nakabalangkas. Ang bawat programming language ay may sariling mga structured na uri. Isaalang-alang natin ang isang istraktura na pinagsasama ang mga elemento ng parehong uri ng data - isang array .
Array ay isang nakaayos na koleksyon ng mga dami ng parehong uri na may isang karaniwang pangalan, ang mga elemento nito ay tinutugunan (nakikilala) sa pamamagitan ng mga serial number (mga indeks). Bilang isang paglalarawan, maaari nating isipin ang isang kabinet na naglalaman ng maraming mga drawer na may numero (ang kabuuan ay "Kahon Blg. 1," "Kahon Blg. 2," "Kahon Blg. 3," atbp.; "Kahon" ang pangkalahatang pangalan ng lahat mga elemento nito). Ang pag-access sa mga nilalaman ng isang tiyak na kahon (elemento ng array) ay isinasagawa pagkatapos piliin ang kahon sa pamamagitan ng numero nito (index). Ang mga elemento ng isang array sa memorya ng computer ay naka-imbak sa malapit; ang mga solong elemento ng isang simpleng uri ay hindi nagpapahiwatig ng gayong pag-aayos ng data sa memorya. Ang mga array ay naiiba sa bilang ng mga indeks na tumutukoy sa kanilang mga elemento.
Isang-dimensional na hanay(isang cabinet ng mga drawer sa isang row) ay ipinapalagay na ang bawat elemento ay may isang index lamang. Ang mga halimbawa ng mga one-dimensional na array ay arithmetic at geometric sequence na tumutukoy sa may hangganan na serye ng mga numero. Ang bilang ng mga elemento sa isang array ay tinatawag sukat. Kapag tinutukoy ang isang one-dimensional na array, ang dimensyon nito ay nakasulat sa mga panaklong sa tabi ng pangalan nito. Halimbawa, kung ito ay nagsasabing: "ang array A(10) ay ibinigay," nangangahulugan ito na ang mga elemento ay ibinigay: A R A 2 ,…, a ig . Isaalang-alang natin ang mga algorithm para sa pagproseso ng mga elemento ng mga one-dimensional na array.
Ang mga elemento ng isang one-dimensional na array ay inilalagay sa bawat elemento, sa pagkakasunud-sunod na kinakailangan upang malutas ang isang partikular na problema. Karaniwan, kapag kailangan mong magpasok ng isang buong array, ang pagkakasunud-sunod kung saan ang mga elemento ay ipinasok ay hindi mahalaga, at ang mga elemento ay ipinasok sa pataas na pagkakasunud-sunod ng kanilang mga indeks.