Prednáška 23

Nepreberané črty jazykov C a C++

Dnešná prednáška bude venovaná (pomerne plytkému) prehľadu rôznych čŕt jazykov C a C++, ktoré sa počas semestra nepreberali. Tento prehľad by mal poslúžiť ako pomôcka pri štúdiu existujúcich programov, resp. ako inšpirácia pre ďalšie samoštúdium.

Znalosť materiálu z tejto prednášky nebude vyžadovaná na skúške. Rovnako nie je odporúčané na skúške tento materiál využívať bez dôkladného samostatného oboznámenia sa s ním.

Táto prednáška nepokrýva objektovo-orientované programovanie v jazyku C++. Objektovo-orientované programovanie (v jazyku Java) bude hlavnou náplňou druhého semestra programovania.

Rozdiely medzi jazykmi C a C++

Jazyk C vznikol okolo roku 1972 na podporu vývoja operačného systému Unix; jazyk C++ okolo roku 1985. Programy v jazyku C sú väčšinou súčasne aj korektnými programami v jazyku C++ (ide ale o isté zjednodušenie). Obidva tieto jazyky existujú vo viacerých štandardoch, v ktorých sa postupne pridávali nové črty.

V priebehu semestra sme programovali v jazyku C++. Veľká časť konštrukcií, ktoré sme v programoch využívali, však pochádza už z jazyka C. Výnimkami sú však napríklad nasledujúce črty jazyka C++, ktoré v jazyku C nie sú k dispozícii:

• V jazyku C nie je možné predávanie parametrov funkcií referenciou. Namiesto toho je potrebné používať smerníky.
• V jazyku C nefungujú operátory new a delete. Namiesto nich treba použiť funkcie popísané nižšie.
• Na používanie typu bool a konštánt true a false je potrebná knižnica stdbool (t. j. #include <stdbool.h>). Zabudovaný booleovský typ má názov _Bool a nadobúda hodnoty 0 a 1.
• Štandardnými knižnicami jazyka C sú spomedzi štandardných knižníc jazyka C++ v zásade tie začínajúce písmenom c, napríklad cstdio. Namiesto #include <cstdio> potom v C píšeme #include <stdio.h>.
  • V jazyku C špeciálne nie je možné používať knižnicu iostream a v nej definované štandardné vstupno-výstupné prúdy cin a cout.
• V jazyku C je potrebné pri deklarácii premennej typu struct struktura písať aj kľúčové slovo struct.
• V starších verziách jazyka C nefungujú mnohé konštrukcie jazyka C++, ktoré sme bežne používali – napríklad komentáre vo forme //, deklarácie premenných inde ako na začiatku funkcie, atď.

Nepreberané črty jazyka C (použiteľné aj v C++)

Enumerované typy

Enumerované typy pozostávajú z vymenovania niekoľkých hodnôt, ktoré sa stanú celočíselnými konštantami. To je občas užitočné na sprehľadnenie zdrojového kódu.

Príklad:

#include <iostream>
using namespace std;

int main() {
    // definicia enumerovaneho typu farba
    enum farba {biela, modra, cervena, zelena, cierna};  
    // definicia premennej typu farba     
    farba f = biela;                                     
    f = zelena; 
    cout << f << endl; // vypise 3
}

Zložený typ (union)

Zložený typ umožňuje na jednom mieste pamäte uchovávať hodnotu, ktorá môže byť viacerých dátových typov (na rozdiel od štruktúr však vždy ide o práve jednu hodnotu). Definuje sa podobne ako štruktúra, avšak s použitím kľúčového slova union namiesto struct.

Príklad:

#include <iostream>
#include <cstring>
using namespace std;

union zlozenyTyp {
    int n;
    char s[8];
};

int main() {
    zlozenyTyp z;
    z.n = 10;
    cout << z.n << endl;  // vypise 10
    strcpy(z.s, "abcd");
    cout << z.s << endl;  // vypise abcd
    cout << z.n << endl;  // vypise nejaky nezmysel
}

Napríklad pri aritmetických stromoch by použitie zloženého typu umožnilo ušetriť trochu pamäte tým, že by sme si v každom uzle pamätali buď jeho hodnotu, alebo operátor, pričom typ uzla by sme rozlišovali podľa toho, či sú smerníky na oboch synov rovné NULL.

Operátory

Okrem operátorov, ktoré sme používali, existuje niekoľko ďalších, ako napríklad nasledujúce:

• Bitové operátory pracujú s celým číslom ako s poľom bitov (vhodnejšie sú unsigned typy):
  • << a >> posúvajú bity doľava a doprava, zodpovedajú násobeniu a deleniu mocninami dvojky.
  • & (and po bitoch), | (or po bitoch), ^ (xor po bitoch), ~ (negácia po bitoch).
• Ternárny operátor (podmienka)?(hodnota pre true):(hodnota pre false)
  • cout << x << " je " << ((x%2==0) ? "parne" : "neparne") << endl;
• Pozor na rozdiel medzi a[i++]=0 a a[++i]=0, prehľadnejšie je použiť dva príkazy: a[i]=0; i++; alebo i++; a[i] = 0;

Cyklus do-while

Cyklus do-while je obdobou cyklu while s vyhodnocovaním podmienky na konci iterácie. Nasledujúce dva spôsoby písania cyklu sú viac-menej ekvivalentné:

do { 
    prikazy;
} while(podmienka);

while (true) {
    prikazy;
    if (!podmienka) break;
}

Makrá a konštanty

Konštantu možno zadefinovať napríklad aj takto:

#define MAXN 100

Narozdiel od konštanty s definíciou

const int maxN = 100;

sa tu konštantná premenná MAXN reálne nevytvára (nevyhradzuje sa pre ňu pamäťové miesto); všetky výskyty MAXN sú preprocesorom kompilátora nahradené v zdrojovom kóde konštantou 100.

Okrem konštánt možno definovať aj zložitejšie makrá s parametrami:

/* Definicia makra: */
#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))

/* Priklad pouzitia: */
cout << MIN(a*a, b+5);

/* Preprocesor vykona substituciu za MIN, ktorou dostane: */
cout << ((a*a) < (b+5) ? (a*a) : (b+5));

• Bez dostatočného množstva zátvoriek by pri použití makra MIN mohlo dôjsť k „interakcii s okolím”.
• Vo všeobecnosti je odporúčané vyvarovať sa použitia makier.

Delenie programu na súbory

• Väčší program chceme rozdeliť na viac súborov
• Chceme vytvárať a používať vlastné knižnice - skupiny funkcií s podobným účelom
  • Napríklad knižnica implementujúca funkcie pracujúce so zásobníkom
• Knižnicu rozdelíme na dva súbory, napr. stack.h a stack.c resp. stack.cpp

V hlavičkovom súbore (header file) stack.h zadeklarujeme funkcie, ale neuvádzame ich kód, napr.:

typedef int dataType;
struct stack {
    int top;  /* pozicia vrchného prvku zásobníka */
    dataType *items; /* pole prvkov */
};
void init(stack &s);
bool isEmpty(stack &s);
void push(stack &s, dataType data); 
dataType pop(stack &q);

Programy, ktoré chcú použiť stack, použijú include na tento súbor

#include "stack.h"

V súbore stack.cpp uvedieme kód funkcií, napr.

#include "stack.h"
const int maxN = 100;
void init(stack &s) {
    s.top = -1;
    s.items = new dataType[maxN];
}
...

• Všimnite si, že v include dávame meno štandardných knižníc v <>, našich vlastných v ""
• Ako zabrániť, aby sa vložilo include viackrát?
  • #ifndef IDENTIFIKATOR #define IDENTIFIKATOR ... #endif

Pri kompilácii potom potrebujeme kompilátoru zadať mená všetkých častí programu s príponou cpp resp. c, napríklad

g++ -o program main.cpp stack.cpp

• Funkciu main musí obsahovať práve jeden z kompilovaných zdrojových súborov.

Zopár užitočných funkcií

Alokácia pamäte

• V jazyku C nie sú definované operátory new a delete, resp. new[] a delete[].
• Pamäť sa alokuje funkciou malloc, ktorá alokuje kus pamäte s daným počtom bajtov.
  • V prípade neúspechu vráti NULL.
  • V prípade úspechu vráti smerník na void, ktorý je následne nutné pretypovať.
• Uvoľnenie pamäte realizuje funkcia free.
• Pri výpočte veľkosti potrebnej pamäte sa zvyčajne používa operátor sizeof.

#include <cstdlib>   // resp. #include <stdlib.h> v C

/* vytvorime pole 100 int-ov */
int *a = (int *)malloc(sizeof(int) * 100);
/* odalokujeme pole a */
free(a);

Triedenie

• Funkcia qsort z knižnice stdlib.h.
• Dostane pole, počet jeho prvkov, veľkosť každého prvku a funkciu, ktorá porovná dva prvky.
  • Funkciu teda posielame ako parameter.
  • Táto porovnávacia funkcia dostane dva smerníky typu void * (na dva prvky poľa).
  • Vráti záporné číslo, ak prvý prvok je menší, nulu, ak sú rovnaké a kladné číslo, ak je prvý väčší.
• Ak si napíšeme porovnávaciu funkciu, môžeme triediť prvky hocijakého typu.

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}
int a[] = {5, 3, 2, 4, 1};
qsort(a, 5, sizeof(int), compare);

• Existuje napríklad aj funkcia bsearch na binárne vyhľadávanie v utriedenom poli.

Nepreberané črty jazyka C++

Generické funkcie

Občas sa zíde napísať algoritmus, ktorý by mohol pracovať na dátach rôznych typov. Napríklad triediť môžeme celé alebo desatinné čísla, reťazce, zložitejšie štruktúry s určitým kľúčom a pod.

V C++ sa dajú písať takzvané generické funkcie, ktoré možno „parametrizovať” podľa typu:

#include <iostream>
using namespace std;

template <typename T>
T myMax (T a, T b) {
  return (a > b) ? a : b;
}

int main() {
    int i = 3;
    int j = 5;
    int k = myMax(i, j);
    cout << k << endl;
}

• O generických funkciách sa budete viac učiť budúci semester.

Preťaženie operátorov

Pre novovytvorené typy je možné štadardným operátorom jazyka C++ priradiť novú sémantiku pomocou tzv. preťaženia. Napríklad v nasledujúcom príklade definujeme operátor < na menách, ktorý najprv porovnáva podľa priezviska a následne podľa krstného mena.

struct meno {
    char *krstne, *priezvisko;
};

bool operator < (const meno &x, const meno &y) {
    return strcmp(x.priezvisko, y.priezvisko) < 0
            || strcmp(x.priezvisko, y.priezvisko) == 0
            && strcmp(x.krstne, y.krstne) < 0;
}

• Podobne môžeme zadefinovať napríklad operátory + a * pre štruktúry reprezentujúce polynómy alebo komplexné čísla...
• cout << "Hello" používa preťažený operátor << pre výstupný prúd na ľavej strane a reťazec na pravej strane.

Reťazce typu string

• V C++ je možné okrem klasických C-čkových reťazcov použiť aj typ string z C++.
• Jeho použitie je elegantnejšie, sám si určuje potrebnú veľkosť pamäte.
• Reťazce tohto typu sú objekty, do funkcií ich odovzdávame väčšinou referenciou (cez &).
• K jednotlivým znakom pristupujeme pomocou [] (ako u polí) alebo pomocou metódy at.

#include <string>
#include <iostream>
using namespace std;

int main() {
    char cstr[100] = "Ahoj\n";
    string str = "Ako sa mas?\n";
    string str2;

    /* Do str mozno pomocou operatora = 
     * korektne priradit konstantne retazce,
     * C-ckove retazce (polia znakov), 
     * aj ine premenne typu string. */
    str2 = "Ahoj\n";
    str2 = cstr;
    str2 = str;

    /* Meranie dlzky retazca: */
    cout << "Dlzka je: " << str.length() << endl;

    /* Funguje porovnanie pomocou ==, !=, <, ...
     * (bud dvoch C++ stringov, alebo C++ stringu a C stringu)
     * Pomocou operatora + mozno realizovat zretazenie. */
    str2 = cstr + str;
    cout << str2 << endl;

    if (str < str2) {
        cout << "Prvy je mensi" << endl;
    } else if (str == str2) {
        cout << "Rovnaju sa" << endl;
    } else {
        cout << "Druhy je mensi" << endl;
    }
}

• Pomocou metódy c_str() možno získať z reťazca typu string premennú typu const char*.

Dátová štruktúra vector

• Súčasťou štandardnej knižnice jazyka C++ je viacero rôznych dátových štruktúr.
• Ide pritom o generické štruktúry, ktoré môžu uchovávať dáta rôznych typov.

Spomenieme dátovú štruktúru vector [1]:

• Elegantnejšia verzia dynamických polí z prednášky.

Vytvorenie nového vektora

// vytvori pole celych cisel s nula cislami
vector<int> a;       
// vytvori pole 5 celych cisel, ktore nastavi na 1
vector<int> a(5,1);

Prístup k prvkom vektora:

• Pomocou a[index] podobne ako pri poliach, nekontroluje, či je index v medziach poľa.
• Funkciou a.at(index), ktorá v prípade indexu mimo rozsahu vyhodí výnimku (program spadne) a nenarobí chaos v pamäti, ľahšie sa hľadá chyba.
• V obidvoch prípadoch môžeme aj priraďovať: a[index] = value; a.at(index) = value;

• Ďalšie metódy na prácu s vektormi:
  • a.push_back(x) vloží hodnotu x ako nový prvok na koniec poľa, podľa potreby pritom pole realokuje a pod.
  • a.size() vráti počet prvkov v poli.

#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> a;
    
    while(true) {  
        // nacitame postupnost nezapornych cisel 
        // ukoncenu -1, ulozime do vektora
        int prvok;
        cin >> prvok;
        if(prvok < 0) {
	    break;
        }
        a.push_back(prvok);
    }
    // vypiseme prvky vektora
    for (int i = 0; i < (int)a.size(); i++) {
        cout << a[i] << endl;  // alebo a.at(i)
    }
}

Algoritmus na triedenie:

• V knižnici <algorithm>

//triedime normalne pole
int A[6] = {1, 4, 2, 8, 5, 7};
sort(A, A + 6);

//triedime vektor
vector <int> A;
sort(A.begin(), A.end());

//triedime podla nasej porovnavacej funkcie, napr. podla absolutnej hodnoty
struct cmp {
    bool operator()(int x, int y) { return abs(x) < abs(y); }
};
cmp c;
sort(A.begin(), A.end(), c);

2D matica pomocou vektora:

#include <vector>
#include <iostream>
using namespace std;

int main() {
    // nacitanie a vypis matice m x n
    int m, n;
    cin >> m >> n;

    vector<vector<int>> a(m, vector<int> (n, 0));

    for (int i = 0; i < (int)a.size(); i++) {
        for (int j = 0; j < (int)a[i].size(); j++) {
            cin >> a[i][j];
        }
    }
    for (int i = 0; i < (int)a.size(); i++) {
        for (int j = 0; j < (int)a[i].size(); j++) {
            cout << " " << a[i][j];
        }
        cout << endl;
    }
}

Range-based for loop

• Špeciálny cyklus cez prvky vektora a pod.
  • nepotrebujeme zavádzať premennú pre index
  • podobný cyklus uvidíte podrobnejšie v Jave

#include <iostream>
#include <vector>
using namespace std; 

void vypis(const vector<int> &a) {
  // vypise vsetky prvky vektora a
  for (const int &value : a) { 
    cout << value << ' ';
  }
  cout << '\n';  
}

int main() {
  vector<int> a;

  // do vektora a vlozi prvky 0,..,5
  for(int value : {0,1,2,3,4,5}) {
      a.push_back(value);
  }

  vypis(a);  // vypise 0 1 2 3 4 5
 
  // zvysi kazdy prvok vektora o 1
  for (int &value : a) { 
      value++;
  }

  vypis(a); // vypise 1 2 3 4 5 6
}

Stream

• Každý textový súbor môžeme chápať ako postupnosť znakov (podobne ako vstup/výstup z konzoly). Teda aj textový súbor je vlastne stream, ktorý môžeme postupne (zľava doprava) čítať alebo do neho zapisovať.
• Textové súbory teda môžeme načítávať alebo zapisovať pomocou analógie k cin a cout
• Budeme využívať typy a funkcie zadefinované v knižnici fstream.

#include <fstream>

using namespace std;

int main (void) {
  ofstream o;
  o.open ("test.txt");     // otvorenie súboru
  o << 'z';                // zapíše 1 znak
  o << "Toto je retazec";  // zapíše reťazec 
  o << endl;               // zapíše znak nového riadku
  o << "10*32=" << 10*32 << endl;          // zapíše reťazec a hodnotu výrazu
  o << "1 rovna sa 4? " << (1==4) << endl; // pozor na priority operátorov ... 1==4 musí byť v zátvorkách !!!
  o.close ();              // zatvorenie súboru
}

• ofstream tiež umožňuje formátovanie výstupu napríklad pomocou modifikátorov fixed,setprecision(),setfill(),setw()

• Podobne môžeme otvoriť aj súbor, z ktorého budeme čítať vstup. V príklade načítame pole celých čísel.

#include <fstream>
#include <iostream>

using namespace std;
const int MAX=100;

int main (void) {
  ifstream f;
  int pocet, A[MAX];
  
  f.open ("vstup.txt");
  if (f.fail ()) return 1;  // return = návrat z funkcie – koniec programu
  f >> pocet;
  for (int i=0; i<pocet; i++) {
    f >> A[i];
  }

  for (int i=0; i<pocet; i++) {
    cout<< A[i] << " ";
  }
  f.close();
}

• Pri načítaní sme sa už stretli s funkciou f.fail(), ktorá vrátila true, ak vznikla chyba (väčšinou pri otvorení neexistujúceho súboru). Druhou možnosťou je testovať správne otvorenie pomocou testovania premennej typu ofstream alebo ifstream.
  • technicky ide o preťaženie operátora konverzie na bool resp. na void*, robí negáciu funkcie fail

  ifstream fin("vstup.txt"); // input
  if(!fin) {
    cout << "Cannot open vstup.txt file.\n";
    return 1;
  }

  ofstream fout("vystup.txt"); // output, normal file
  if(!fout) {
    cout << "Cannot open vystup.txt file.\n";
    return 1;
  }

• Testovanie konca súboru môžeme robiť pomocou funkcie eof

ifstream fin("VSTUP.txt"); // input
char c;

while(!fin.eof()) {
  fin>>c;
  cout<<c;
}

• Pre streamy je praktická funkcia getline, ktorá načíta zo streamu celý riadok. Nasledovný príklad spočíta v jednotlivých riadkoch počet bodiek.

int main(void){
ifstream f("VSTUP.txt");;
string line;
int poc;

while (getline(f,line)){
 poc=0;
 for (int i=0; i<line.length(); i++){
   if (line[i]=='.') poc++;
 }
 cout << poc <<endl;
}