ON OFF

  1. Klase kā viens no objektorientētās programmēšanas pamatjēdzieniem.

    Klase ir objekta tipa apraksts, kas ietver sevī iekšējo mainīgo deklarēšanu un iekšējo funkciju aprakstu, kā arī pieejas tiesību definēšanu mainīgajiem un funckijām.

    Uz klases metodēm, tāpat kā uz parastajām funkcijām attiecas pārslogošana (overloading),t.i., iespēja izmantot vienu nosaukumu vairāku metožu nosaukšanai.

    Līdz ar jēdzienu klase, blakus jau zināmajiem - globālo un lokālo redzamības apgabalu (scope) parādās jauns redzamības apgabals - klases redzamības apgabals. Atrašanās klases redzamības gabalā nozīmē to, ka iekšējais mainīgais vai funckija ir redzami tikai dotā objekta ietvaros.

    Klases redzamības apgabalā atrodošies mainīgie un funckijas pēc pieejamības (accesability) iedalās šādās 3 grupās:

    • publiskie jeb atklātie (public), kas ir pieejami arī no ārējiem moduļiem,
    • privātie jeb slēptie (private), kas ir pieejami tikai no klases iekšējām funkcijām, kā arī no funkcijām vai klasēm, kas dotajai klasei definētas kā draudzīgās (friend),
    • aizsargātie(protected), kas pieejami arī no mantotajām (inherited) klasēm.

    Specifikatori public, private un protected darbojas no pieminēšanas brīža vai nu līdz nākošajam specifikatoram, kas to atceļ, vai nu līdz klases galvas beigām, ja vairs nav neviena specifikatora. Turklāt no klases galvas sākuma, ja nav uzrādīts savādāk, pēc nokušēšanas darbojas private. Šie 3 specifikatori, lietoti klases galvā, sadala klases galvu sektoros, kur katrā sektorā ir noteitks vienots pieejamības līmenis.

    Principu, ka objektā var eksistēt elementi, kas nav pieejami no ārējiem moduļiem (ne-publiski elementi), tātad, ir pieejami tikai caur citām - publiskām, metodēm, sauc par inkapsulāciju (encapsulation), kas ir viens no galvenajiem objektorientētās programmēšanas principiem.

    Klasi definē izmantojot vienu no trijiem atslēgas vārdiem class, struct, union.

  2. Objekta jēdziens objektorientētajā programmēšanā.

    Objekts (object) programmā ir datu kopums kopā ar tām piesaistītajām darbībām. Datus objektā reprezentē lauki (fields) jeb ieksējie mainīgie (member variables), bet darbības reprezentē metodes (methods) jeb iekšējās funkcijas (member functions).

    Objekti programmā var parādīties divos veidos, kas atšķiras pēc sintakses un atmiņas izmantošanas:

    • tiešā veidā (izmantojot automātisko atmiņu),
    • dinamiskā veidā.s

    Tiešā veidā izmantot objektus ir ļoti ērti no sintakses viedokļa. Tai pat laikā citās programmēšanas valodās (piemēram Java) tiešā objektu izmantošana vispār nav iespājama, tā ir valodas C++ specifika un neapšaubāmi - priekšrocība,

    Objektu reprezentā mainīgais ar tipu "klase", un pieķluve objekta elementiem (laukeim un metodēm) notiek, izmantojot punkta notāciju(.). Objekts tiek automātiski izveidots pie mainīgā deklarēšanas un automātiksi beidz pastāvēt programmas bloka beigās (kā tas pienākas "normāliem" lokālajiem mainīgajiem).

    Jēga izmantot dinamiskus objektus ir tāda pati, kāda izmantot jau iepriekš apskatītos dinamiskos masīvus - lai dotu lietotājam (programmētājam) iespēju papildus kontrolēt resursu (šajā gadījumā, atmiņas)izmantošanu.

    Objektu reprezentē mainīgais ar tipu "norāde uz klase", un piekļuve pie objekta elementiem (laukiem un metodēm) notiek, izmantotjot bultiņas notāciju(->). Objekts tiek izveidots, izmantojot operatoru new un likvidēts ar delete.

    Daudzās citās programmēšanas valodās (Java, Basic) šis ir vienīgais iespējamais objektu izmantošanas veids (tiešā veida nemaz nav), tai pat laikā uzskatāmības dēļ šajās valodās bultiņas notācijas vietā tiek lietota punkta notācija, kas neapšaubāmi ir ērtāk lasāma un vieglāk uztverama.

  3. UML klašu un objektu diagrammas.

  4. UML aktivitāšu diagrammas.

  5. Atslēgvārdi private, public, protected.

    Šie atslēgvārdi norāda klases redzamības apgabalā esošo funkciju un lauku pieejamību (accesability). Tos iedala šādi:

    • publiskie jeb atklātie (public), kas ir pieejami arī no ārējiem moduļiem,
    • privātie jeb slēptie (private), kas ir pieejami tikai no klases iekšējām funkcijām, kā arī no funkcijām vai klasēm, kas dotajai klasei definētas kā draudzīgās (friend),
    • aizsargātie(protected), kas pieejami arī no mantotajām (inherited) klasēm.

  6. Konstruktors.

    Konstruktors(constructor) ir specifiska klases iekšējā funkcija, kas automātiski (netieši) tiek izsaukta uzreiz pēc objekta izveidošanas.

    No vienas puses, konstruktors ir tāda pati vien metode, kā citas, no otras puses, konstruktoram ir pietiekoši daudz atšķirību no citām metodēm:

    • konstruktora izsaukšana notiek īpašā veidā;
    • īpaša sintakse;
    • īpaša shēma konstruktoru mantošanā;

    Valodā C++ konstruktors tiek saukts klases vārdā, tam tiek padotas vērtības, ar kurām inicializēt jaunizveidoto objektu.

    Klasē var būt vairāki konstruktori, un tie, tāpat kā citas funkcijas ar vienādu nosaukumu, atšķiras pēc paramaetru virknes. Ja objekts tiek izmantots tiešā veidā, tad konstruktors tiek izsaukts pie objekta deklarēšanas. Ja konstruktoram nav parametru, tad tukšās iekavas var nelikt. Ja objekts ir dinammisks, tad konstruktors tiek netiešā veidā izsaukts, izsaucot operatoru new.

    Noklusētais konstruktors tā kā katrā klasē ir jābūt vismaz vienam konstruktoram, tad kompilators automātiski izveido noklusēto konstruktoru (default constructorM) bez parametriem ar tukšu ķermeni (resp., kurš neko nedara).

    Ja klasē ir definēts (uzprogrammēts) kaut viens konstruktors, tad noklusētais konstruktors automātiski netiek veidots un, ja ir nepieciešamība pēc konstruktora bez parametriem, tad tas obligāti jādefinē pašam programmētājam.

    Kopijas konstruktors ir viens no svarīgākajiem konstruktoru veidiem, un tam ir ļoti specifiska nozīme. Kopijas konstruktors ar vienu parametru, kura parametrs ir ar tipu reference vai konstanta reference uz šīs pašas klases objektu.

    Kopijas konstuktora būtība ir dot iespēju izveidot vienu objektu pēc cita objekta parauga.

    Kopijas konstruktoru bez parastā izmantošanas veida, izsauc vēl šādos gadījumos:

    • inicializējot objektu ar citu objektu pie deklarēšanas;
    • nododot objektu (bet nevis tā referenci) kādai funkcijai kā parametru - tādā gadījumā funkcijas vajadzībām tiek veidots jauns lokāls objekts, izsaucot kopijas konstruktoru.

  7. Destruktors.

    Destruktors (destructor) ir specifiska klases iekšējā funckija, kas automātiski tiek izsaukta tieši pirms objekta likvidēšanas.

    Destruktora nosaukums valodā C++ ir vienāds ar klases nosaukumu, kam priekšā pielikts tildes simbols "~"(piemēram, ~foo) Destruktoram nav parametru, tādējādi klasei var būt tikai viens destruktors.

    Ja par konstruktoru ir diezgan skaidrs, kāoēc tam atrasties katrā klasē, tad destruktoram ir jēga tikai tad, ja klase izmanto kaut kādus dinamiskus resursus, kuri, objektam likvidējoties, ir jāatbrīvo (piemēram, jāatbrīvo dinamiski izdalītā atmiņa vai jāaizver fails).

    Destruktora izsaukšana atšķiras atkarībā no objekta izmantošanas veida.

    • Ja objekts tiek izmantots tiešā veidā, tad destruktors tiek automātiski izsaukts tā blokga beigaš, kad objekts deklarēts.
    • Ja objekts ir dinamisks, tad destruktors tiek netiešā vediā izsaukts ar operatoru delete.

  8. Hedera faili.

    Hedera (header) faili tiek izmantoti, kad ir nepieciešamība pēc programmas dalīšanas vairākos failos. Hedera failos parasti tiek definēti klases, tās metožu kā arī parastu funkciju prototipi. Šis fails, savukārt, tiek iekļauts (ar "#include "foo"") failos, kur klases un funkcijas tiek izmantotas, kā arī failos, kur šīs klases un funkcijas ir nodefinētas.

  9. Rādītāja (norādes) mainīgie.

    Norāde (pointer) ir mainīgais (vai cits mehānisms), kas glabā (nosaka) atmiņas adresi.

    Adrese (adress) ir vērtība, kas apzīme noteiktu vietu atmiņā.

    Norādes mainīgos parasti raksturo zvaigznīte (*) piet to deklarēšanas, vienīgais izņēmums ir statiski masīvi, kas tiek deklarēti, izmantojot kvadrātiekavu notāciju, tomēr savā būtībā arī ir norādes (kaut arī ar ierobežotām iespējām.)

    Adrese ir tehnisks jēdziens, kas domāts programmas iekšējām vajadzībām, tāpēc norāžu saturu tiešā veidā parasti nemēdz interpretēt.

    Deklarējot norādi, ir svarīgi norādīt, uz kāda tipa vērtību norāda mainīgais. tam vislielākā nozīme ir nevis pašā adrešu apstrādē, bet gan, veicot apstrādi pēc adreses iegūtajiem datiem (piemēram, masīva no veseliem skaitļiem tips ir int*, t.i. "norāde uz int", kas nozīmē, ka masīva elementi jāapstrādā kā int tipa vērtības.)

    Ir iespējams nolikt norādi arī citā masīva vietā (atšķirībā no tā sākuma pozīcijas). Norādes pārvietošanu vai novietošana iespējama gan, izmantojot adreses ņemšanas operatoru &, gan adresu aritmētiku, pielietojot adreses mainīgajam aritmētiskas operācijas.

    Masīva mainīgais nav vienīgasi norādes paveids. Norādes ir universāls līdzeklis datu pārvaldīšanai atmiņā. Saistībā ar norādēm izšķir 2 pretējas darbības:

    • adreses iegūšana noteiktam atmiņas apgabalam pēc to repzentējošā mainīgā, izmantojot adreses ņemšanas operatoru & (nesajaukt ar referenci);
    • vērtības iegūšana pēc adreses (nesajaukt ar norādes mainīgā deklarēšanu);
    Vērtības iegūšana pēc adreses notiek, pirms norādes liekot zvaigznītes operatoru *

    Bez masīviem un simbolu virknēm norāžu mainīgos parasti izmanto dinamiskās datu struktūrās, kas tiks aprakstītas vēlāk.

  10. Dinamiska atmiņas pieprasīšana un atbrīvošana.

    Dinamiski atmiņa tiek izmantota tad, kad programmētājs vēlas pilnu kontroli pār programmas izmantotajiem resursiem. Visbiežākie dinamiskie atmiņas izmantošanas veidi ir dinamiski masīvi, kuriem ir pieejama indeksa notācija, saistīti dinamiski saraksti (tai skaitā dažādi koki), kā arī objekti.

    Lai strādātu ar objektiem un masīviem dinamiski tiek izmantotas norādes, kas ir ar tādu pašu tipu kā objekts. Jauns objekts tiek izveidots ar komandu new. Lai nenotiktu atmiņas noplūde (memory leak) programmas darbības laikā, kas var rezultēties ar programmas crash'u pēc tam, kad programma beidz darbu, vai pieprasītā atmiņa nav nepieciešama programmas darbības laikā, izmantotā atmiņa ir jāatbrīvo ar komandu delete.

  11. This rādītājs.

    Jebkura klases metode (kas nav statiska) var piekļūt objektam, kuram tā ir izsaukta. To var izdarīt ar speciālu norādes mianīgo this, kur tips ir klases_vards*. Prasti norāde this nav nepieciešama, jo klases metodēm ir tieša piekļuve dotā objekta elementiem. Tomēr atsevišķos gadījumos bez tās nevar iztikt, piemēram, lai nodotu objektu kādai ārējai funkcijai.

    
        #include <iostream>
        using namespace std;
    
        class person;
        void print_external (const person&);
    
        struct person
        {
            string name;
            int age;
            void print () const { print external (*this);};
        };
        int main()
        {
            person p;
            p.name = "Liz";
            p.age = 19;
            p.print ();
            return 0;
        };
        void print_external (const person &p)
        {
            cout << p.name << " " << p.age << endl;
        }
    
  12. Kaskadēta metožu izsaukšana.

    Kaskādēta metožu izsaukšana nozīmē, ka drīkst izsaukt vairākas metodes šādā veidā:

    someObject.firstMethod().secondMethod().thirdMethod(); Lai šis darbotos, pirmajai metodei ir jāatgriež tāds obejkts ar kuru varētu izsaukt otro metodi, bet otrajai metodei ir jāatgriež tāds objekts ar kuru varētu izsaukt trešo metodi.

    Visplašāk kaskādēta metožu izsaukšana ir novērojama pie datu izvades << un izvades >> . Tā kā operators "<<" atgriež std::cout objektu ir iespējams saķēdēt bezgalīgi garu virkni kopā.

  13. Operatoru pārslogošana (operator overloading).

    Valodā C++ ļoti plaši pielieto operaotrus, turklāt ir iepsēja tos, līdzīgi funkcijām, pārslogot, tādējādi pielāgojot darbam ar dažādiem tipiem. Pārslogot var gandrīz jebkuru operatoru, izņemot šos:

    . .* :: ?:

    Sintaktiski iespēju pārslogot nodrošina operatoru funkcionālais pieraksts, kurā operators tiek izsaukts vai definēts kā parasta funkcija un līdz ar to arī pāslogojams ā parasta funkcija(ar nelielām specifiskām niansēm).

    Operatora funkcionālais nosaukums sastāv no atslēgas vārda operator, kas seko operetora simbols vai simboli, piemēram, operator+ operator*= operator() operator[]. Piemēram rindiņa c = a + b; funcionālajā pierakstā izskatās šādi: c = operator+ (a,b);

    Operatoru pārslogošanai ir vairāki ierobežojumi un noteikumi:

    • operatoru prioritātes un asociatīvās īpašības saglabājas un nav maināmas;
    • operatoru uzvedība nav pārdefinējama iebūvetajiem tipiem (piemēram int);
    • pārdefinētajam operatoram jābūt saistītam ar lietotāja izveidotu klasei (vai u jābūt šīs klases iekšējam operatoram, vai arī klasei jābūt par kāda parametra tipu);
    • operatoriem nevar būt noklusētie parametri;
    • operatori, tāpat kā citas funkcijas, mantojas, izņemot operatoru =

    Operatoru pārslogošana ir samērā specifiska katram operatoram, tomēr ir izdalāmi 2 galvenie veidi:

    • operators kā neatkarīga funkcija - tādā gadījumā operatoram funkcionālajā pierakstā būs tikpat parametru, cik operandu;
    • operators kā klases iekšējā funkcija - tādā gadījumā operatoram funkcionālajā pierakstā būs par vienu parametru mazāk nekā operandu, jo par pirmo operandu formāli kalpos objekts, kam šis operators itek izsaukts.
    Jāņem vērā, ka lai izmantotu ārēju pārslogotu operatoru objekta privātam laukam, šis pārsologotais operators (tā funckija) ir jāpasludina par klases draugu.

  14. Mantošana.

    Mantošana (inheritance) ir obejktorientētās programmēšanas mehānisms, kad klase pārņem (manto) elementus (laukus un metodes) no jau eksistējošas klases vai pat vairākām klasēm.

    Mantošana ir vēl viens mehānisms pirmkoda vairākkārtējai izmantošanai, kas papildina koda strukturēšanas iespējas, kā arī nodrošina ērtāku uzturēšanu.

    Klases, no kurām mantošanas rezultātā tiek iegūti elementi, sauc par bāzes klasēm (base class), bet klasi, kura tiek veidota, izmantojot mantošanu - par atvasināto klasi (derived class) vai mantoto (inherited) klasi.

    Mantošanas process var būt kaskādes veida, līdz ar to viena un tā pati klase var būt gan atvasinātā klase, gan bāzes klase citām klasēm. Klases mantošana notiek, pēc klases nosaukuma uzrādot klasi vai klases, no kurām tiks mantots(pēc līdzīgas sintakses, kā konstruktorā alternatīvajā variantā tiek inicializēti lauki).

    Mantošanas mehānismu izmantošana izsauc nepieciešamību pēc vairākām papildus konstrukcijām un mehānismiem objektorientētajā programmēšanā:

    • modifikators protected paplašina private redzamību uz mantotajām klasēm;
    • konstruktoru kaskādes veida izsaukšana;
    • destruktoru kaskādes veida izsaukšana;
    • atklātā un slēptā mantošana;
    • virtuālās funkcijas;

  15. Algoritma izpildes laika precīza novērtēšana. Sliktākā gadījuma laiks.

    Lai precīzi novērtētu algoritma izpildes laiku ir jāskaita cik darbības tas veiks. (Cikli, kontroles nosacījumi.) Lai noskaidrotu sliktākā gadījuma laiku ir jāpieņem, ka katrs cikls izpildīsies maksimālo skaitu reižu. Citiem algoritmiem, piemēram, quick-sort pieņem visneizdevīgāko sākuma stāvokli un no tā izrēķina cik darbības būs nepieciešamas.

  16. Algoritma izpildes laika asimptotiska novērtēšana sarežģītība ar kārtu. O-mērs.

  17. Polimorfisms.

    Pārslogošana (overloading) ir vienāda vārda izmantošana dažādu funkciju nosaukšanai.

    Pārslogošana ir plašāka jēdziena - polimorfisms - apakšgadījums. Funckiju (nosaukuma) pārslogošana nav iespējama valodā C. Funkciju pārslogošana valodā C++ iespējama tāpēc, ka funkcijas tiek identificētas nevis tikai ar vārdu( kā tas ir valodā C), bet papildus arī to parametru tipu virkni, resp., ar signatūru.

    Funkcijas signatūra (signature) ir funkcijas apraksts, kas ietver funkcijas vārdu un parametru tipu virkni, ieskaitot arī parametru modifikatorus const..Funkc

    • Atšķirībā no prototipa, signatūra neietver atgriežamo tipu;
    • Nevar pastāvēt divas dažādas funkcijas, kuru prototips atšķiras tikai ar atgriežamo tipu, jo to signatūras sakrīt.

    Tomēr, lai veiksmīgi izmantotu pārslogotas funkcijas, nepietiek ar korektu to definēšanu. Svarīgs ir aŗi izsaukšanas konteksts. Ja pēc funkcijas izsaukuma nav iespējams pateikt, kura no pārslogotajām funkcijām (kas vērtu būt definētas korekti) ir domāta, iestājas kompilatora kļūda. Lai šādads kļūdas labotu, izsaukumā jāprecizē, kuru īsti funkciju jāizsauc. To dara, pielietojot argumentiem tipa pārveidošanu.

  18. Funkciju veidne (šablons, template).

    Šablons ir mehānms, kas reprezentē shēmu, pēc kuras var tikt veidotas klases vai funkcijas.

    Funkciju šablons ir shēma funkciju veidošanai. Funkciju šablons ir vienkāršākais piemērs šablonu mehānisma demonstrēšanai.

    Funkciju šablonu izveidošanai un izmantošanai ir šādas īpašības:

    • funkciju šablona izveidošana ir līdzīga parastas funkcijas izveidošanai ar nekonkretizētiem datu tipiem, kam pievieonta šablona galva;
    • funckiju šablona izmantošana pilnīgi neatšķiras no parastas funkcijas izmantošanas;

    Jāatceras, kas funkciju šablons nav universāla funkcija (kaut arī no izmantošanas viedokļa tā varētu likties), bet shēma funkciju izveidošanā, t.i. uz tā bāzes tiek izveidots tik daudz "īstu" funkciju, cik nepieciešams.

    No tā izriet, ka:

    • funkciju šblona (arī klašu šablona) izmantosāna nodrošina efektīva izpildāmā koda ģenerēšanu, jo katram gadījumam tiek izveidota sava funkcija ( vai klase )(nevis viena universāla);
    • tajā pašā laikā šabloni šī paša iemesla dēļ nenodrošina kompakta izpildāmā koda ģenerēšanu.
    Lai šablonu drīkstētu izmantot noteiktam tipu komplektam, dotajos tipos ir jābūt definētām visām darbībām, kas pielietotas šablona definēšanā.

  19. Klašu veidne.

    Klašu šablonu izveidošana notiek pēc līdzīgiem principiem, kā funkciju šablona izveidošana - šablonu klasi ievada identiska šablona galva, un klases definēšanā tiek izmantoti arī nekonkretizētie tipi, tomēr klašu šablona izmantošana objektu veidošanai ir sarežģītāka nekā funkciju šabloniem - kompilators pēc konteksta nevar noteikt, ar kādu aktuālo tipu komplektu jāveido objekts, tāpēc tas jāuzrāda tiešā veidā.

    Aktuālo tipu komplekta uzrādīšana pie klases objekta deklarēšanas var pasliktināt programmas lasāmību, bet izeja ir konstrukcijas typedef lietošana, kas ļauj no klases šablona izveidoto klasi nosaukt ar konkre'tu vārdu un tādējādi padarīt tālāko šīs klases izmantošanu ērtāku.

  20. Saraksta klase, izmantojot veidnes (šablonus) (nelietojot STL).

    Tāpat kā iespējams būvēt "parastas" klašu templeitus ir iespējams būvēt dažādu sarakstu klašu templeitus, piemēram, vienvirziena saistīto sarkaskstu, steku, rindu koku etc. Pati programmēšana notiek tādā pat veidā (sintakse neatšķiras), galvenais ir pareizi salikt saišu veidošanu. (Piemēram, vienvirziena saistītajā sarakstā labāk node inicializēt ar next pointeri uz NULL, lai par to vēlāk nav jādomā.)

  21. STL bibliotēkas jēdziens.

    Standarta šablonu bibliotēkas (standard template library STL) izveidošana bija veiksmīgs solis C++ bibliotēku standratizēšanā, jo ilgu laiku praktiski vienīgās C++ standarta bibliotēkas bija tās, kas bija mantotas no C (ja neskaita ievada uz izvada bibliotēkas.)

    STL sastāvā ietilpst 3 komponentu kategorijas:

    • Konteineri tās ir datu struktūras, kas veido STL pamatu (piemēram vector, stack, un pārējo divu kategoriju komponentes nodarbojas ar to apkalpošanu;
    • Iteratori - specializētas norādes piekļūsšanai konteineru klašu vērtībām.
    • Algoritmi - funkciju šabloni, kas apkalpo konteineru datus (piemēram, sort())

    STL konteineru klases STL satur daudzas konteineru klases, kas reprezentē vispārzināmas datu struktūrsa. Tas ir ļoti spēcīgs līdzeklis, tomēr prasa pietiekoši plašas zināšanas algoritmos un datu struktūrās, lai tās izmantotu "pēc pilnas programmas".

    Iekļaujamā bibliotēka Konteineru klase Apraksts
    <bitset> bitset bitu kopas
    <vector> vector dinamiski masīvi
    <list> list saraksti
    <map> map, multimap kartes vai attēlojumi - līdzīgi masīviem, bet indeksa lomu šeit var viekt arī citu tipu vērtības.
    <stack> stack steki - linēra struktūra, kas organizēta pēc principa "last-in, first-out"
    <queue> queue, priority_queue steki - linēra struktūra, kas organizēta pēc principa "first-in, first-out"
    <deque> deque divvirzienu rindas
    <set> set, multiset kopas

    STL iteratori Iteratori ir mehānismi, kas paredzēti piekļūšanai konteineru elementiem, kas lielā mērā (gan idejiski, gan sintaktiski) atgādina nor'daes (pointers). Iteratorus deklarē, izmantojot tipu iterator, kas definēts konteineru klasēs (nevis, pielietojot papildus * simbolu, kā tas pierasts pie norādēm). Divi svarīgi daudzu konteineru klašu iebūtie iteratori ir begin() un end(), kas norāda attiecīgi uz konteinera pirmo elementu un elementu aiz pēdējā (pēc līdzības ar beigu simbolu zema līmeņa simbolu virknēs). Iteratori var būt vairāku tipu - patvalīgas pieejas (random access), divvirzienu (bidirectional) u.c., un to, kāds iterators tiek izmantots, nosaka konteineru klases tips un konteksts.

    STL algoritmi STL piedāvā vairāku algoritmu realizācijas, kas apkalpo konteineru klases. Šajā mācību materiālā tiks apskatīta kārtošanas algoritma sort() izmantošana.

  22. Plūsmas ievades klases un objekti. cin objekts.

    Formatēta ievade nodrošina informācijas pieņemšanu no klaviatūras un pārveidošanu par noteikta datu tipa vērtību, ja tas ir iespējams, un ierakstot to mainīgajā. Formatēta ievade notiek, izmantojot objektu cin, un ievades operatoru >>. Izmantojamā bibliotēka: <iostream.

    Līdzīgi kā izvadei, arī ievadi var noformēt vairākām vērtībām uzreiz vienā priekšrakstā kaskādes veidā.

    Starp vairāku vērtību ievadīšanu var tikt likts viens vai vairāki atdalītājsimblo. Visi atdalītājsimbli ir līdzvvērtīgi - tie nolasīšanas laikā tiek ignorēti, lai nolasītu "e;īstās"e; vērtības. Tomēr ENTER no programmas izpildes viedokļa ir nedadz savādāks: lai kādus atdalītājsimbolus mēs liktu sstarp vērtībām, vismaz pašās beigās ir jāliek ENTER, jo tikai tad sākas pats nolasīšanas process (līdz tam notika tikai simbolu uzkrāšana). Tātad, ievades process notiek 2 posmos:

    • informācijas nolasīsān no klaviatūras un uzkrāšana buferī līdz pat ENTER nospiešanai
    • bufera satura pārstaigāšana, mēģinot izvilkt noteikta tipa vērtību vai vērtības, lai ierakstītu mainīgajā vai mainīgajos

    Ievade kļūdu apstrāde

    Ja izvade normālā gadījumā vienmēr notiks veiksmīgi (izņemot retus ārkārtas gadījumus), tad ievades komandai neveiksmīgs iznākums ir relatīvi parasta lieta, kas notiek ievadāmā teksta formāta neatbilstības dēļ mainīgā tipam, kurā notiek informācijas ielasīšana. Piemēram, ja komanda ir ielasīt datus mainīgajā ar skaitlisku tipu, bet uz klaviatūras tiek padoti burti, nevis cipari, protams, notiek kļūda. Ja ir iespējams notikt kļūdai, tad nepieciešami mehānismi, lai kļūdas novērstu vai apietu.

    • Pēc katras nolasīšanas operācijas ir iespējams pārbaudīt vai tā ir bijusi veiksmīga vai nē. To veic ar objekta cin funkciju good (iespējams pārbaudī arī uz neveiksmi ar funkcijām bad vai fail

    Ja nolasīšana bijusi neveiksmīga, objekts cin tiek nobloķēts, un, ja to neatbloķē, visas turpmākās darbības ar to tiek ignorētas. Lai turpinātu darbu pēc neveiksmīgas ievades, ir jāveic divas operācijas:

    • objekta cin atbloķēšana ar funkciju clear;
    • ievadītās simbolu virknes ignorēšana līdz tuvākajam ENTER (funkcija ignore);

    Ar datu nolasīšanu no faila ir krietni ķēpīgāk.

    Formatēta ievade no teksta faila notiek pēc līdzīga principa, kādi ir pieejami ievadei no klaviatūras un kas jau ir aprakstīti iepriekšējās nodaļās. Formatēta ievade no faila notiek, izmantojot ievades operatoru >>.

  23. Plūsmas izvades klases un objekti. cout objekts.

    Formatēta izvade failā notiek, izmantojot izvades operatoru << un identiskus formatēšanas mehānismus (funkcijas un manipulatorus), kād ir pieejami izdrukāšanai uz displeja. (manipoulatori ir pieejami bibliotēkā <iomanip>, bet <iostream> vietā stājas bibliotēka <fstream>)

  24. Bināru komponenšu failu veidošana secīgi.

    Izvadi binārā režīmā nodrošina faila objekta funkcija write.

    ostream &write (const char* buf, int num);

    Faila objekta funkcija write()ieraksta num baitus izvades plūsmā (failā), no bufera (atmiņas apgabala), kura sākuma adrrese glabājas mainīgajā buf

    Ir svarīgi, ka failā ierakstāmie dati tiek padoti kā baitu virkne (char*) neatkarīgi no tā, kā norādītie dati tiek interpretēti programmā. Šim nolūkam parasti jāveic datu tipa pārveidošana uz uz char*.

    Ja mums ir porgrammas mainīgais, kurš reprezentē noetiktu informāciju atmiņā, tad funkcijai write padodamā bufera (parametrs nr 1) sagatavošana parasti notiek šados 2 soļos:

    • adreses paņemšana no mainīgā (ja mainīgais jau nav norāde);
    • norādes pārveidošana uz tipu char* (ja tai jau nav tāds tips), izmantojot klasisko tipu pārveidošanas operatoru ((char*)pointer) vari arī (reinterpret_cast<char*>(pointer))).

    Otrs funkcijas write() arguments ir baitu skaits, cik jāieraksta failā. Šeit ērti izmantot funkciju sizeof(), kam kā argmentu var ņemts gan datu tipu, gan mainīgo, kam vēlas noskaidrot lielumu. Tomēr, lai nodrošinātu informācijas apmaiņu starp dažādām platformām, vai starp programmmām, kas kompilētas ar dažādiem kompilatoriem, dažreiz drošāk ir caur parametru, kas padod konstantu vērtību,

  25. Bināru komponenšu failu lasīšana secīgi.

    Nolasīšanu binārā režīmā nodrošina faila objekta funkcija read.

    read istream &read (char* buf, int num);

    Faila objekta funkcija read() nolasa num baitus no ievades plūsmas (faila) un ieraksta buferī (atmiņas apgabalā), kura sākuma adrese glabājas mainīgajā buf. Abu funkcijai padodamo argumentu noformēšana notiek identiski funkcijai write(). Funkcija read(), kam caur parametru #2 tiek padots 1, lielā mērā atbilst binārā režīmā izsauktai funkcijai get().

  26. Bināru komponenšu failu veidošana ar tiešo pieeju.

    Noklusētā metode faila apstrādei ir sekvenciālā pēc kārtas, taču pateicoties sekundārās atmiņas tehniskajām iespējām, ir iespe'ja apstrādāt faila datus, piekļūstot tam tiešā veidā - kā caur indeksu masīva elementam.

    • faila informāciajs pamatvienība ir baits;
    • baitu numerācija failā sākas ar 0

    Strādājot ar failu tiešās pieejas režīmā, īpaši svarīgs kļūst jēdziens faila norāde -tā ir aktuālā vieta failā, šakot no kuras uz priekšu tiks veikta kārtējā nolasīšana, ierakstīšana vai cita darbība. Tiešās pieejas darbības ir tās, kuras darbojas ar faila norādi.

    Strādājot ar bināru failu izmantojot tiešo pieeju programmētājam ir svarīgi atcerēties, kurā vietā failā pointeris atrodas, un ja ir realizēta datu struktūra, ka šis pointeris pirms rakstišanas ir jānovietu vēlamajā vietā. Kā arī ir jāiegaumē tas, ka jaunā informācija tiek pārrakstīta pa "virsu" vecajai.

  27. Bināru komponenšu failu lasīšana ar tiešo pieeju.

    Ar bināru failu lasīšanu, izmantojot tiešo pieeju ir tieši tāpat kā ar rakstīšanu. Galvenais ir uzstādīt pointeri vēlajamā vietā, un izmantot funkciju read norādot baitu skaitu.

  28. Izņēmumsituāciju apstrādes pamatjēdzieni.

    Izņēmumu apstrāde (exception handling) ir mehānisms, kas ļauj noteiktā veidā strukturēt programmu, lai nošķirtu kļūdu apstrādes daļu no pārējās programmas daļas.

    Konceptuāli izņēmumu apstŗade ietver divas galvenās darbību grupas, kuras saistītas ar 3 speciāliem atslēgas vārdiem (try, throw, catch).

    • Izņēmuma izmešana(throw) - pirmkoda daļas izpildes pārtraukšana kļūdas dēļ un paziņošana par kļūdu. Izņēmumu izmešana notiek speciālā try blokā.
    • Izņēmumu pārtveršana(catch) nodrošināt izņēmuma gadījuma apstrādi atbilstoši izņemuma tipam. Izņēmuma uztveršana notiek uzreiz aiz try bloka, kurā varētu notikt izņēmuma izmešana.

    Praktiski kļūdu apstrādi var realizēt arī, neizmantojot izņēmumu apstrādes mehānismu, bet tādā gadījumā pašam programmētājam ir jāveido konstrukcijas kļūdas paziņojumu nosūtīšanai uz kļūdu apstrādes vietu, kas varētu izpausties, kā speciālas nozīmes funkcijas atgriežamās vērtības vai pat papildus parametri funkcijām, kas būtu paredzēti kļūdu paziņojumu pārsūtīšanai starp moduļiem.