Skočiť na obsah


Programovanie v jazyku C a C#

Návody pre začiatočníkov a pokročilých



Fórum: Škôlka jazyka C
* * * * *
Fotografia

1. lekcia C (Súbory) základná škola


1. Vstup zo súboru a výstup do súboru
Z implementačného (hardwareového) hľadiska je každý súbor postupnosť Byte,
uložených na nejakom médiu (najčastejšie disku) v niekoľkých blokoch.
Bloky majú rovnakú veľkosť a nemusia ležať za sebou. Ako sa s nimi pracuje
je vyslovene záležitosť operačného systému (OS) a to nás nemusí zaujímať.
Súbor je teda vytváraný podľa pravidiel daných OS. Prístup k súboru je možný
ako sekvenčne, tak aj náhodne.
Z dôvodu co najväčšieho obmedzenia počtu periferný operácií (pre zvýšenie rýchlosti),
sú vstupné/výstupné (Input/Output) operácie bufferované, tzn.:
* Pre vstup
Naraz sa prečíta celý blok dát z disku do pamäti (bufferu). Jednotlivé položky
sa potom čítajú z pamäti a nie priamo z disku, čo je podstatne rýchlejšie.
* Pre výstup
Dáta sa nezapisujú priamo na disk, ale do bufferu a keď je plný, zapíše sa automaticky
celý obsah bufferu na disk do súboru ako jeden blok.

1.1 Začiatok práce so súborom
Najdôležitejšia rada:
Nehľadajte v práci so súbormi žiadne zložitosti!
Základný dátový typ je:
FILE * -> je pointer na objekt typu FILE
Definícia premennej f pre prácu so súborom:
FILE *f;
Treba si uvedomiť, že premenná f sa dá použiť ako pre čítanie súboru, tak aj pre zápis
do súboru.
Ak chceme definovať viac premenných, teda pracovať s viac súbormi naraz
(napr. pre čítanie a zápis) musí sa znak * opakovať:
FILE *fr, *fw;
Prehľadnosť kódu je lepšia, ak sa premenné používajú:
*fr -> čítanie (read)
*fw -> zápis (write)
Otvorenie súboru pre čítanie:
fr = fopen("POKUS", "r");
Otvorenie túboru pre zápis
fw = fopen("POKUS", "w");

1.2 Základné operácie s otvoreným súborom
Funkcie z knižnice stdio.h, ktoré umožňujú pracovať so súborom:
(premenná f je typu FILE *.)

čítanie zo súboru	 c = getc(f)

zápis znaku do súboru	 putc(c, f)

formátované čítanie zo súboru	 fscanf(f, "formát", argumenty)

formátovaný zápis do súboru	 fprintf(f, "formát", argumenty)

1.3 Ukončenie práce so súborom
Po ukončení práce so súborom je nutné túto skutočnosť OS zdeliť.
Táto akcia sa nazýva zavretie súboru a prevádza sa funkciou:
fclose(f);

Poznámka:
Aj napriek tomu, že mnohé systémy zavierajú súbory po skončení programu automaticky,
je zlým zvykom sa na to spoliehať, už len preto, že počet súčasne orvorených súborov
je obmedzený.
Ďalším dôvodom je zápis bufferu do súboru. Pri prípadnej havárii programu, by sa dáta
z bufferu nemuseli zapísať na disk a stratili by sa.

1.4 Príklady základnej práce so súbormi
Program vytvorí súbor POKUS.TXT a zapíše do neho čísla 1 - 10, každé na nový riadok.

#include <stdio.h>

main()

{

FILE *fw;

int i;



fw = fopen("POKUS.TXT", "w");

for (i = 1; i <= 10; i++)

	fprintf(fw, "%d \n", i);

fclose(fw);

}

Skontrolujte si výstup programu (textovým editorom). Súbor POKUS.TXT sa vytvoril
v priečinku, kde je uložený program.

Program prečíta tri double čísla zo súboru DATA.TXT a vypíše na obrazovku ich súčet.
(Najskôr vytvorte v textovom editore súbor a vložte doňho tri reálne čísla. Je jedno,
či budú vedľa seba oddelené medzerou, alebo každé na inom riadku.)

#include <stdio.h>

main()

{

FILE *fr;

double x, y, z;



fr = fopen("DATA.TXT", "r");

fscanf(fr, "%lf %lf %lf", &x, &y, &z);

printf("%f\n", x +y +z);

fclose(fr);

}

Dá sa ľahko otestovať, či súbor obsahuje všetky tri double čísla:

if (fscanf(fr, "%lf %lf %lf", &x, &y, &z) == 3)

	printf("%f\n", x +y +z);

else

	printf("Súbor DATA.TXT neobsahuje tri reálne čísla.\n");

Vyskúšajte si pridať do súboru ďalšie čísla a potom ubrať na max. dva a otestujte.

Program prečíta dva znaky zo súboru ZNAKY.TXT a zapíše ich do súboru KOPIA.TXT.
Pozor, znaky sa čítajú do premennej typu int!

#include <stdio.h>

main()

{

FILE *fr, *fw;

int c;



fr = fopen("ZNAKY.TXT", "r");

fw = fopen("KOPIA.TXT", "w");



c = getc(fr);		 /* čítanie prvého znaku */

putc(c, fw);		 /* zápis prvého znaku */

putc(getc(fr), fw);	/* cítanie a zápis druhého znaku */



fclose(fr);

fclose(fw);

}

1.5 Testovanie konca riadku
Céčko poskytuje štandartný znak pre koniec riadku ('\n'). Používa sa ako na testovanie
konca riadku, tak aj na zápis konca riadka.
Funkcia getchar() alebo gets() neprevádza test konca riadka. Táto činnosť je vecou
programátora. Základný trik pre čítanie až do konca riadku je:

if ((c = getc(fr)) != '\n')

Príklad:
Program prečíta jeden riadok zo súboru DOPIS.TXT a vypíše ju na monitor vrátane
znaku nového riadku.

#include <stdio.h>

main()

{

int c;

FILE *fr;



fr = fopen("DOPIS.TXT", "r");

while ((c = getc(fr)) != '\n')

	putchar(c);

putchar(c);		/* výpis '\n' - odriadkovanie */

fclose(fr);

}

1.6 Testovanie konca súboru
Je možné dvomi rovnocennými spôsobmi.
Pri textových súboroch záleží len na programátorovi či bude používať konštantu EOF
alebo makro feof().
Treba poznamenať, že pri použití feof() bude program pravdepodobne pomalší,
pretože je tu navyše volanie toho makra.
Pomocou symbolickej konštanty EOF
Pri čítaní na konci súboru sa automaticky vracia konštanta EOF, ktorá je väčšinou
definovaná v súbore stdio.h.
Základný trik pre čítanie súboru až do konca je:

if ((c = gets(fr)) != EOF)

Poznámka:
Premenná c nesmie byť definovaná ako char, pretože EOF je často reprezentovaná
int hodnotou -1.
Príklad:
Program skopíruje súbor DOPIS.TXT do KOPIA.TXT.

#include <stdio.h>

main()

{

FILE *fr, *fw;

int c;



fr = fopen("DOPIS.TXT", "r");

fw = fopen("KOPIA.TXT", "w");



while ((c = getc(fr)) != EOF)

	putc(c, fw);

fclose(fr);

fclose(fw);

}

Pomocou štandartného makra feof()
Tento spôsob je vhodnejší keď čítame z binárneho (nie textového) súboru.
Príklad:
To isté za pomoci feof().

#include <stdio.h>

main()

{

FILE *fr, *fw;

int c;



fr = fopen("DOPIS.TXT", "r");

fw = fopen("KOPIA.TXT", "w");



while (c = getc(fr), feof(fr) == 0) {

	putc(c, fw);

}

fclose(fr);

fclose(fw);

}

1.7 Testovanie správnosti otvorenia a zavretia súboru
Vhodné využívať pre ladenie programu, hlavne pri väčších programoch. Teda
treba si zvyknúť to používať vždy pri práci so súbormi.
Pri nesprávnom otvorení súboru vracia fopen() konštantu NULL.
Použitie:

if ((fr = fopen("DOPIS.TXT", "r")) == NULL)

	printf("Subor DOPIS.TXT sa nepodarilo otvorit.\n");

Pri nesprávnom zavretí súboru vracia fclose() hodnotu EOF.
Použitie:

if (fclose(fr) == EOF)

	printf("Subor sa nepodarilo zavriet.\n");

Príklad:
Takto by mal vyzerať predchádzajúci program, s ošetrením všetkých súborových operácií.

#include <stdio.h>

main()

{

FILE *fr, *fw;

int c;



if ((fr = fopen("DOPIS.TXT", "r")) == NULL) {

	printf("Subor DOPIS.TXT sa nepodarilo otvorit.\n");

return;		/* ukoncenie programu */

}



if ((fw = fopen("KOPIA.TXT", "w")) == NULL) {

	printf("Subor KOPIA.TXT sa nepodarilo otvorit.\n");

return;		/* ukoncenie programu */

}



while ((c = getc(fr)) != EOF)

	putc(c, fw);



if (fclose(fr) == EOF) {

	printf("Subor DOPIS.TXT sa nepodarilo zavriet.\n");

return;		/* nevhodne */

}



if (fclose(fw) == EOF) {

	printf("Subor KOPIA.TXT sa nepodarilo zavriet.\n");

return;		/* zbytocne */

}

}

Poznámka:
Uvedený program obsahuje jednu logickú chybu. Keby sa podarilo otvoriť DOPIS.TXT
a KOPIA.TXT nepodarilo, potom by program skončil a DOPIS.TXT by ostal otvorený
a musel by ho zavrieť OS.
Táto chybe nie je veľká, pretože OS ho zavrie za nás, ale dobrým programátorským
zvykom býva, nespoliehať sa na niečo čo môže alebo by mal urobiť niekto iný, ale
radšej to zabezpečiť sám.
Príklad:
Program vypíše súbor DOPIS.TXT na monitor tak, že skonvertuje všetky malé písmená
na veľké a nakoniec vypíše dĺžku najdlhšieho prečítaného riadku.

#include <stdio.h>

main()

{

FILE *fr;

int c,

	 najdlhsi = 0,

	 pocet = 0;

	

if ((fr = fopen("DOPIS.TXT", "r")) == NULL) {

	printf("Subor DOPIS.TXT sa nepodarilo otvorit.\n");

return;

}



while ((c = getc(fr)) != EOF) {

	putchar(c >= 'a' && c<= 'z' ? c + 'A' - 'a' : c);

	if (c == '\n') {

	 if (najdlhsi < pocet)

		najdlhsi = pocet;

	 pocet = 0;

	}

	else

	 pocet++;

}

printf("\n\nNajdhsi riadok obsahoval %d znakov.\n", najdlhsi);



if (fclose(fr) == EOF) {

	printf("Subor DOPIS.TXT sa nepodarilo zavriet.\n");

return;

}

}

1.8 Štandartný vstup a výstup
V hlavičkovom súbore stdio.h sú definované dva konštantné pointery, ktoré predstavujú
dva súbory otvorené OS pri spustení programu. Sú to:
FILE *stdin;
FILE *stdout;
Tieto pointery sa označujú ako štandartný vstupný/výstupný prúd (standard input/output
stream) a väčšinou predstavujú vstup z klávesnice a výstup na obrazovku. Tieto I/O prúdy
je možné v mnohých OS jednoducho meniť pomocou presmerovania napr. na vstup zo súboru,
alebo výstup do súboru bez zásahu do samotného programu.
Napríklad v MS-DOS program TLAC.EXE spustený príkazom:
A:\>tlac
tlačí niečo na obrazovku. Ak ale použijeme rovnaký program a spustíme ho príkazom:
A:\>tlac > vystup.txt
nebude nič vypisovať na obrazovku, ale celý výstup zapíše do súboru VYSTUP.TXT,
ktorý sám vytvorí, otvorí a nakoniec zavrie.
Poznámky:
* V súbore stdio.h je definovaný ešte tretí prúd: stderr, ktorý sa používa na vypisovanie
chybových správ programu.
* V aplikáciách pod MS-DOS bývajú tiež navyše:
stdaux - sériové rozhranie
stdprn - paralelné rozhranie (väčšinou tlačiareň)
* stdin a stdout môžu byť použité v programe ako argumenty operácií so súbormi, napr.:

getc(stdin)		 je ekvivalentom	 getchar()

putc(c, stdout)	 je ekvivalentom	 putchar()

Príklad:
Program ukáže, ako sa dá využiť stdout a tiež ako sa vyhnúť problémom pri čítaní
bufferovaného vstupu. Pri čítaní z tohoto vstupu je treba mať na pamäti, že aj keď
očakávame jeden znak, môže prísť celý zvyšok riadku, teda napr. aj znak '\n', pretože
užívateľ musel stlačiť klávesu <Enter>, aby mohol byť operačným systémom do bufferu
zapísaný znak z tohoto bufferu programátorom prečítaný. Je teda nutné prečítať z bufferu
všetky znaky, ktoré sa v ňom nachádzajú, čím sa v budúcnosti vyhneme problémom,
že program číta znak (najčastejšie '\n'), ktorý užívateľ napísal z klávesnice,
lebo musel.
Program najprv vypíše dotaz, či má byť vstup vypísaný na obrazovku,
alebo do súboru VYSTUP.TXT. Pokiaľ užívateľ zvolí súbor VYSTUP.TXT, program ho skúša
otvoriť na čítanie, čím testuje, či tento súbor existuje. Ak existuje, spýta sa,
či má byť prepísaný.

#include <stdio.h>

main()

{

FILE *fw;

int c;

printf("Stlac M pre vypis na monitor.\n");

printf("Alebo iny znak pre zapis do suboru VYSTUP.TXT: \n");



c = getchar();

/* vyprazdnenie bufferu - preskoci zvysok riadku */

while (getchar() != '\n')

	;

if (c == 'm' || c == 'M')

	fw = stdout;

else {

	if ((fw = fopen("VYSTUP.TXT", "r")) != NULL) {

	 printf("Subor VYSTUP.TXT existuje, prepisat? [A/N]: ");

	 while (getchar() != '\n')

		;

	 if (fclose(fw) == EOF) {

		printf("Chyba pri zavierani suboru.\n");

		return;

	 }

	

	 if ( !(c == 'a' || c == 'A') )

		return;		 /* koniec programu */

	}

	

	if ((fw = fopen("VYSTUP.TXT", "w")) == NULL) {

	 printf("Subor VYSTUP.TXT sa nepodarilo otvorit.\n");

	 return;

	}

}

printf("Napiste text a ukoncite ho znakom *.\n");

while ((c = getchar()) != '*')

	putc(c, fw);

	

if (fw != stdout && fclose(fw) == EOF) {

	printf("Subor VYSTUP.TXT sa nepodarilo zavriet.\n");

	return;

}

}

Poznámka:
Cyklus:

while (getchar() != '\n')

	;

je veľmi dôležitý, pretože po stlačení prvého znaku (zápis na monitor alebo do súboru)
nasleduje ešte jeden znak <Enter>, ktorý by bol z bufferu prečítaný ako odpoveď na otázku,
či prepísať súbor VYSTUP.TXT.
1.9 Vrátenie prečítaného znaku späť do vstupného bufferu
Pri programovaní reálnych aplikácií sa v mnohých prípadoch pri čítaní znakov dozvedáme,
že máme prestať čítať, až keď prečítame jeden znak navyše. Tento znak ale nie je možné
"zahodiť", pretože je súčasťou - začiatkom ďalšej informácie.
V týchto prípadoch sa dá použiť funkcia ungetc(c, fr), ktorá vráti posledný prečítaný
znak späť do vstupného bufferu. Ak sa to podarí, funkcia ungetc() vráti pre kontrolu
tento znak. Pri neúspechu sa vráti EOF. Obvykle sa do vstupného bufferu vráti len
jeden znak.
Priklad:
Táto časť programu konvertuje znakový reťazec na zodpovedajúcu číselnú hodnotu.

int c, hodnota = 0;

while ((c = getchar()) >= '0' && c <= '9') {

	hodnota = hodnota * 10 + (c - '0');

}

ungetc(c, stdin);

Príklad:
Toto rieši prípad, keď je číslo v súbore sprevádzané neznámym počtom znakov (v tomto
prípade '$') a my toto číslo chceme čítať pomocou funkcie fscanf(). Predpokladá sa
už otvorený súbor na čítanie.

int c, hodnota = 0;

while ((c = getc(fr)) == '$')

	;			 /* precita vsetky predchadzajuce znaky $ */

ungetc(c, fr);	/* vratenie prvej cislice cisla do bufferu */

fscanf(fr, "%d", &hodnota);

Poznámka:
* Späť do vstupného bufferu sa dá vrátiť aj iný znak, ako naposledy prečítaný.
Tento trik sa dá použiť napr. na predvolenie klávesy, ktorá bude neskôr akoby stlačená.
1.10 Rôzne možnosti otvárania súborov

f = fopen("SUBOR", "rezim");

Rôzne významy parametra "režim":

r		 --- textový súbor pre čítanie

w		 --- textový súbor pre zápis alebo prepísanie

a		 --- textový súbor pre pripojenie na koniec

rb		 --- binárny súbor pre čítanie

wb		 --- binárny súbor pre zápis alebo prepísanie

ab		 --- binárny súbor pre pripojenie na koniec

r+		 --- textový súbor pre čítanie a zápis

w+		 --- textový súbor pre čítanie, zápis alebo prepísanie

a+		 --- textový súbor pre čítanie a zápis na koniec

rb+		--- binárny súbor pre čítanie a zápis

wb+		--- binárny súbor pre čítanie, zápis alebo prepísanie

ab+		--- binárny súbor pre čítanie a zápis na koniec

Poznámky:
1) Niektoré kompilátory umožňujú explicitne označiť, že sa jedná o textový súbor, teda
režimy "rt", "wt", "at"
2) Ak otvoríme už existujúci súbor v režime "w" ("wb"), tak sa tento súbor najprv vymaže
a potom sa znovu založí. Je to teda prepísanie súboru!
3) Ak otvoríme už existujúci súbor v režime "a" ("ab"), súbor sa otvorí a ukazovateľ
pozície sa presunie na jeho koniec. Dochádza teda k rozšíreniu existujúceho súboru(append).
A súbor ešte neexistuje, vytvorí sa!
4) Ak použijeme režim rozšírený o '+', dá sa aj čítať aj zapisovať. Toto má praktický
význam len v binárnych súboroch.
5) V OS UNIX netreba binárne a textové súbory rozlišovať. To znamená, že doplnenie režimov
t - textový a b - binárny nemá význym.
1.11 Práca s binárnymi súbormi
Textové súbory majú výhodu, že je možné si ich obsah kedykoľvek prehliadnuť, vytvoriť
alebo upraviť bežným editorom. Ich nevýhodou je, že na uchovanie rovnakého množstva
informácií potrebujú oveľa viac priestoru ako binárne súbory. Napríklad číslo 65535 zaberie
v textovom priestor 5 Byte a v binárnom len 2 Byte.
Druhou výhodou binárnych súborov je, že sa snimi pracuje omnoho rýchlejšie ako s textovými.
Dôvody sú dva:
1 - binárny súbor je kratší
2 - zapisuje sa priamo do pamäti po Bytoch (pri zápise čísla do textového súboru je nutné
urobiť jeho konverziu z vnútornej reprezentácie čísla v počítači na textovú podobu a to
je časovo náročné)
Z týchto dôvodov sa binárne súbory v profesionálnych programoch využívajú pomerne často.
Najvýhodnejšie je ich použitie na ukladanie rozmerných dát - veľkých polí, štruktúr, atď.
Pre uloženie znakov nemajú veľký význam, pretože znak zaberá v textovom súbore jeden Byte,
rovnako ako v binárnom.
Pre prácu s binárnymi súbormi sa používajú nasledujúce funkcie:
Čítanie a zápis do binárneho súboru

fread()	 čítanie

fwrite()	 zápis

Funkcie majú tieto funkčné prototypy:
int fread(char *kam, int veľkosť, int počet, FILE *súbor);
int fwrite(char *odkiaľ, int veľkosť, int počet, FILE *súbor);
kde jednotlivé parametre majú význam:

kam		---adresa pamäti, kam sa bude ukladať prečítaný blok dát

odkiaľ	 ---adresa pamäti, odkiaľ sa bude brať zapisovaný blok dát

veľkosť	---dlžka jednej položky z bloku dát (treba použiť sizeof())

počet	 ---počet datových položiek (nie Byte!)

súbor	 ---premenná pre prácu so súborom

Obidve funkcie vracajú počet skutočne úspešne zapísaných/prečítaných položiek
--> pozor, nie Byte!
Pohyb v binárnom súbore
V textových súboroch sa veľmi nevyužíva možnosť pohybu v súbore -- jednotlivé znaky
sa v nich sekvenčne čítajú.
V binárnych, kde poznáme presne veľkosti jednotlivých položiek, je veľakrát veľmi užitočná
možnosť nastaviť si ukazovátko do súboru na ľubovolné miesto. Od tohto miesta sa bude ďalej
čítať, alebo sa bude od neho ďalej zapisovať, bez nutnosti zdržovaním sa čítaním
predchádzajúcich dát.
Pre nastavenie pozície v súbore sa používa funkcia fseek():
int fseek(FILE *súbor, long posun, int odkiaľ);
kde jednotlivé parametre majú význam:

súbor	 ---premenná pre prácu so súborom

posun	 ---počet Byte od pozície v súbore danej parametrom odkiaľ

odkiaľ	 ---miesto, odkiaľ sa bude v súbore posúvať

		 ---môže mať jednu z troch hodnôt:

			 *SEEK_SET - od začiatku súboru

			 *SEEK_CUR - od aktuálnej pozície

			 *SEEK_END - od konca súboru

Funkcia fseek() vracia nulu (FALSE) v prípade úspešného presunu alebo nenulovú hodnotu
(TRUE) v prípade neúspešného presunu.
Pokiaľ potrebujeme zistiť, kde sa v súbore práve nachádzame, je možné použiť funkciu:
long ftell(FILE *súbor)
ktorá vracia posunutie merané v Byte od začiatku súboru.
Príklad použitia binárneho súboru
Program zapíše do binárneho súboru POKUS.DAT hodnoty dvoch premenných (i a d). Súbor je
otvorený ako binárny na čítanie aj zápis, čo umožňuje, aby sa po zápise oboch premenných
a presunu ukazovateľa v súbore dalo z tohto súboru hneď čítať. Všimnite si tiež, ako sa
zadáva adresa premennej (rovnako ako pri použití funkcie scanf()) a ako sa najleším
spôsobom zistí veľkosť premennej.

#include <stdio.h>

main()

{

FILE *f;										/* pre citanie aj zapis */

int i = 5;

double d = 3.14159;



f = fopen("POKUS.DAT", "wb+");

fwrite(&i, sizeof(i), 1, f);					/* zapis dat do suboru */

fwrite(&d, sizeof(d), 1, f);

	

printf("Pozicia v subore je %ld \n", ftell(f));

fseek(f, 0, SEEK_SET);						 /* posun na zaciatok suboru */



i = 0; d = 0.0;								 /* nulovanie premennych */

fread(&i, sizeof(i), 1, f);					 /* citanie a zobrazenie dat */

fread(&d, sizeof(d), 1, f);

printf("Nacitane data: i = %d, d = %f \n", i, d);

fclose(f);

}

Úlohy:

1) Vytvorte textový súbor ZNAKY.TXT, v ktorom budú náhodné znaky. Tento súbor čítajte
po znakoch v cykle do-while. Ak je prečítaný znak 'q' (Quit), program ukončite.
Ak je znak '0', vypíšte: Bola to nula
Ak je prečítaný znak '1', vypíšte: Bola to jednicka
Testujte aj OEF a použite switch.
Spoiler

2) Vytvorte textový súbor DOPIS.TXT, v ktorom bude niekoľko riadkov z malých,
veľkých písmen a medzier. Tento súbor celý vypíšte na monitor. Súčasne do súboru
KOPIA.TXT zapíšte obsah čítaného súboru, ale malé písmená preveďte na veľké.
Spoiler

3) Napíšte program, ktorý spočíta celkový počet znakov súboru DOPIS.TXT.
Spoiler

4) Napíšte program, ktorý prečíta PISMENA.TXT po riadkoch. Každý riadok presne opíšte
do súboru KOLKO.TXT a na novom riadku uveďte. koľko malých písmen v riadku bolo.
Spoiler

5) Vytvorte program, ktorý zapíše do súboru CISLA.TXT dvadsať reálnych čísiel,
- násobkov 3.14. Pred každé číslo napíšte znak "$" a každé číslo napíšte na samostatný
riadok. napr.:
$3.14
$6.28
Spoiler

6) Čítajte všetky reálne čísla zo súboru CISLA.TXT a vypočítajte ich aritmetický priemer.
Vo funkcii fscanf() vyskúšajte formáty čítania "%f", "%f\n", " %f", " %f\n".
Koniec súboru netestujte pomocou EOF, ale pomocou návratovej hodnoty funkcie fscanf().
Spoiler

7) Napíšte program, ktorý porovná oblasť súborov PISMENA1.TXT a PISMENA2.TXT
(vytvorte ich napríklad pomocou príkazu operačného systému - copy).
Program vypíše hlásenie:
"Subory su zhodne."
alebo
"Subory sa lisia v x znakoch."
Odlišné znaky priebežne vypisujte.
Spoiler

8) Napíšte program, ktorý sa pokúsi čítať neexistujúci súbor. Zaistite, aby program
vhodne reagoval na túto situáciu.
Spoiler

9) Napíšte program, ktorý číta znaky zo súboru PISMENA.TXT a odpisuje ich buď na obrazovku,
alebo do súboru NOVY.TXT. Užívateľ má možnosť si vybrať smer výstupu.
Spoiler

10) Napíšte program, ktorý vypisuje prirodzené čísla od 1. Po každých 10 číslach vypíše otázku:
"Mam pokracovat ? [A/N] :"
a podľa odpovede sa zariadi.
Spoiler

11) V súbore CISLA.TXT je na každom riadku jedno celé číslo, ktorému predchádza neznámy
počet znakov "$". Spočítajte tieto čísla a výsledok vypíšte na obrazovku.
Spoiler
  • 0

Popis: Súbory

- FILE *fr, *fw;
- testovanie konca riadku
- testovanie konca súboru
- testovanie správnosri otvorenia a zavretia
súboru
- štandartný vstup a výstup
- vrátenie prečítaného znaku späť do vstupného
bufferu
- rôzne možnosti otvárania súborov
- práca s binárnymi súbormi
- úlohy k lekcii
Poznámky: Ak chceš, aby ti niekto úlohy skontroloval, zabal ich do zip-u a zašli na e-mail:
libcosenior zavináč gmail botka com

Poprípade tam môžeš konzultovať, čo ti nie je jasné.
Odkazy:


0 Komentárov


Najlepšie lekcie


Najnovšie pridané lekcie


Najnovšie komentáre


Najviac komentované lekcie


Najviac zobrazené lekcie


Náhodné lekcie


Na tejto stránke bolo užívateľ(ov) za posledných 30 minút

členov, návštevníkov