7. UKAZOVATELE, POLIA A REŤAZCE

Transcription

1 7. UKAZOVATELE, POLIA A REŤAZCE 7.1. Ukazovatele 7.2. Pole 7.3. Aritmetika ukazovateľov 7.4. Reťazce 7.5. Viacrozmerné pole, ukazovateľ na ukazovateľ 7.6. Ukazovateľ na ukazovateľ a pole ukazateľov 7.7. Ukazovateľ na funkcie Argumenty príkazového riadku Ukazovatele môžu byť používané v súvislosti so statickými dátami, napríklad s premennými. Omnoho elegantnejšie použitie poskytujú v súvislosti s poliami (a najmä s poliami znakov - reťazcami), lebo ako zakrátko uvidíme, (zjednodušene povedané) ukazovateľ a pole je jedno a to isté. Celkom nezastupiteľné miesto majú ukazovatele v súvislosti s dynamickými dátovými štruktúrami. Pretože zmienené použitie ukazovateľov je príliš rozsiahle pre jednu kapitolu, popíšeme ich v dvoch kapitolách. Téme tejto kapitoly napovedá jej názov. Nasledujúca kapitola obsahuje podrobný prehľad vstupu a výstupu. V ďalšej kapitole sa budeme venovať dynamickým dátovým štruktúram Ukazovatele S ukazovateľmi sme sa stručne zoznámili už v kapitole venovanej základným dátovým typom. Preto iste neuškodí krátka rekapitulácia. Ukazovateľ reprezentuje adresu objektu. Nesie so sebou súčasne informáciu o dátovom type, ktorý sa na tejto adrese nachádza. Deklaráciu ukazovateľa a jeho použitie ukazuje príklad: int x, y, *px, *p2x; px = &x; /* px teraz ukazuje na x */ *px = 5; /* to isté ako x = 5; */ y = *px + 1; /* y = x + 1; */ *px += 1; /* x += 1; */ (*px)++; /* x++; zátvorky su nutné */ p2x = px; /* p2x ukazuje na to iste, ako px, t.j. na x */ *p2x = *p2x + y; /* x = x + y; */ Majme na pamäti, že pri deklarácii ukazovateľa môžeme použiť aj modifikáciu const. Potom sa jedná o konštantný ukazovateľ, ukazovateľ na konštantu, alebo oboje, teda konštantný ukazovateľ na konštantu. Pozrime sa na niekoľko príkladov: int i; int *pi; /* pi je neinicializovaný ukazovateľ na typ int */ int * const cp = &i; /* konstantný ukazovateľ na int */ const int ci = 7; /* celočíselná konstanta */ const int *pci;/* neinicializovaný ukazovateľ na celočíselnu konstantu*/ const int * const cpc = &ci; /* konstantny ukazovateľ na konstantu */

2 Prekladače ANSI C pochopiteľne kontrolujú program a v prípade pokusu o porušenie konštantnosti ukazovateľa, hodnoty alebo obidvoch (podľa deklarácie) ohlási chybu Pole Pole je kolekcia premenných rovnakého typu, ktoré môžu byť označované spoločným menom. K prvkom poľa pristupujeme prostredníctvom identifikátoru poľa a indexu. Pole v C obsadzuje spojitú oblasť operačnej pamäte tak, že prvý prvok poľa je umiestnený na najnižšej pridelenej adrese a posledný na najvyššej pridelenej adrese. Pole je v C výhradne jednorozmerné. Povšimnime si skutočnosť, že na prvky poľa nekladieme žiadne obmedzenia. To nám umožňuje zaviesť viacrozmerné pole ako pole polí. Definícia poľa je jednoduchá: typ meno[rozsah]; kde typ určuje typ prvkov poľa (bázový typ) meno predstavuje identifikátor poľa rozsah je kladný počet prvkov poľa (celočíselný konštantný výraz, ktorý musí byť vyčísliteľný počas prekladu) Na tomto mieste zdôraznime význam položky rozsah. Znamená počet prvkov poľa. V súvislosti so skutočnosťou, že pole začína prvkom s indexom nula to znamená, že posledný prvok poľa má index rozsah-1. Ešte jedna dôležitá vlastnosť C. Prekladač nekontroluje rozsah použitého indexu. Pokiaľ sa o túto skutočnosť nepostaráme sami, môžeme čítať nezmyselné hodnoty pri odkaze na neexistujúce prvky poľa. Proti niektorým iným vyšším programovacím jazykom na nás kladie C vyššie nároky. Pokiaľ sa však zamyslíme, spomínaná kontrola medzí sa aj tak použije iba pri ladení, hotový program by možnosť nedodržania medzí nemal obsahovať. Ukážme si niekoľko definícií polí, v ktorých budeme postupne ukazovať možnosti definície premenných typu pole: #define N 10 int a[n]; a je deklarované ako pole o N prvkoch, každý typu int. Na jednotlivé prvky sa môžeme odkazovať indexy 0 až 9, t.j. a[0], a[1],..., a[n-1]

3 pamäťový priestor pridelený poľu a môžeme zistiť výpočtom: počet obsadených byte = N * sizeof(int) Prečo musíme potrebný pamäťový priestor počítať práve týmto spôsobom? Iba sizeof(a) vráti veľkosť pamäte pre premennú typu ukazovateľ. sizeof(*a) vráti veľkosť prvku pole, teda veľkosť int. C síce netestuje indexy polí, ale umožňuje nám súčasne s definíciou poľa previesť aj jeho inicializáciu: b[0] b[1] b[2] b[3] b[4] static double b[5] = 1.2, 3.4, -1.2, 123.0, 4.0 ; Princíp je jednoduchý. Pred bodkočiarku, čím by definícia končila, vložíme do zložených zátvoriek zoznam hodnoť, ktorými chceme inicializovať prvky poľa. Hodnoty pochopiteľne musia byť odpovedajúceho typu. Naviac ich nemusí byť rovnaký počet, ako je dimenzia poľa. Môže ich byť menej. Priradenie totiž prebieha následovne: prvá hodnota zo zoznamu je umiestnená do prvého prvku poľa, druhá hodnota do druhého prvku poľa,.... Pokiaľ je zoznam vyčerpaný skôr, než je priradená hodnota poslednému prvku poľa, zostávajú odpovedajúce (záverečné) prvky poľa neinicializované. Pri inicializácii popísanej vyššie sme museli uvádzať dimenziu poľa. Tuto prácu však môžeme prenechať prekladaču. Ten poľu vymedzí toľko miesta, koľko odpovedá inicializácii, ako napríklad: int c[] = 3, 4, 5; Aby sme predchádzajúcu vetu uviedli na správnu mieru, musíme si povedať, ako chápe C identifikátor pole. Identifikátor pole (symbolicky id) predstavuje konštantný ukazovateľ na prvý prvok poľa, teda na id[0]. Niekedy tiež hovoríme, že id predstavuje bázovú adresu poľa. Skôr popísané vlastnosti C nám zaručia, že nezmeníme hodnotu konštantného ukazovateľa id (viď nasledujúca Aritmetika ukazovateľov) Aritmetika ukazovateľov Názov tohoto odstavca zrejme vyvolá zdesenie väčšiny pascalistov. Aký to má zmysel, prevádzať aritmetické operácie s ukazovateľmi? Ako hneď uvidíme, význam spočíva vo zvýšení prehľadnosti, zrýchlení chodu programu a v možnostiach, ktoré dostávame k dispozícii. Ako vieme, ukazovateľ ukazuje na hodnotu nejakého typu. Nesie so sebou informáciu o tomto type. Táto informácia pochopiteľne predstavuje počet bajtov nutných pre uchovanie hodnoty typu. A pri aritmetike ukazovateľov zmysluplne používame obe časti zmienenej informácie, adresu aj veľkosť položky. Aritmetika ukazovateľov je obmedzená na tri základné operácie, sčítanie, odčítanie a porovnanie. Pozrime sa najprv na prvé dve operácie.

4 Sčítanie aj odčítanie sú binárne operácie. Pretože sa zaoberáme aritmetikou ukazovateľov, bude jedným z operandov vždy ukazovateľ. Druhým operandom potom bude buď opäť ukazovateľ, alebo ním môže byť celé číslo. Pokiaľ sú oba operandy ukazovatele, je výsledkom ich rozdielu počet položiek, ktoré sa medzi adresami na ktoré ukazovatele ukazujú nachádzajú. Pokiaľ k ukazovateľu pripočítam, respektíve odpočítam celé číslo, je výsledkom ukazovateľ ukazujúci o príslušný počet prvkov vyššie, respektíve nižšie. Ak si predstavíme prvky s vyšším indexom nad prvkami s vyšším indexom. Tak je ale pole v C definované. Táto predstava je úplne dokonalá, pokiaľ si predstavíme ukazovateľ naprostred nejakého poľa. Pozrime sa teda na ukazovatele a pole. Majme nasledujúcu deklaráciu, int i, *pi, a[n]; nepriradzujme pre jednoduchosť už žiadne konkrétne hodnoty. Čo môžeme teraz s istotou povedať. Len to, čo vieme o umiestnení prvkov poľa. adresa prvku a[0] je &a[0] <--> a <--> a + 0. Posledný výraz už predstavuje súčet ukazovateľa s celočíselnou hodnotou. Ta musí byť nula, aby sa naozaj jednalo o ukazovateľ na prvý prvok poľa. Teraz nás iste neprekvapí, že nasledujúce výrazy uvedené na rovnakom riadku a + i <--> &a[i] *(a+i) <--> a[i] predstavujú iné zápisy toho istého výrazu. V prvom riadku ide o ukazovateľ na i+1. prvok, v druhom riadku potom hodnotu tohoto prvku. Pre konkrétne N rovné 100 dostávame, int i, *pi, a[100]; a nasledujúce priradenie je priradenie hodnoty jedného ukazovateľa ukazovateľu druhému, pi = a; /* pi teraz ukazuje na začiatok poľa a, na 1. prvok */ výrazy uvedené nižšie sú po tomto priradení zameniteľné (majú rovnaký význam, predstavujú hodnotu prvku poľa a s indexom i), a[i] <--> *(a+i) <--> pi[i] <--> *(pi+i). Ak budeme teraz potrebovať ukazovať na prostredný prvok poľa a, ľahko to môžeme urobiť s pomocou nášho pomocného ukazovateľa pi: pi = a + 49; /* p teraz ukazuje naprostred poľa a, na 50. prvok */ S týmto ukazovateľom sa potom môžeme posunúť na nasledujúci prvok poľa napríklad pomocou inkrementácie, lebo aj pri nej prekladač vie, o koľko bajtov má posunúť (zväčšiť)

5 adresu, aby ukazoval na nasledujúci prvok: ++pi alebo pi++, ale nie ++a ani a++, lebo a je konštantný ukazovateľ (je pevne spojený so začiatkom poľa). Časť venovanú poliam a aritmetike ukazovateľov ukončíme krátkym programom. V ňom si najmä všimnime skutočnosť, že formálne argumenty funkcií nie sú poľami, ale ukazovateľmi na typ. Naviac ich zmena neovplyvní zmenu argumentov skutočných (to by však prekladač nedovolil - sú predsa konštantné). Preto nieje problémom týmto funkciám predať ukazovateľ ako na začiatok poľa, tak na ľubovolný iný jeho prvok. Opatrnosť potom musíme zachovať čo sa týka predávaného počtu prvkov. C neprevádza kontrolu medzí! /****************************************************************/ /* subor CPYARRY.C */ /* na funkciach kopirujicich prvky jedneho pola do druheho */ /* ukazuje pristup k prvkom pola pomocou indexu a pomocou uka- */ /* zatela, teda pointerovu aritmetiku */ /****************************************************************/ #define N 6 #include <stdio.h> void copy_array1(int *a, int *b, int n) /* a - vstupne pole, b - vystupne pole, n - pocet prvkov */ register int i = 0; for (; i < n; i++) b[i] = a[i]; void copy_array2(int *a, int *b, int n) /* a - vstupne pole, b - vystupne pole, n - pocet prvkov */ while (n-- > 0) *b++ = *a++; void print_array(int *p, int n) /* vytlaci celociselne pole o n prvkoch */ /* zacne a skonci na novom radku */ puts(""); while (n-- > 0) printf("\t%d", *p++); puts(""); int main() int pole1[] = 1, 2, 3, 4, 5, 6, 7, 8, 9, pole2[n], dim1; dim1 = sizeof(pole1) / sizeof(int); print_array(pole1, dim1); copy_array1(pole1, pole2, N); print_array(pole2, N); copy_array2(pole1 + 3, pole2, N); print_array(pole2, N); return 0;

6 /* vystup vyzera nasledovne: */ Reťazce Reťazec je (jednorozmerné) pole znakov ukončené špeciálnym znakom vo funkcii zarážky. Na túto skutočnosť musíme myslieť pri definícii veľkosti poľa. Pre zarážku musíme rezervovať jeden znak. Teraz sa zamyslime nad zarážkou. Tá je súčasťou reťazca (bez nej by reťazec bol len pole znakov). Musí teda byť rovnakého typu, ako ostatné prvky reťazca - char. A pri pohľade na ASCII tabuľku nám zostane jediná použiteľná hodnota - znak s kódom nula: '\0'. Pozrime sa už na definíciu poľa, ktoré použijeme pre reťazec: char s[size]; Na identifikátor s sa môžeme dívať z dvoch pohľadov: Jednak ako na premennú typu reťazec (pole znakov, zarážku pridávame niekedy sami) dĺžky SIZE, ktorého jednotlivé znaky sú prístupné pomocou indexov s[0] až s[size-1]. Alebo ako na konštantný ukazovateľ na znak, t.j. na prvý prvok poľa s, s[0]. Reťazcové konštanty píšeme medzi dvojicu úvodzoviek, úvodzovky v reťazcovej konštante musíme uviesť špeciálnym znakom \ - opačné lomítko. Tak to sme si pripomenuli obsah jednej z úvodných kapitol. Pokračujme ešte chvíľu v jednoduchých ukážkach: "abc" je konštanta typu reťazec dĺžky 3+1 znak (zarážka), teda 3 znaky, 4 bajty pamäti (konštantné pole 4 znakov). "a" je tak isto reťazcovou konštantou, má dĺžku 1+1 znak 'a' je znaková konštanta (nepliesť s reťazcom!) Teraz si spojíme znalosti reťazcových konštánt a polí. Napríklad zápis char pozdrav[] = "hello"; je ekvivalentní zápisu char pozdrav[] = 'h','e','l','l','o','\0'; V oboch prípadoch sa dĺžka (dimenzia) poľa použije z inicializačnej časti. Druhý príklad je zaujímavý najmä nutnosťou explicitného uvedenia zarážky. Inak môžeme povedať, že sa tento spôsob zadania reťazca nepoužíva.

7 Ak sme pracovali s poľom znakov, prečo to teraz neskúsiť s ukazovateľom na znak. Nasledujúca definícia je veľmi podobná tým predchádzajúcim: char *ps = "retazec"; aj tak sa líši dosť podstatne. ps je ukazovateľ na znak, ktorému je priradená adresa reťazcovej konštanty retazec. Táto konštanta je teda umiestnená v pamäti, ale premenná ps na ňu ukazuje len do okamžiku, než jej hodnotu napríklad zmeníme. Potom však stratíme adresu konštantného reťazca "retazec". Jednoduchý program popisovanú situáciu ozrejmí (v ňom sme pochopiteľne nemenili hodnotu konštantného ukazovateľa na pole): /****************************************/ /* subor str_ptr.c */ /* ukazuje jednoduchu pracu s retezcami */ /****************************************/ #include <stdio.h> int main() char text[] = "world", *new1 = text, *new2 = text; printf("%s\t%s\t%s\n", text, new1, new2); new1 = "hello"; printf("%s\t%s\t%s\n", text, new1, new2); printf("%s\n", "hello world" + 2); return 0; /* world world world world hello world llo world */ Najdôležitejším bodom programu je priradenie new1 = "hello", v ňom iba meníme hodnotu ukazovateľa new1. Nedochádza pri ňom k žiadnemu kopírovaniu reťazcov. To by sa musel zmeniť obsah oboch ďalších reťazcov text aj new2, predsa pôvodne boli umiestnené na rovnakej adrese.

8 Podobné veci, ktoré môžeme robiť s ukazovateľmi, môžeme robiť aj s konštantnými reťazcami, napríklad: "ahoj svet" + 5 predstavuje ukazovateľ na "svet" Proste sme použili aritmetiku ukazovateľov a najmä fakt, že hodnota reťazcovej konštanty je rovnaká ako akéhokoľvek ukazovateľa na reťazec (a nielen na reťazec) - ukazovateľ na prvú položku. Naďalej si teda pamätajme približne toto. Pri práci s reťazcami nesmieme zabúdať na skutočnosť, že sú reprezentované ukazovateľmi. Iba zmenou či priradením ukazovateľa sa samotný reťazec nezmení. Preto s týmito ukazovateľmi nemôžeme prevádzať operácie tak, ako sme zvyknutý napríklad v Turbo Pascale. Na záver odstavca venovaného popisu práce s reťazcami si uveďme modifikáciu programu, ktorý kopíroval obsah jedného celočíselného poľa do iného. Dve varianty funkcie pre kopírovanie zdrojového reťazca do cieľového sú použité v programe: /************************************************/ /* subor STR_CPY.C */ /* ukazuje dve mozne implementacie kopirovania */ /* retezcov */ /************************************************/ #include <stdio.h> #define SIZE 80 void strcpy1(char *d, char *s) while ((*d++ = *s++)!= '\0') ; void strcpy2(char d[], char s[]) int i = 0; while ((d[i] = s[i])!= '\0') i++; int main() char s1[] = "prvy (1.) retazec", s2[] = "druhy (2.) retazec", d1[size], d2[size], *ps = s2; strcpy1(d1, s1); strcpy2(d2, s2 + 6); ps = s2 + 8; printf("s1[]:%s\t\ts2[]:%s\nd1[]:%s\t\td2[]:%s\n\t\t\t\t\t *ps:%s\n\n", s1, s2, d1, d2, ps); return 0;

9 /* s1[]:prvy (1.) retazec d1[]:prvy (1.) retazec */ s2[]:druhy (2.) retazec d2[]:(2.) retazec *ps:.) retazec Pozrime sa na obe kopírovacie funkcie. Nemusíme im predávať počet znakov. Zarážka má skvelú vlastnosť. Vďaka nej spoznáme koniec poľa. Súčasne však vzniká nebezpečie, že cieľový reťazec nebude mať dostatok priestoru pre zapísanie znakov z reťazca zdrojového. Reťazce zrejme budeme v našich programoch používať veľmi často. Iste by nám nebolo milé, keby sme museli písať pre každú operáciu nad reťazcami svoju vlastnú funkciu. Jednak by to vyžadovalo isté úsilie, jednak by sme museli vymýšľať jednoznačné a súčasne mnemonické identifikátory. Túto prácu našťastie robiť nemusíme. Zmienené funkcie sú súčasťou štandardnej knižnice funkcií a ich prototypy sú obsiahnuté v hlavičkovom súbore string.h. Nasledujúce riadky dávajú prehľad o najpoužívanejších reťazcových funkciách. Pretože sme sa reťazcom venovali dostatočne, uvedieme iba deklarácie týchto funkcií s ich veľmi stručným popisom. int strcmp(const char *s1, const char *s2); lexikograficky porovnáva reťazce, vracia hodnoty < 0 ak je s1 < s2 0 s1 == s2 > 0 s1 > s2 int strncmp(const char *s1, const char *s2, unsigned int n); ako predchádzajúca s tým, že porovnáva najviac n znakov unsigned int strlen(const char *s); vráti počet významných znakov reťazca (bez zarážky) char *strcpy(char *dest, const char *src); nakopíruje src do dest char *strncpy(char *dest, const char *src, unsigned int n); ako predchádzajúca, ale najviac n znakov (ak ich je práve n, nepridá zarážku) char *strcat(char *s1, const char *s2); s2 prekopíruje za s1 char *strncat(char *s1, const char *s2, unsigned int n); ako predchádzajúca, ale najviac n znakov char *strchr(const char *s, int c); vyhľadá prvý výskyt (zľava) znaku c v reťazci s char *strrchr(const char *s, int c); vyhľadá prvý výskyt (sprava) znaku c v reťazci s char *strstr(const char *str, const char *substr); vyhľadá prvý výskyt (zľava) podreťazca substr v reťazci str

10 7.5. Viacerozmerné pole, ukazovateľ na ukazovateľ Po dlhšej vsuvke, ktorá ukazovala podrobnejšie vlastnosti znakových polí - reťazcov, sa dostávame k problematike viacrozmerných polí. Najčastejšie nám zrejme pôjde o matice. Jazyk C umožňuje deklarovať pole iba jednorozmerné. Jeho prvky však môžu byť ľubovolného typu. Môžu teda byť opäť (napríklad) jednorozmernými poliami. To však už dostávame vektor vektorov, teda maticu. Ak budeme uvedeným spôsobom postupovať ďalej, vytvoríme dátovú štruktúru prakticky ľubovoľnej dimenzie. Potom už je potrebné mať len dostatok pamäte. Definícia matice (dvojrozmerného poľa) vyzerá takto: type meno[5][7]; kde typ určuje dátový typ položiek poľa meno predstavuje identifikátor poľa [5][7] určuje rozsah jednotlivých vektorov, 5 riadkov a 7 stĺpcov Pamätajme si zásadu, že posledný index sa mení najrýchlejšie (tak je viacrozmerné pole umiestnené v pamäti). S viacrozmerným poľom môžeme pracovať rovnako, ako s jednorozmerným. To sa prirodzene tyká aj možnosti inicializácie. Len musíme jednotlivé "prvky" - vektory, uzatvárať do zložených zátvoriek. Tento princíp je však rovnaký (čo sa opakujeme), ako pre vektor. Preto si priamo uveďme ukážkový program, prevzatý od klasikov - K&R. Našou úlohou je pre zadaný deň, mesiac a rok zistiť poradové číslo dňa v roku. Vo výpise je uvedená aj funkcia, majúca opačný význam. Pre deň v roku a rok (čo keď je priestupný) určí mesiac a deň. Riešenie je veľmi elegantné.

11 /****************************************/ /* subor yearday.c */ /* urci cislo dna v roku a naopak */ /* motivacia K&R */ /****************************************/ static int day_tab[2][13] = 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31; int day_of_year(int year, int month, int day) int i, leap; leap = year % 4 == 0 && year % 100!= 0 year % 400 == 0; for (i = 1; i < month; i++) day += day_tab[leap][i]; return day; int month_day(int year, int yearday, int *pmonth, int *pday) int i, leap; leap = year % 4 == 0 && year % 100!= 0 year % 400 == 0; for (i = 1; yearday > day_tab[leap][i]; i++) yearday -= day_tab[leap][i]; *pmonth = i; *pday = yearday; return i; int main() int year = 1993, month = 11, day = 12, yearday, m, d; yearday = day_of_year(year, month, day); month_day(year, yearday, &m, &d); return 0; Program nemá vstup ani výstup. Predstavuje proste definície funkcií a ukážku ich volania. Hneď v úvode je definované statické pole, obsahujúce počty dní v mesiacoch roku. Prvky s indexom nula majú nulovú hodnotu. Vďaka tomuto posunu voči štandardnému C indexovaniu má piaty mesiac index päť. Pole je dvojrozmerné. Jeho prvý vektor odpovedá bežnému roku, druhý vektor odpovedá roku prestupnému. Toto riešenie je veľmi rýchle a jeho pamäťové nároky nie sú premrštené. Funkcia day_of_year() určí pre vstupný year, month a day číslo dňa v roku. Funkcia obsahuje rozsiahlejší logický výraz, ktorý určí, či je rok priestupný alebo nie. Potom sa iba k zadanému dňu v zadanom mesiaci postupne pripočítavajú počty dní v mesiacoch predchádzajúcich. Funkcia month_day() má opačnú úlohu. Zo vstupných údajov year a yearday (číslo dňa v roku) vypočíta mesiac a deň. Problémom je, že výstupné hodnoty sú dve. Riešením sú formálne argumenty pmonth a pday, predávané adresou. Postup algoritmu výpočtu je opačný, než v predchádzajúcom prípade. Postupne sa odčítajú dĺžky mesiacov, dokiaľ nie je zbytok menší, než je počet dní mesiaca. Tento mesiac je potom výsledným mesiacom. Zbytok dňom v mesiaci. Návratová hodnota funkcie nemá prakticky žiadny význam. Je proste "do počtu".

12 7.6. Ukazovateľ na ukazovateľ a pole ukazovateľov Ukazovateľ je premenná ako každá iná. Prečo by sme teda na neho nemohli ukazovať nejakým iným (ďalším) ukazovateľom. Vo viacrozmernom poli prevádzame v podstate to isté, len jednotlivé vektory nie sú pomenované. Môžeme povedať, že pole ukazovateľov je v jazyku C nielen veľmi obľúbená, ale aj veľmi často používaná konštrukcia. Majme jednoduchú úlohu. Pole reťazcov (t.j. ukazovateľov na reťazce), ktoré máme zotriediť. Výhodou nášho riešenia je, že reťazce nebudú meniť svoju pozíciu v pamäti. Zamieňať sa budú len ukazovatele na ne. Naše pole nech sa volá v a nech má nejaký počet ukazovateľov na char. char *v[10]; Pokia2 umiestnime do jednotlivých ukazovateľov pole napríklad ukazovate2a na načítané riadky textu (nemusí mať rovnakú dĺžku), môžeme princíp triedenia ukázať na zámene dvoch susedných ukazovateľov (na reťazce) v poli. Pre väčšiu názornosť sú reťazce na obrázku v nesprávnom poradí: Stav pred výmenou: Stav po výmene: v[i] väčší v[i] väčší v[i+1] menší v[i+1] menší Dôležité je povšimnúť si, že text (reťazca) svoju pozíciu v pamäti nezmenil. To by bolo pomerne komplikované, ak si uvedomíme, ako prebieha zámena dvoch premenných. Zamenili sa iba adresy (hodnoty ukazovateľov), Po vysvetlení princípu sa môžeme pozrieť na program, ktorý lexikograficky zotriedi mená mesiacov v roku. Pretože štandardné knižnice C netriedia slovensky, niesu ani mená mesiacov slovensky, ale len "slovensky" bez mäkčeňov a dĺžňov. Všimnime si aj inicializáciu viacrozmerného poľa a zistenie počtu jeho prvkov.

13 /************************************************/ /* subor str_sort.c */ /*ukazuje triedenie pola ukazovateľov na retazce*/ /************************************************/ #include <stdio.h> #include <string.h> void sort(char **v, int n) int gap, i, j; char *temp; for (gap = n/2; gap > 0; gap /= 2) for (i = gap; i < n; i++) for (j = i - gap; j >= 0; j -= gap) if (strcmp(v[j], v[j+gap]) <= 0) break; temp = v[j]; v[j] = v[j+gap]; v[j+gap] = temp; int main() char *name[] = "chyba", "januar", "februar", "marec", "april", "maj", "jun", "jul", "august", "september", "oktober", "november", "december" ; int i; puts("mena mesiacov v roku (podla poradia):"); for (i = 0; i < 13; i++) printf("%2d. mesiac je : %s\n", i, name[i]); puts("\na teraz po zotriedeni:"); sort(name, sizeof(name)/sizeof(char *)); for (i = 0; i < 13; i++) printf("%2d. mesiac je : %s\n", i, name[i]); return 0; Nevýhoda zobrazenia mien všetkých mesiacov pred aj po zoradení sa prejaví na monitoroch s najviac 25 textovými riadkami. Nechceli sme však program robiť menej prehľadným, preto sme takýto výstup ponechali.

14 7.7. Ukazovateľ na funkciu. Ukazovateľ na funkciu sme mohli začleniť do predchádzajúcej podkapitoly. Jedná sa často o Ukazovateľ alebo o pole ukazovateľov. Funkcia však nielen vracia hodnotu istého typu, ale môžu mať aj rôzny počet argumentov rôzneho typu. Pretože je použitie ukazovateľov na funkciu nielen veľmi mocným prostriedkom C, ale aj prostriedkom veľmi nebezpečným, rozhodli sme sa popísať ukazovateľ na funkciu v samostatnej podkapitole. Definujme napríklad ukazovateľ na funkciu, ktorá nemá argumenty a vracia hodnotu zvoleného dátového typu: typ (*meno)(); Poznamenajme, že zátvorky okolo identifikátoru meno a úvodné hviezdičky sú nutné, lebo zápis typ *meno(); predstavuje funkciu vracajúcu ukazovateľ na typ. Príkladom použitia ukazovateľa na funkciu môže byť knižničná funkcia qsort(). Jej deklarácia je nasledovná: void qsort(void *base, size_t nelem, size_t width, int (*fcmp)(const void *, const void *)); kde base je začiatok poľa, ktoré chceme zotriediť nelem je počet prvkov, ktoré chceme zotriediť (rozsah poľa) width je počet bajtov, ktorý zaberá jeden prvok fcmp je ukazovateľ na funkciu, prevádzajúcu porovnanie, ta má ako argumenty dva konštantné ukazovatele na práve porovnávané prvky (potrebné pretypovať) Prototyp funkcie qsort() je v hlavičkovom súbore stdlib.h. Funkcia qsort() je napísaná všeobecne a tak nemá žiadne konkrétne informácie o typoch hodnôt, ktoré triedi. Túto záležitosť rieši naša užívateľská funkcia, ktorá správne porovná hodnoty. Lebo my vieme, čo triedime. Ukážku použití funkcie spolu s meraním času a použitím generátoru náhodných čísel nám dáva program:

15 /********************************************************/ /* subor fn_qsrt.c */ /* ukazuje pouzitie qsort() a definiciu a pretypovanie */ /* uzivatelskej porovnavacej funkcie */ /********************************************************/ #include <time.h> #include <stdio.h> #include <stdlib.h> #define POCET 1000 #define RND_START 1234 int float_sort (const float *a, const float *b) return (*a - *b); /* <0, ==0, >0 */ /* int float_sort (const float *a, const float *b) */ void test (float *p, unsigned int pocet) /* otestuje ci dane pole je zotriedene vzostupne */ int chyba = 0; for (;!chyba && --pocet > 0; p++) if (*p > *(p+1)) chyba=1; puts ((chyba)? "\npole nieje zotriedene\n" : "\npole je zotriedene\n"); /* void test (float *p,unsigned int pocet) */ void vypln(float *p, int pocet) /* vypni pole dane adresou a poctom prvkov nahodnymi */ /* cislami pomocou generatora nahodnych cisel */ srand(rnd_start); while (pocet-- > 0) *p++ = (float) rand(); /* void vypln(float *p, int pocet) */ int main (void) static float pole [POCET]; clock_t start, end; vypln (pole, POCET); start = clock(); qsort(pole, POCET, sizeof(*pole), (int (*) (const void *, const void *)) float_sort); end = clock(); printf ("Triedenie qsort trvalo %fs", (end - start) / CLK_TCK); test (pole, POCET); getc (stdin); return 0; /* int main (void) */ Pri práci s ukazovateľmi na ukazovatele, a teda aj na funkcie, je veľmi užitočné zaviesť nový typ, ktorý definujeme podľa nášho zámeru. Odkaz na tento nový typ výrazne sprehľadní náš program. Pred uvedením ďalšej ukážky poznamenajme, že odkazy na funkcie môžu byť aj externé. Znamená to, že máme možnosť nezávisle na zdrojovom texte definovať funkciu s požadovanými vlastnosťami, ktorú potom pripojíme do výsledného programu. Naša ukážka však používa len ukazovateľ na v súbore definované funkcie.

16 /********************************/ /* subor PTR_FN01.C */ /* pole ukazovateľov na funkciu */ /********************************/ #include <stdio.h> #include <process.h> typedef void (*menu_fcn) (void); /* definicia typu */ menu_fcn command[3]; /* pole troch ukazovateľov na funkcie */ void fn_1(void) /* definicia prvej funkcie */ /**************/ puts("funkce cislo 1\n"); /*puts() je kratsi, nez printf() */ /* void fn_1(void) */ void fn_2(void) /* definicia druhej funkcie */ /**************/ puts("funkce cislo 2\n"); /* void fn_2(void) */ void fn_3(void) /* definicia tretej funkcie */ /**************/ puts("funkce cislo 3\nKONEC\n"); exit(0); /* ukoncenie chodu programu */ /* void fn_3(void) */ void assign_fn(void) /* priradenie ukazovateľa na fciu */ /******************/ /* do pola ukazovateľov */ command[0] = fn_1; command[1] = fn_2; command[2] = fn_3; /* void assign_fn(void) */ void menu(void) /* funkcia s ponukou */ /*************/ int choice; do puts("1\tpolozka\n2\tpolozka\n3\tukoncenie\n"); putchar('>'); scanf("%d", &choice); if (choice >= 1 && choice <= 3) command[choice - 1](); /* ^ volanie funkcie pomocou pola ukazovateľov, () su nutne */ while (1); /* nekonecny cyklus */ /* void menu(void) */ int main(void) /* hlavna funkcia programu */ /************/ assign_fn(); /* volanie spravnej inicializacie pola ukazovatelov */ menu(); /* volanie ponuky, obsahuje aj volbu ukoncenia */ return 0; /* tento riadok je vlastne zbytocny, program */ /* ukonci exit() v tretej funkcii - fn_3 */ /* int main(void) */

17 7.8. Argumenty príkazového riadku Pokiaľ ešte spúšťame programy z príkazového riadku, asi rovnako vieme, že im môžeme predať argumenty. Často to bývajú mená vstupného a výstupného súboru, prepínače.... Rovnaká situácia je aj v prípade, kedy spúšťame program z iného programu. Aby nám boli argumenty príkazového riadku v programe dostupné, stačí rozšíriť definíciu funkcie main o dva argumenty. Situácia je podobná, ako pri funkcii s premenným počtom argumentov. Prvý argument funkcie main() udáva počet argumentov príkazovom riadku (1 = len meno programu, 2 = meno programu + jeden argument,...). Je celočíselného typu. Druhý argument funkcie main() predstavuje hodnoty týchto argumentov. Jeho typ je pochopiteľne pole ukazovateľov na reťazce, lebo nimi argumenty príkazového riadku skutočne sú. Je dobrým zvykom popísané argumenty funkcie main() pomenovať argc a argv, kde c znamená count a v znamená value. Program zobrazujúci argumenty, s ktorými bol spustený: /************************************************/ /* subor CMD_LN04.C */ /* pomocou ukazovateľov, dva formaty printf */ /************************************************/ #include <stdio.h> int main(int argc, char **argv) while (argc-- > 0) printf((argc > 0)? "%s " : "%s\n", *argv++); return 0; Pre lepšiu predstavu sa pozrime, ako bude vyzerať situácia s argumentmi príkazového riadku pri spustení príkladu. Priznajme, že prvý argument, teda cmd_ln04, bude do prostredia spusteného programu rozvinutý v úplnej podobe. Viac-menej verme, že obrázok je, cez drobnú nepresnosť, užitočný.

18 Na záver rozsiahlej kapitoly venovanej poliam a ukazovateľom si zopakujme hlavné zásady pre prácu s nimi: nesmieme sa odkazovať na neinicializovaný ukazovateľ ak je p ukazovateľ na nejaký typ, potom *p je práve ta hodnota, na ktorú ukazuje identifikátor poľa je len konštantný ukazovateľ na toto pole nebojme sa aritmetiky ukazovateľov Predchádzajúca kapitola Obsah Začiatok Nasledujúca kapitola