Loogika ja programmeerimine (0)

Programmeerimise algkursus 91 - 91
Mida selle kursusel õpetatakse? 3
SISSEJUHATAV SÕNAVÕTT EHK 'MILLEKS ON VAJA PROGRAMMEERIMIST?' 3
PROGRAMMEERIMISE KOHT MUUDE MAAILMA ASJADE SEAS 4
PROGRAMMEERIMISKEELTE ÜLDINE JAOTUS 7
ESIMESE TEEMA KOKKUVÕTE 8
ÜLESANDED 9
PÕHIMÕISTED. OMISTAMISLAUSE. 9
9
SISSEJUHATUS 9
PROGRAMMEERIMISE MÕISTED 10
ARVUTIGA SEOTUD MÕISTED 14
OMISTAMISLAUSE 16
ÜLESANDED 19
ARITMEETILINE JA LOOGILINE AVALDIS . OPERAND JA OPERAATOR . 20
20
SISSEJUHATUS 20
20
AVALDIS 20
ÜLEVAADE ARITMEETILISTEST OPERAATORITEST 22
23
ÜLEVAADE LOOGILISTEST OPERAATORITEST 23
ÜLESANDED 24
STANDARDPROTSEDUURID ANDMETE SISESTAMISEKS JA VÄLJASTAMISEKS. 25
25
SISSEJUHATUS 25
STANDARDPROTSEDUURID ANDMETE VÄLJASTAMISEKS 28
STANDARDPROTSEDUURID ANDMETE SISESTAMISEKS 30
VÄLJUNDI VORMISTAMINE 33
ÜLESANDED 35
MÄRKUS TRANSLAATORITE KASUTAMISE KOHTA 35
TINGIMUSLAUSE . SUUNAMISLAUSE. VALIKULAUSE. 36
36
SISSEJUHATUS 36
TINGIMUSLAUSE 37
SUUNAMISLAUSE 39
VALIKULAUSE 40
ÜLESANDED 40
STRUKTUURSED ANDMETÜÜBID: JADA, MASSIIV , KIRJE, FAIL. 40
40
Sissejuhatus 40
Jada. Massiiv. Massiivi mõõtmed 41
Massiivi deklareerimine 41
43
Massiivi kasutamine 43
Kirje 44
44
Kirje deklareerimine 44
46
Kirje kasutamine 46
Fail 46
47
Faili deklareerimine 47
48
Faili kasutamine 48
ÜLESANDED 49
MÄÄRATUD KORDUS. EELKONTROLLIGA KORDUS. JÄRELKONTROLLIGA KORDUS. 49
SISSEJUHATUS 49
MÄÄRATUD KORDUS 50
EELKONTROLLIGA KORDUS 50
JÄRELKONTROLLIGA KORDUS 51
Korduslaused keeles Pascal 52
Korduslaused keeles C 52
Korduslaused keeles Qbasic 52
KORDUSLAUSETE KASUTAMINE 53
ÜLESANDED 56
Jada järjestamine 56
Minimaalseima väärtuse leidmine maatriksist 57
Suurima summaga rea leidmine maatriksist 57
VIITMUUTUJA. ARVUTI MÄLU PAINDLIK KASUTAMINE 57
SISSEJUHATUS 57
VIITMUUTUJA OLEMUS 57
VIITMUUTUJA KASUTAMINE 58
Viitmuutuja kasutamine keeles Pascal 59
Viitmuutuja kasutamine keeles C 59
MÄLU PAINDLIK KASUTAMINE 60
Mälu hõivamine 60
Mälu vabastamine 61
TÜÜPILISED KOMISTUSKIVID 62
DÜNAAMILISED ANDMESTRUKTUURID 63
Ahel ja järjekord 63
Pinumälu ehk magasinmälu 65
ÜLESANDED 67
ALAMPROGRAMMID . PROTSEDUUR JA FUNKTSIOON 67
MILLEKS ON VAJA ALAMPROGRAMME? 67
PROTSEDUURI JA FUNKTSIOONI ERINEVUSED 68
ALAMPROGRAMMIDE KASUTAMINE 68
Pascal 69
C 70
Qbasic 71
PARAMEETER 71
GLOBAALSED JA LOKAALSED MUUTUJAD 74
ÜLEVAADE STANDARDPROTSEDUURIDEST JA -FUNKTSIOONIDEST 75
Pascal 75
C 77
Qbasic 78
ÜLESANDED 79
Sissejuhatus 87
Struktuurprogrammeerimine 87
Objektorienteeritud programmeerimine 88
Objekt, atribuut, meetod 88
Klass 89
Kapseldumine 89
Sündmused ja teated 90
Pärilikkus ja polümorfism 90
Mis on kasu objektorienteeritusest? 91
Objektorienteeritud maailm 91

Mida selle kursusel õpetatakse?

Esimese astme materjalid on jaotatud 12-ks teemaks, millega kaasnevad ülesanded harjutamiseks. Nendeks teemadeks on:

Suurem sissejuhatav sõnavõtt ehk 'Milleks on vaja programmeerimist?'

Põhimõisted: andmetüüp, väärtus, konstant, muutuja , identifikaator , võtmesõna, operand, operaator. Omistamise lause.

Aritmeetiline ja loogiline avaldis.

Standardprotseduurid andmete sisestamiseks ja väljastamiseks.

Tingimuslause. Suunamislause. Valiklause.

Struktuursed andmetüübid: jada, massiiv, kirje, fail.

Määratud kordus. Eelkontrolliga kordus. Järelkontrolliga kordus.

Viitmuutuja. Arvuti mälu paindlik kasutamine.

Alamprogrammid. Protseduur ja funktsioon.

Programmide vormistamine. Identifikaatorite süstematiseerimine. Taanete kasutamine.

Programmi dokumenteerimine . Kommentaarid. Programmi projekteerimine. Programmi testimine .

Struktuurprogrammeerimise põhimõtted. Objektorienteeritud programmeerimise põhimõtted.
Esimesel tasemel kasutatakse näidetes samaaegselt kolme programmeerimise keelt, milleks on Pascal, C ja Basic . Siinkohal tahaks rõhutada, et antud kursuse eesmärgiks ei ole mitte programmeerimiskeele täiuslik omandamine, vaid programmeerimise oskuse omandamine - need kaks oskust on erinevad! Samuti on kursuse materjalidesse peidetud soov näidata, et samasse klassi kuuluvad programmeerimiskeeled on oma olemuselt samasugused.

SISSEJUHATAV SÕNAVÕTT EHK 'MILLEKS ON VAJA PROGRAMMEERIMIST?'

PROGRAMMEERIMISE KOHT MUUDE MAAILMA ASJADE SEAS

Masinad ja nende juhtimine

Oli kord aeg, mil inimene tegi tööd vaid käsitsi. Ta võttis küll kasutusele töövahendid oma töö kergendamiseks, kuid tänapäevases mõttes tegi ta tööd ikkagi käsitsi. Mõningate jõudu nõudvate tööde tegemiseks hakkas ta kasutama loomi, hiljem masinaid, kuid ilma inimese juuresolekuta saadi hakkama vaid väga vähestes kohtades - nii loomad kui ka masinad vajasid juhtimist. Kujutame seda järgneva joonisega:
--------- juhtimine -----------
| Masin | tegevus ei muuda muutuja väärtust
| Muutuja |
| | A
B = A 10 10 ? A -> 10 -> B
C = A 10 10 10 A -> 10 -> C
------------------------------------------------------------------
Sellest tabelist võib näha, et konstandi väärtuse omistamisel muutujale kirjutatakse väärtus 10 muutujanimega A tähistatud mälupesa(de)sse. Muutuja väärtuse omistamisel teisele muutujale toimub esiteks väärtuse 10 lugemine muutujanimega A tähistatud mälupesa(de)st ja seejärel selle väärtuse kirjutamine muutujanimega B tähistatud mälupesa(de)sse. See on sellise protsessi tegelik kirjeldus. Edaspidi räägime ainult, et "muutuja A väärtus omistatakse muutujale B".
Kellele see jutt ikkagi segasena tundus, sellel soovitan kodus mängida järgmiste reeglite järgi:

muutujaks on tühi tikutops;

muutuja nimeks on tikutopsile peale kirjutatud täht või nimi;

väärtuseks on selline paberitükk, mis mahub tikutopsi ja mille peal on vastav arv;

tikutopsis tohib korraga olla vaid üks paberitükk;

muutujale väärtuse omistamine on samaväärne tegevusega , kus vastava arvuga paberitükk asetatakse tikutopsi, kuid vastavalt reeglile (4) võetakse sealt eelmine paberitükk välja (kui see seal oli);

muutujast väärtuse lugemine on samaväärne ühe uue paberitüki võtmisega ja sinna muutujaga samasuguse väärtuse peale kirjutamisega.
Tehes täpselt nende reeglite järgi, saate Te modelleerida operatsioone muutujatega ilma otseselt arvutit kasutamata. Ja ärge unustage, et kui mänguruum hakkab kitsaks jääma, siis võite ju endale uue muutuja deklareerida (kui muidugi tikutopsid otsas ei ole ;-).

Omistamislause keeles Pascal

Keeles Pascal on omistamislause süntaks järgmine:
':='
Et eristada üksteisele järgnevaid lauseid , pannakse nende vahele semikoolon ';', välja arvates mõned erijuhud . Eelnev näide keeles Pascal näeb välja niisugune:
A := 10;
B := A;
C := A;

Omistamislause keeles C

Keeles C on omistamislause süntaks järgmine:
'=' ';'
Eelnev näide keeles C näeb välja niisugune:
A = 10;
B = A;
C = A;

Omistamislause keeles Basic

Et programmeerimiskeeli, mille nimes esineb sõna "Basic" on suhteliselt palju ja süntaksi poolest pisut erinevaid, siis valisin välja ühe sellise, mida levitatakse koos operatsioonisüsteemiga MS-DOS 6.2 ja selle nimi on MS-DOS QBasic 1.1. Samasugust süntaksit kasutab ka Visual Basic.
Keeles QBasic on omistamislause süntaks järgmine:
[ 'LET' ] '='
Nurksulud eelnevas definitsioonis tähendavad, et nurksulgude vahel olevad sümbolid võib ära jätta, need ei ole kohustuslikud.
Eelnev näide keeles QBasic näeb välja niisugune:
A = 10
B = A
C = A

ÜLESANDED

Selle teema kohta on erinevaid ülesandeid küllaltki raske välja mõelda, mingis mõttes on nad ikka sarnased ja eesmärk on neil samuti ühine - kontrollida, kas Te olete muutuja mõistest aru saanud või mitte. Väga tahaksin rõhutada, et kui Teil mõnest mõistest arusaamisega raskusi on, siis tingimata küsige kellegi oskaja käest nõu.

See ülesanne on mõnes mõttes klassikaline, kuid ma ei tahtnud esitada seda kui näidet. Niisiis, on antud kaks muutujat nimedega A ja B ning väärtustega vastavalt 10 ja 20 (või mis tahes). Mida peab tegema, et vahetada muutujate A ja B väärtused omavahel ära?
Kui Te jääte selle ülesande lahendamisel hätta, siis siin on väike vihje.

On antud viis muutujat A, B, C, D ja E ning nende väärtused vastavalt 7, 1, 4, 9 ja 2. Tehke vastavad muutujate väärtuste omistamised selleks, et muutujate A kuni E väärtused oleksid kasvavas järjekorras. Leidub lahendus, mis nõuab 5 omistamislauset.

See ülesanne on eriti neile, kes esimesest kahest ülesandest mängleva kergusega jagu said. Mis muidugi ei tähenda, et teised seda lahendada ei võiks ;-)
Ehitati selline arvuti, millel on andmete hoidmiseks väga suur tekstirea kujuline mälu. Sisendandmed pannakse enne töö algust sellesse ritta ja tulemused võetakse sealtsamast tekstireast pärast programmi töö lõppemist. Sellise arvuti programm asub eraldi ja koosneb lausetest kujul
'(' ',' sqrt (a^2+b^2)

Operand ja operaator

Avaldise väärtuse leidmise puhul tuleb meil tihti rääkida tehete ehk operatsioonide sooritamisest. Sellest tuleneb ka kaks uut mõistet - operand ja operaator. OPERAATOR on see, kes või mis sooritab talle spetsiifilise operatsiooni. OPERAND on see väärtus, millega operaator oma operatsiooni sooritab.
Matemaatikas on üheks tuntumaks operaatoriks plussmärk ehk liitmisoperaator . Nii nagu nimigi ütleb, on plussmärgi tegevuseks kahe väärtuse kokkuliitmine. Me ütleme "kaks pluss kolm on viis" ja mõistame selle lause all seda, et kui liita kokku väärtused 2 ja 3, siis tulemuseks saame väärtuse 5.
Plussmärgi ja liitmisoperaatori samastamine tuleneb meie kooliharidusest. Kui õpetaja koolis esimesest klassist alates õpetaks, et pluss tähistab kahe arvu kõrvutiasetamist ehk "2 + 3 on 23", siis kooli lõpetades te selle peale enam ei mõtleks ja võtaksite seda kui iseenesest mõistetavat tõsiasja.
Liitmisoperaatorit võib kujutada ka funktsioonina LIIDA(a,b). Siis on täiesti samaväärne, kas me kirjutame
1 + 2 + 3
või
LIIDA(1, LIIDA(2,3)),
tulemuseks on mõlemal juhul väärtus 6 (funktsiooni LIIDA väärtus arvude 2 ja 3 puhul on 5).
Operaatoreid on mitmesuguseid. Meile tuntumad on operaatorid , mis nõuavad kahe operandi olemasolu. Esineb ka ühe operandiga operaatoreid. Näiteks arvu astendamise operaator on kahe operandiga ( 2^10 ), arvu märgi muutmise operaator aga ühe operandiga ( -5 ). Eelmises teemas käsitletud omistamise märk on ka operaatori tunnustega. Seda võib nimetada omistamisoperaatoriks, mille tegevuseks on avaldise väärtuse kirjutamine muutujasse.
Programmeerimiskeeltes eristatakse kahte liiki avaldisi - aritmeetilisi avaldisi, mille tulemuse väärtuseks on arv ja loogilisi avaldisi, mille tulemuseks on tõeväärtus.

Aritmeetiline avaldis

Aritmeetilises avaldises kasutatakse eeskätt arvutüüpi andmeobjekte ja aritmeetilisi tehtemärke. Ka võib aritmeetilises avaldises kasutada arvutüüpi funktsioone. Kõik eespool toodud näited avaldiste kohta on olnud aritmeetilised avaldised .

Loogiline avaldis

Loogiline avaldis sisaldab ühte või enamat loogilist operaatorit ja võib tihti sisaldada aritmeetilisi avaldisi. Matemaatikast tuntud loogiline avaldis on võrratus, mille puhul on tulemuseks samuti tõeväärtus:
2 tõene
2 = 8 ==> väär
x + 3 > 10 ==> tõene, kui x >= 8, muidu väär
Lisaks operaatoritele, mida kasutatakse operandide võrdlemiseks, on loogilistes avaldistes kasutusel loogikatehted JA (loogiline korrutamine ehk konjunktsioon ), VÕI (loogiline liitmine ehk disjunktsioon ), POLE (loogiline eitus ehk negatsioon) ja mõned teised. Need tehted jäävad kahjuks väljapoole meie koolide matemaatika programmi, kuid programmeerimine ilma neid kasutamata läbi ei saa. Loogikatehetest saab kõige paremini aru, kui õppida selgeks vastavad tõeväärtustabelid ( analoogia korrutustabeliga, see tuli ka pähe õppida):
JA | tõene | väär | Selgituseks :
------################# (tõene JA tõene) on tõene
tõene # tõene | väär # (tõene JA väär) on väär
------#-------+-------# (väär JA tõene) on väär
väär # väär | väär # (väär JA väär) on väär
------#################
VÕI | tõene | väär | Selgituseks:
------################# (tõene VÕI tõene) on tõene
tõene # tõene | tõene # (tõene VÕI väär) on tõene
------#-------+-------# (väär VÕI tõene) on tõene
väär # tõene | väär # (väär VÕI väär) on väär
------#################
POLE | tõene | väär | Selgituseks:
------################# (POLE tõene) on väär
# väär | tõene # (POLE väär) on tõene
------#################
Seega, loogiline avaldis kujul
(A 10)
on tõene ainult siis, kui mõlemad tingimused on tõesed.

ÜLEVAADE ARITMEETILISTEST OPERAATORITEST

Alljärgnevalt teen ma väikese ülevaate aritmeetilistest operatsioonidest. See ülevaade ei ole kaugeltki täielik, kuid see ei olegi antud juhul eesmärgiks. Operatsioonid on järgnevas tabelis esitatud prioriteedi (tehete järjekorra tähtsuse) kahanemise järjekorras. See tähendab, et märgi muutmine tehakse alati enne kui astendamine või korrutamine ja korrutamine omakorda eelneb liitmisele või lahutamisele.
Sellest tulenevalt on avaldise 2 + 7 * 3 väärtuseks 23 mitte 27.
Operatsiooni nimetus | operandi tüüp | tulemuse tüüp | operande
------------------------+------------------+---------------------+---------
märgi muutmine | täisarv, reaalarv | sama, mis operandil | 1
astendamine | täisarv,reaalarv | sama, mis operandil | 2
korrutamine | täisarv,reaalarv | sama, mis operandil | 2
jagamine | täisarv,reaalarv | sama, mis operandil | 2
täisarvuline jagamine | täisarv | täisarv | 2
jagamise jäägi leidmine | täisarv | täisarv | 2
nihutamine paremale | täisarv | täisarv | 2
nihutamine vasakule | täisarv | täisarv | 2
liitmine | täisarv,reaalarv | sama, mis operandil | 2
lahutamine | täisarv,reaalarv | sama, mis operandil | 2
Kui operatsioonist võtavad osa nii täisarvud kui ka reaalarvud , siis harilikult on tulemuseks reaalarv.

Aritmeetilised operaatorid keeles Pascal

Operatsiooni nimetus | operandi tähis
------------------------+---------------
märgi muutmine | -
astendamine | puudub, kasutatakse funktsioone: sqr(x)=>x ruudus
korrutamine | *
jagamine | /
täisarvuline jagamine | DIV
jagamise jäägi leidmine | MOD
nihutamine paremale | SHR ; (5 SHR 1) on sama, kui (5 DIV 2)
nihutamine vasakule | SHL ; (5 SHL 1) on sama, kui (5 * 2)
liitmine | +
lahutamine | -

Aritmeetilised operaatorid keeles C

Operatsiooni nimetus | operandi tähis
------------------------+---------------
märgi muutmine | -
astendamine | puudub, kasutatakse funktsiooni: pow(x,y)
korrutamine | *
jagamine | /
täisarvuline jagamine | /
jagamise jäägi leidmine | %
nihutamine paremale | >>
nihutamine vasakule | =
väiksem kui | =
väiksem kui | =
väiksem kui | 100% ja 350 tonni --> 12,5%.
Nende andmete põhjal kirjutame võrrandi, kus küsitud koguse tähistame tähega K:
K 100
--- = ---- ehk (K/350)=(100/12,5).
350 12,5
Sellest võrrandist avaldame K:
K = (100/12,5)*350 = 2800.
Seega on konkreetse ülesande vastus 2800 tonni.
Ja kus on siin programmeerimine? Asi on nimelt selles, et arvuti ei ole võimeline sellist ülesannet lahendama. Küll aga on arvuti võimeline etteantud programmi alusel arvutusi tegema. Seega antud ülesannet lahendav programm oleks järgmine:
P r o g r a m m N1.1
K = (100/12.5)*350
VÄLJASTA K
Või saab kasutada ka üherealist programmi:
P r o g r a m m N1.2
VÄLJASTA (100/12.5)*350
Seega, Teie lahendate ülesannet, arvuti teostab arvutused - selline on tööjaotus. Selles väikeses üherealises programmis tähistab sõna 'VÄLJASTA' standardprotseduuri sellele sõnale järgneva väärtuse väljastamiseks väljundseadmele.
Täiesti kohane on küsimus, et milleks on vaja sellist programmi, mis lahendab ainult üht konkreetset ülesannet?
Õigustatud on selline programm siis, kui kalkulaatorit pole käepärast ja peast arvutada ei viitsi. Palju kasulikum on aga selline programm, mis lahendab selle ülesande kõikvõimalikke variante, see tähendab ülesannet, mille sõnastus võiks olla järgmine:
NÄIDE 2.
Ü l e s a n n e
Saadava suhkru mass moodustab P % töödeldava suhkrupeedi kogusest. Kui palju on vaja suhkrupeeti X tonni suhkru saamiseks?
L a h e n d u s
Avaldame K analoogiliselt eelmisele näitele:
K = (100/P)*X
Selleks, et leida suurus K, on meil vaja teada suurusi P ja X. Programmeerimise kontekstis öelduna tähendab see seda, et muutuja K väärtuse leidmiseks on meil tarvis omistada muutujatele P ja X väärtused. Eelmise näitega samaväärse programmi saame, kui omistame neile muutujatele eelmises ülesandes püstitatud väärtused:
P r o g r a m m N2.1
P = 12.5
X = 350
K = (100/P)*X
VÄLJASTA K
Lisaks omistamislausele leidub veel teinegi võimalus muutujale väärtuse omistamiseks - see on väärtuse sisestamine standardprotseduuri abil. Tähistame sellist protseduuri sõnaga ' SISESTA ' ja kirjutame programmi, mis aitab meil lahendada kõiki teise näite alla kuuluvaid ülesandeid:
P r o g r a m m N2.2
SISESTA P
SISESTA X
K = (100/P)*X
VÄLJASTA K
Standardprotseduur 'SISESTA' töötab harilikult järgmise algoritmi järgi:

Loeme kokku klaviatuurilt sisestatud sümbolid, kuni vajutatakse reavahetuse klahvi (' Return ' või 'Enter').

Kui sisestatud sümbolid moodustavad väärtuse, mis sobib kokku protseduuri väljakutsega kaasa antud muutuja tüübiga, siis omistame saadud väärtuse sellele muutujale, vastasel korral teatame kasutajale, et sisestatud väärtusel ei ole sobiv andmetüüp.
Tegelikes programmeerimisekeeltes on see algoritm tihti keerulisem kui eelkirjeldatu, kuid üldine põhimõte on sama.
Kõiki programme võib üldjuhul vaadelda koosnevana kolmest osast:
1) andmete sisestamine;
2) andmete töötlemine;
3) andmete väljastamine.
Erandjuhtudel võib olla programm ilma andmesisestuseta, nagu programmid N1.1 ja N1.2. Veelgi harvemini võib tulla ette programme, millel ei ole andmete väljastamist. Selline olukord viitab kasutule programmile, sest mida see ka ei teeks , tulemusi selline programm ei esita.
Vaatleme nüüd järgnevalt, milliseid võimalusi andmete sisestamiseks ja väljastamiseks pakuvad kursusel kasutatavad programmeerimiskeeled ning mida andmete sisestamine ja väljastamine tegelikult tähendavad.

STANDARDPROTSEDUURID ANDMETE VÄLJASTAMISEKS

Andmete väljastamise olemus

Andmete väljastamisel leitakse etteantud avaldise väärtus ja kirjutatakse see väljundvoogu.
VÄLJUNDVOOG on programmeerimises kasutatav üldistus kõigi andmete kohta, mis liiguvad programmist väljundseadmele. Tüüpiliselt on väljundvoog suunatud kuvari ekraanile . Enamikus programmeerimiskeeltest loetakse seda standardseks väljundvooks ja kui ei ole kuidagi teistmoodi defineeritud, siis kasutatakse seda. Kuid väljundvoo sihtpunktiks võib olla ka kettal paiknev fail või printer.

Andmete väljastamine keeles Pascal

Väljastamiskäsu süntaks keeles Pascal on järgmine:
'WRITE' '(' ')' |
'WRITELN' [ '(' ')' ]
avaldiste_loetelu -> [ ',' ]
Protseduuride 'Write' ja 'WriteLn' erinevus seisneb selles, et viimane viib väljastamise järjekorra uuele reale ehk teeb reavahetuse.
P r o g r a m m N1.1.P
Program N1_1_P; { Programmi algusesse kirjutame programmi nime. }
Var { Keeles Pascal on vaja kõik muutujad deklareerida.}
K : Real ; { Ütleme, et K on reaalarvu tüüpi muutuja.}
Begin { Põhiprogrammi algus }
K := (100/12.5)*350; { 'Andmetöötlus' }
Writeln(K); { Väljasta tulemus }
End. { Põhiprogrammi lõpp. NB! Lõpus peab olema punkt! }
Nagu Te ehk juba taipasite, kirjutatakse keeles Pascal kommentaarid loogeliste sulgude ( '{' , '}' ) vahele.

Andmete väljastamine keeles C

Väljastamiskäsu süntaks keeles C on järgmine:
'printf' '(' ',' ')' ';'
Keeles C tuleb tähele panna, et suured ja väikesed tähed on translaatori jaoks erinevad. Nii võib defineerida muutujad nimedega 'k' ja 'K' ning kasutada neid samaaegselt. Sellegipoolest ei ole see soovitatav, sest võib põhjustada valestimõistmist ja programmeerijapoolseid vigu. Küll aga tuleb veateadete korral, mis väidavad muutuja 'p' puudumist, kontrollida, kas ei peaks 'p' asemel olema kasutatud muutujat 'P'. Selliseid näpukaid tuleb kõigil ette, eriti aga algajatel.
P r o g r a m m N1.1.C
# include /* Ütleme, et on vajalik lugeda päisfaili
' stdio .h'. Selles asuvad C standartsete sisend -
väljundfunktsioonide kirjeldused. /*
main() /* Põhiprogrammi algus */
float K; /* Ütleme, et K on reaalarvu tüüpi muutuja. */
K = (100/12.5)*350; /* 'Andmetöötlus' */
printf("%f", K); /* Väljasta tulemus */
} /* Põhiprogrammi lõpp. */
Kommentaarid kirjutatakse sümbolipaaride '/*' ja '*/' vahele.
Kontrollstringi abil on võimalik kujundada väljundit. Sellest tuleb juttu allpool.

Andmete väljastamine keeles Qbasic

Väljastamiskäsu süntaks keeles QBasic on järgmine:
' PRINT ' |
'WRITE'
avaldiste_loetelu -> [ ( ',' | ';' ) ]
Väljastusprotseduur 'Write' erineb protseduurist 'Print' selle poolest, et kirjutab väljastatud väärtuste vahele komad ja stringide ümber jutumärgid. Käsuga 'Write' väljastatud andmete formaat on kokkusobiv sisestusprotseduuri 'Input' sisendformaadiga.
P r o g r a m m N1.1.B
K = (100/12.5)*350 ' Andmetöötlus
print K ' Väljasta tulemus
Kommentaarid kirjutatakse rea lõppu ühekordse apostroofi järele.

STANDARDPROTSEDUURID ANDMETE SISESTAMISEKS

Andmete sisestamise olemus

Nagu ma juba eespool märkisin, on andmete sisestamine veel üheks meetodiks muutujale väärtuse omistamisel. Kui omistamislause saab väärtuse avaldiselt, siis sisestamisprotseduur saab väärtuse sisendandmete voost ehk sisendvoost.
SISENDVOOG on programmeerimises kasutatav üldistus kõikide programmi sisestatavate andmete kohta. Tüüpiliselt saabub sisendvoog klaviatuurilt. Enamikus programmeerimiskeeltest loetakse seda standardseks sisendvooks ja kui ei ole kuidagi teistmoodi defineeritud, siis kasutatakse seda. Kuid sisendvoo lähtepunktiks võib olla ka kettal paiknev andmefail või mõni sisendseade.
Iga sisestamisprotseduuri väljakutse loeb sisendvoost järgmise hulga informatsiooni ja omistab selle etteantud muutujale. Sissejuhatuses esitatud programmis N2.2 käsu 'SISESTA P' tegevust võib kirjeldada järgmiselt:
1) Loeb kasutaja klahvivajutusi kuni vajutatakse klahvi [Enter] (mõnel klaviatuuril on selleks [Return]). Iga klahvivajutusega kaasneb vastava sümboli väljastamine kuvari ekraanile (kuid on ka selliseid sisestusprotseduure, mis sümboleid ei väljasta).
2) Teisendab kogutud klahvivajutused väärtuseks. Antud näite korral me eeldasime, et vajutati ainult punkti ja numbreid tähistavatele klahvidele, seega on sisestatud väärtus reaalarvu tüüpi.
3) Omistab saadud väärtuse muutujale P.
Sisendprotseduur võib ühe väljakutse ajal sisestada