Procedurálne programovanie: 3. prednáška Gabriela Kosková

Obsah opakovanie práca so súborom typová konverzia príklady

Procedurálne programovanie: Riadiace štruktúry - opakovanie v príkladoch

ak by tu nebol break - vypisovalo by to vždy aj x Príklad 1 program načíta znak. Ak je znak 'a', vypíše 'abc', ak je znak 'b', vypíše 'bc', ak je 'c', vypíše 'c', inak vypíše znak 'x' #include <stdio.h> int main() { switch(getchar()) { case 'a' : putchar('a'); case 'b' : putchar('b'); case 'c' : putchar('c'); default : putchar('x'); } return 0; kde je chyba? ak by tu nebol break - vypisovalo by to vždy aj x nemusí byť break; break;

načítavanie na adresu premennej: & Príklad 2 program načíta 2 reálne čísla a pomocou ternárneho operátora vypíše ich maximum #include <stdio.h> int main() { float x, y; printf("Zadajte 2 realne cisla: "); scanf("%f %f", x, y); printf("%.2f\n", (x > y) ? x : y); return 0; } kde je chyba? načítavanie na adresu premennej: & & &

Príklad 3 Program načíta znak. Ak je znak písmeno, vypíše Pismeno, inak vypíše Ine #include <stdio.h> int main() { char c; c = getchar(); if (c >= ‘a’ && c <= ‘z’ || c >= ‘A’ && c <= ‘Z’) printf("Pismeno\n"); else printf("Ine\n"); return 0; } (c >= ‘a’ && c <= ‘z’ || c >= ‘A’ && c <= ‘Z’) ? printf("Pismeno\n") : printf("Ine\n"); c = (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') ? printf("Pismeno\n") : printf("Ine\n"); Priradenie – nie je súčasťou ternárneho operátora! Použiť len vtedy, ak potrebujete naozaj meniť hodnotu premennej.

Príklad 4 Program spočítava reálne čísla zadávané z klávesnice, pokým nie je zadaná nula, na konci súčet vypíše #include <stdio.h> int main() { float x, suma = 0; printf("Zadajte cisla (ukoncite 0)\n"); do { scanf("%f", &x); suma += x; } while(x != 0.0); printf("Sucet je: %.3f", suma); return 0; }

Príklad 5 #include <stdio.h> int main() { int i, n; float x, min, max; scanf("%d", &n); if (n > 0) { scanf("%f", &x); min = max = x; for(i=2; i<=n; i++) { if(x > max) max = x; if(x < min) min = x; } printf("Minimum: %.2f\n", min); printf("Maximum: %.2f\n", max); return 0; Program načíta n čísel a vypíše minimum a maximum (príklad z cvičení)

#include <stdio.h> int main() { int i = 2, n, pred, aktual; scanf("%d", &n); if (n > 0) { scanf("%d", &pred); if(pred < 0 || pred > 10) { printf("Postupnost nie je spravna\n"); return 0; } for(i=2; i<=n; i++) { scanf("%d", &aktual); if(aktual < pred/2 || aktual > 2*pred) { break; pred = aktual; if (i == n+1) printf("Postupnost je spravna\n"); Program kontroluje, či postupnosť je správna (príklad z cvičení). Príklad 6

Príklad 7 program načíta celé číslo n. potom vypíše n riadkov, pričom i-ty riadok obsahuje i po sebe idúcich párnych čísel začínajúcich 2. #include <stdio.h> int main() { int i, j, n; printf("Zadajte pocet riadkov: "); scanf("%d", &n); for (i = 1; i <= n; i++) { for (j = 2; j <= ; ) printf("%d ", j); putchar('\n'); } return 0; for (j = 1; j <= i; j++) printf("%d ", 2*j); 2*i j+=2 doplňte

Príklad 8: trojuholník Program vykrelí trojuholník z hviezdičiek a medzier #include <stdio.h> int main() { int i, j, n; scanf("%d", &n); return 0; } for(i=1; i<=n; i++) { } for(j=1; j<=n; j++) if(i>=j) putchar('*'); else putchar(' '); Pre n=5: * ** *** **** ***** putchar('\n');

Príklad 9: trojuholník – pridaný for (1) #include <stdio.h> int main() { int i, j, n, k; scanf("%d", &n); for(k=1; k<=2; k++) for(i=1; i<=n; i++) { for(j=1; j<=n; j++) if(i>=j) putchar('*'); else putchar(' '); putchar('\n'); } return 0; Čo urobí pridanie for-cyklu? Pre n=5: * ** *** **** *****

Príklad 10: trojuholník – pridaný for (2) #include <stdio.h> int main() { int i, j, n, k; scanf("%d", &n); for(i=1; i<=n; i++) { for(k=1; k<=2; k++) for(j=1; j<=n; j++) if(i>=j) putchar('*'); else putchar(' '); putchar('\n'); } return 0; Čo urobí pridanie for-cyklu? Pre n=5: * * ** ** *** *** **** **** **********

Príklad 11: trojuholník – pridaný for (3) #include <stdio.h> int main() { int i, j, n, k; scanf("%d", &n); for(i=1; i<=n; i++) { for(j=1; j<=n; j++) for(k=1; k<=2; k++) if(i>=j) putchar('*'); else putchar(' '); putchar('\n'); } return 0; Čo urobí pridanie for-cyklu? Pre n=5: ** **** ****** ******** **********

Procedurálne programovanie: Vstup a výstup z textového súboru

Súbory súbor vstup zo súboru výstup koniec súboru postupnosť Bytov uložených na médiu (disku) v niekoľkých blokoch (nie nutne za sebou) prístup k blokom - operačný systém vstup zo súboru naraz sa prečíta celý blok z disku do pamäte (buffer) - položky sa potom čítajú z pamäte (rýchlejšie) výstup dáta sa zapisujú do bufferu a keď je plný, zapíše sa na disk napr. v UNIXE sa dá používať aj nebufrované vstupné a výstupné operácie (io.h) koniec súboru často špeciálny znak (napr. "Ctrl Z")

Začiatky práce so súborom základný dátový typ: FILE * ukazovateľ (pointer - *) na objekt typu FILE ukazovateľ obsahuje adresu objektu typu FILE ako adresár - zapísaná adresa, kde začína súbor na disku dodržať veľké písmená (FILE *, nie file *) definícia premennej f pre prácu so súborom: aj pre čítanie, aj pre zápis rovnaké pre viac premenných: FILE *f; pre čitateľnosť je vhodné používať fr pre čítanie, fw pre zápis FILE *fr, *fw;

Otvorenie súboru na čítanie a zápis r ako read čítanie zápis fr = fopen("POKUS.TXT", "r"); w ako write fw = fopen("POKUS.TXT", "w"); aj ďalšie režimy otvorenia súboru (nielen "r" a "w") režimy "r" a "w" - otvorenie textového súboru režimy "rb" a "wb" - otvorenie binárneho súboru  neskôr

Základné práce s otvoreným súborom funkcie štandardnej knižnice stdio.h, premenná f je typu FILE *: porovnanie s čítaním z klávesnice a zápisom na obrazovku čítanie znaku zo súboru c = getc(f); c = getchar(); zápis znaku do súboru putc(c, f); putchar(c); formátované čítanie zo súboru fscanf(f, "format", argumenty); scanf("format", argumenty); formátovaný zápis do súboru fprintf(f, "format", argumenty); printf("format", argumenty);

Ukončenie práce so súborom keď už nebudeme zo súboru čítať ani doňho zapisovať - uzatvoriť súbor, premenná f je typu FILE *: nespoliehať sa, že po skončení programu sa v mnohých systémoch automaticky uzavrie súbor počet súčasne otvorených súborov je obmedzený zápis bufferu do súboru (preto uzatvárať ihneď) - pri spadnutí programu by zostali dáta v bufferi a stratili by sa fclose(f);

Príklady program vytvorí súbor POKUS.TXT, zapíše doňho čísla od 1 po 10, každé v zvlášť riadku #include <stdio.h> int main() { FILE *fw; int i; fw = fopen("POKUS.TXT", "w"); for (i = 1; i <= 10; i++) fprintf(fw, "%d\n", i); fclose(fw); return 0; }

súbor DATA.TXT je potrebné najprv vytvoriť - v editore Príklady program načíta tri double čísla zo súboru DATA.TXT a ich súčet vypíše na obrazovku #include <stdio.h> int main() { FILE *fr; double x, y, z; fr = fopen("DATA.TXT", "r"); fscanf(fr, "%lf %lf %lf\n", &x, &y, &z); printf("%lf\n", x + y + z); fclose(fr); return 0; } funkcia fscanf() vracia počet úspešne prečítaných položiek (v prípade konca súboru vracia hodnotu EOF) súbor DATA.TXT je potrebné najprv vytvoriť - v editore

program načíta zo súboru tri double čísla zo súboru DATA program načíta zo súboru tri double čísla zo súboru DATA.TXT a vypíše ich súčet na obrazovku - testuje, či sú v súbore 3 čísla Príklady #include <stdio.h> int main() { FILE *fr; double x, y, z; fw = fopen("DATA.TXT", "r"); if(fscanf(fr, "%lf %lf %lf\n", &x, &y, &z) == 3) printf("%lf \n", x + y + z); else printf("Subor neobsahuje 3 realne cisla\n."); fclose(fr); return 0; }

program prečíta 2 znaky zo súbrou ZNAKY program prečíta 2 znaky zo súbrou ZNAKY.TXT a zapíše ich do súboru KOPIA.TXT Príklady #include <stdio.h> int main() { FILE *fr, *fw; int c; fr = fopen("ZNAKY.TXT", "r"); fw = fopen("KOPIA.TXT", "w"); c = getc(fr); putc(c, fw); putc(getc(fr), fw); fclose(fr); fclose(fw); return 0; }

Testovanie konca riadku postarať sa o testovanie konca riadku (EOLN - označenie, nie symbolická konštanta) testovanie štandardného znaku pre koniec riadku v C: \n \n - aj pre čítanie, aj pre zápis \n - význam určuje prekladač podľa systému (<CR>, <LF>, alebo <CR><LF>)

Príklad program prečíta zo súboru LIST.TXT riadok a aj s koncom riadku ho vypíše na obrazovku #include <stdio.h> int main() { FILE *fr; int c; fr = fopen("LIST.TXT", "r"); while ((c = getc(fr)) != '\n') putchar(c); putchar(c); /* vypis \n */ fclose(fr); return 0; }

Testovanie konca súboru dva spôsoby: pomocou konštanty EOF alebo pomocou makra feof() - pomalejšie (volanie makra)

Testovanie konca súboru: EOF symbolická konštanta EOF väčšinou definovaná v stdio.h väčšinou má hodnotu -1 premenná c nesmie byť definovaná ako char, pretože EOF je reprezentovaná ako int s hodnotou -1 (-1 by bola na char konvertovaná ako iný znak) if ((c = getc(fr)) != EOF) ...

program skopíruje obsah súboru ORIG.TXT do súboru KOPIA.TXT Príklad #include <stdio.h> int main() { FILE *fr, *fw; int c; fr = fopen("LIST.TXT", "r"); fw = fopen("KOPIA.TXT", "w"); while ((c = getc(fr)) != EOF) putc(c, fw); fclose(fr); fclose(fw); return 0; }

Testovanie konca súboru: feof() makro feof() vracia TRUE (nenulovú hodnotu), keď posledné čítanie bolo za koncom súboru FALSE (nulu), keď sa pri čítaní nedošlo na koniec vhodné, keď čítame z binárneho súboru môže obsahovať znak s hodnotou 0xFF - pomocou implicitnej konverzie je prevedený na hodnotu EOF - skončilo by sa s čítaním skôr  neskôr

program skopíruje obsah súboru ORIG.TXT do súboru KOPIA.TXT Príklad program skopíruje obsah súboru ORIG.TXT do súboru KOPIA.TXT #include <stdio.h> int main() { FILE *fr, *fw; int c; fr = fopen("LIST.TXT", "r"); fw = fopen("KOPIA.TXT", "w"); while (c = getc(fr), feof(fr) == 0) putc(c, fw); fclose(fr); fclose(fw); return 0; }

Testovanie správnosti otvorenia a zatvorenia súboru akcie: otvorenie a zatvorenie súboru nemusia byť úspešné preto testovať úspešnosť a podľa toho pokračovať fopen() - ak sa podarí otvoriť súbor - vracia ukazovateľ na súbor, - inak - vracia konštantu NULL (definovaná v stdio.h, má hodnotu 0) testovanie: if((fr = fopen("TEST.TXT", "r")) == NULL) printf("Subor sa nepodarilo otvorit.\n");

Testovanie správnosti otvorenia a zatvorenia súboru fclose() - ak sa nepodarí otvoriť súbor - vracia konštantu EOF testovanie: if(fclose(fr) == EOF) printf("Subor sa nepodarilo zatvorit.\n");

tu by sme mali správne zatvoriť súbor LIST.TXT program skopíruje obsah súboru ORIG.TXT do súboru KOPIA.TXT - s ošetreniami #include <stdio.h> int main() { FILE *fr, *fw; int c; if ((fr = fopen("LIST.TXT", "r")) == NULL) { printf("Subor sa nepodarilo otvorit.\n"); return 0; } if ((fw = fopen("KOPIA.TXT", "w") ) == NULL) { while ((c = getc(fr)) != EOF) putc(c, fw); if (fclose(fr) == EOF) printf("Subor sa nepodarilo zatvorit.\n"); if (fclose(fw) == EOF) tu by sme mali správne zatvoriť súbor LIST.TXT

Príklad program vypíše súbor LIST.TXT na obrazovku tak, že skonvertuje všetky malé písmená na veľké a nakoniec vypíše dĺžku najdlhšieho riadku

kontrola, či sa podarilo otvoriť súbor #include <stdio.h> int main() { FILE *fr; int c, dlzka, max_dlzka; if ((fr = fopen("LIST.txt", "r")) == NULL) { printf("Subor sa nepodarilo otvorit.\n"); return 0; } dlzka = max_dlzka = 0; while((c= getc(fr)) != EOF) { dlzka++; if (c>='a' && c<='z') c += 'A' - 'a'; putchar(c); if (c == '\n') { if (max_dlzka < dlzka) max_dlzka = dlzka; dlzka = 0; kontrola, či sa podarilo otvoriť súbor Číta znaky pokým nie je koniec súboru Napočítava dĺžku riadku Konverzia malých písmen na veľké Výpis znaku Ak je riadok doteraz najdlhší, zapamätanie si jeho dĺžky Vynulovať dĺžku pre počítanie dĺžky ďalšieho riadku

pokračovanie: Kontrola aj dĺžky posledného riadku, ktorý nemusí končiť \n if (max_dlzka < dlzka) max_dlzka = dlzka; printf("Max. dlzka: %d\n", max_dlzka); if (fclose(fr) == EOF) printf("Subor sa nepodarilo zatvorit\n"); return 0; } Výpis a zatvorenie súboru

Štandardný vstup a výstup C pracuje s klávesnicou a obrazovkou ako so súborom v stdio.h - definované dva konštantné ukazovatele: označujú štandardný vstupný/výstupný prúd (standard intput-output stream) je možné ich zmeniť pomocou presmerovania pri spúšťaní programu, napr.: FILE *stdin; FILE *stdout; nie stdio program < vstup.txt > vystup.txt

Štandardný vstup a výstup stdin a stdout môžu byť použité v programe ako argumenty operácií so súbormi: getc(stdin) getchar() je ekvivalentné putc(c, stdout) putchar(c) je ekvivalentné v stdio.h je definovaný ešte tretí prúd stderr, ktorý sa používa pri vypisovaní chybových správ

program ukáže ako využívať stdout a vyhnúť sa problémom s bufferom Príklad program ukáže ako využívať stdout a vyhnúť sa problémom s bufferom program vypíše otázku, či má byť výstup vypísaný na obrazovku, alebo do súboru VYSTPUP.TXT. Ak súbor existuje, vypíše otázku, či má byť súbor prepísaný

Vyprázdnenie buffera – preskočí zvyšok riadku #include <stdio.h> int main() { FILE *fw; int c; printf("Stlacte O pre vypis na Obrazovku\n"); printf("alebo iny znak pre zapis do suboru VYSTUP.TXT: "); c = getchar(); while (getchar() != '\n') ; Vyprázdnenie buffera – preskočí zvyšok riadku

Výpis na štandardný výstup (obrazovku) pokračovanie if (c == 'o' || c == 'O') fw = stdout; else { if ((fw = fopen("VYSTUP.TXT", "r")) != NULL) { printf("Subor VYSTUP.TXT existuje, prepisat? [A/N]: "); c = getchar(); while (getchar() != '\n') ; if (fclose(fw) == EOF) { printf("Chyba pri zatvarani suboru\n"); return 0; } if (!(c == 'a' || c == 'A')) if ((fw = fopen("VYSTUP.TXT", "w")) == NULL) { printf("Subor VYSTUP.TXT sa nepodarilo otvorit\n"); Výpis na štandardný výstup (obrazovku) Ak súbor existuje (podarilo sa ho otvoriť na čítanie), zistenie, či sa má prepísať Ak nechce prepísať súbor, program skončí Otvorenie súboru na zápis s kontrolou

Čítanie znakov a ich zápis do fw (súbor alebo štandardný výstup) pokračovanie: printf("Piste text a ukoncite ho znakom *\n"); while ((c = getchar()) != '*') putc(c, fw); if (fw != stdout) { if (fclose(fw) == EOF) { printf("Subor VYSTUP.TXT se nepodarilo zatvorit\n"); return 0; } Čítanie znakov a ich zápis do fw (súbor alebo štandardný výstup) Ak sa zapisovalo do súboru, jeho zatvorenie s kontrolou

Vrátenie prečítaného znaku späť do bufferu často zistíme, že máme prestať čítať znak až potom, čo prečítame o znak naviac  vrátiť do bufferu späť do bufferu môžeme zapísať aj iný ako práve prečítaný znak vráti znak do vstupného bufferu - ak je vrátenie úspešné, ungetc() vracia vrátený znak - ak je vrátenie neúspešné, vráti EOF ungetc(c, fr)

Príklad č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 časť programu prečíta číslo pomocou fscanf() - predtým však musí prečítať neznámy počet znakov '$' (predpokladáme otvorený súbor) int c, hodnota = 0; while ((c = getc(fr)) == '$') ; ungetc(c, stdin); fscanf(fr, "%d", &hodnota);

Rôzne možnosti otvárania súborov v textovom režime súbory sa otvárajú stále rovnakou funkciou fopen() či ide o textový alebo binárny súbor či ide o zápis alebo čítanie prototyp funkcie: - const: len vstupný argument, nebude sa meniť vo funkcii - char * - reťazec znakov FILE *fopen(const char *meno, const char *rezim) vráti ukazovateľ (adresu) na otvorený súbor alebo NULL meno súboru aký typ súboru a na akú činnosť sa bude otvárať

Významy parametru rezim (textové súbory) r textový súbor pre čítanie w textový súbor pre zápis alebo pre prepisovanie a textový súbor pre pripojenie na koniec r+ textový súbor pre čítanie a zápis w+ textový súbor pre čítanie, zápis alebo prepisovanie a+ textový súbor pre čítanie a zápis na koniec

Významy parametru rezim (textové súbory) niektoré implementácie umožňujú explicitne určiť, že ide o textový režim: "rt" "wt" "at" ak otvoríme existujúci súbor v režime "w", tak sa tento súbor najprv vymaže a potom sa vytvorí nový ak otvoríme existujúci súbor v režime "a" tak sa tento súbor otvorí a ukazovateľ sa presunie na koniec súboru (rozširovanie existujúceho súboru) ak použijeme režim rozšírený o znak +, je možné do súboru aj zapisovať

Procedurálne programovanie: Typová konverzia

Na Internete nikto nevie, že si pes :-)

Typová konverzia prevod premennej určitého typu na iný typ napr. int na float dva druhy konverzií: implicitná - samovoľná, automatická explicitná - vynútená, požadovaná

Pravidlá implicitnej typovej konverzie pred vykonaním operácie sa samostatné operandy konvertujú: kedykoľvek sa objaví typ char alebo short int, konvertuje sa na int všetky operandy unsigned char a unsigned short sa konvertujú na int - ak int nepretečie, inak na unsigned int

Pravidlá implicitnej typovej konverzie ak majú dva operandy jednej operácie rôzny typ, operand s nižšou prioritou je konvertovaný na typ s vyššou prioritou podľa hierarchie: int  unsigned int unsigned int  long long  unsigned long unsigned long  float float  double double  long double int má najnižšiu prioritu jeden operand typu float a druhý nižšiu prioritu, druhý  float

Pravidlá implicitnej typovej konverzie v priraďovacích príkazoch je typ na pravej strane konvertovaný na typ z ľavej strany napr.: double x; x = 5; x bude mať hodnotu 5.0 int i; i = 5.0; i bude mať hodnotu 5

Príklady 1 je konvertované na char, c obsahuje znak "ctrl A" char c; c = c + '1'; c obsahuje znak "ctrl B" ordinálne číslo znaku '1' je 49, teda c obsahuje znak s ordinálnym číslom 51, teda znak '3'

Príklady i obsahuje ordinálne číslo znaku 'A', teda 65 int i; i = 'A'; c obsahuje znak číslo 67 (ordinálne číslo znaku 'C' i bude mať hodnotu 3 (0.8 sa odreže)

Príklady double g; g obsahuje číslo 5.0 int i; char c; g = 5; i = g * c; g obsahuje číslo 5.0 najprv sa c skonvertuje na int, potom sa c skonvertuje na double, výsledok g * c je double, ale podľa pravidla 3 sa skonvertuje na int a priradí i

Explicitná typová konverzia pretypovanie jazyk C dovoľuje takmer ľubovoľnú konverziu  riziko, že to bude nevhodné syntax: (typ) vyraz príklady: (int) char_vyraz - prevod znaku na ordinálne číslo (char) int_vyraz - prevod ordinálneho čísla na znak (int) double_vyraz - odrezanie desatinnej časti (double) int_vyraz - prevod celého čísla na reálne (double) float_vyraz - zväčšenie presnosti

Explicitná typová konverzia najčastenšie na pretypovanie ukazovateľov príklad použitia : #include <math.h> ... int i = 10; double f; f = sqrt((double) i); sqrt() vráti druhú odmocninu nie je to nutné, ale čitatelné (nutné to bolo v prvých verziách jazyka C)

Procedurálne programovanie: Príklady

Príklad 1: práca so súborom program načítava reálne čísla zo súboru CISLA.TXT, vypisuje ich na obrazovku a nakoniec vypíše ich priemer

Otvorenie súboru s kontrolou #include <stdio.h> int main() { double x, suma; int i; FILE *fr; if ((fr = fopen("CISLA.TXT", "r")) == NULL) { printf("Subor CISLA .TXT, sa nepodarilo otvorit.\n"); return 0; } suma = 0.0; i = 0; while (feof(fr) == 0) { fscanf(fr, "%lf", &x); printf("%.3lf\n", x); suma += x; i++; Otvorenie súboru s kontrolou V cykle spočítavanie načítaných čísel (suma) a počítanie ich počtu (i)

Zatvorenie súboru s kontrolou pokračovanie: if(fclose(fr) == EOF) { printf("Subor CISLA.TXT sa nepodarilo zatvorit.\n"); return 0; } printf("Priemer cisel je: %.3lf\n", suma / i); Zatvorenie súboru s kontrolou Výpis priemeru

Príklad 2: práca so súborom program číta text zo súboru PISMENA.TXT a po konci riadku na obrazovku vypíše jeho dĺžku

Otvorenie súboru s kontrolou #include <stdio.h> int main() { int c, i, dlzka; FILE *fr; if ((fr = fopen("PISMENA.TXT", "r")) == NULL) { printf("Subor PISMENA.TXT sa nepodarilo otvorit.\n"); return 0; } dlzka = 0; i = 1; while ((c = getc(fr)) != EOF) { if (c == '\n') { printf("dlzka riadka %d: %d\n", i, dlzka); i++; else dlzka++; Otvorenie súboru s kontrolou vynulovanie dĺžky aktuálneho riadku (dlzka), počet riadkov – nastavenie na 1 (i) Čítanie po znakoch – pokým nie je koniec súboru Na konci riadku: vypíše jeho dĺžku, zvýši počet riadkov (i) a nastaví dĺžku ďalšieho riadku na 0 (dlzka). Vo vnútri riadku: započítanie prečítaného znaku

Zatvorenie súboru s kontrolou pokračovanie: if(fclose(fr) == EOF) printf("Subor PISMENA.TXT sa nepodarilo zatvorit.\n"); return 0; } Zatvorenie súboru s kontrolou

Príklad 4: typová konverzia program načíta tri celé čísla a vypíše ich priemer na dve desatinné čísla #include <stdio.h> int main() { int x, y, z; printf("Zadajte 3 cele cisla: "); scanf("%d %d %d", &x, &y, &z); printf("Priemer: %.2f\n", (float) (x+y+z) / 3); return 0; } (x+y+z) / 3.0);

Sú lepšie spôsoby ako sa odhlásiť...