Felhasználói eszközök
oktatas:programozas:c:c_nyelv
Különbségek
A kiválasztott változat és az aktuális verzió közötti különbségek a következők.
| Előző változat mindkét oldalon Előző változat Következő változat | Előző változat Következő változat Következő változat mindkét oldalon | ||
|
oktatas:programozas:c:c_nyelv [2020/04/14 19:28] admin [Nevesített állandó] |
oktatas:programozas:c:c_nyelv [2020/05/19 15:00] admin [Összefűzés] |
||
|---|---|---|---|
| Sor 31: | Sor 31: | ||
| ehhez még plusz kiterjesztéseket tesznek hozzá. | ehhez még plusz kiterjesztéseket tesznek hozzá. | ||
| + | ===== Gyakorlat 001 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Ki kezdte fejleszteni a C nyelvet? | ||
| + | * Milyen operációs rendszerre tervezték a C nyelvet eredetileg? | ||
| + | * Milyen programozási nyelvből örökölt tulajdonságokat a C nyelv? | ||
| + | * Mikor fogadták el a C nyelvet ANSI szabványnak? | ||
| ===== Helló Világ ===== | ===== Helló Világ ===== | ||
| Sor 51: | Sor 58: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | A programban szereplő printf() utasítás a stdio.h programozói könyvtárban található. | + | A programban szereplő printf() utasítás a stdio.h fejállományban vagy programozói könyvtárban található. |
| Ha használni akarjuk a printf() függvényt, mindig szükség van a #include <stdio.h> sorra. | Ha használni akarjuk a printf() függvényt, mindig szükség van a #include <stdio.h> sorra. | ||
| Sor 71: | Sor 78: | ||
| {{:oktatas:programozas:c:c_fuggveny_reszei.png?400|}} | {{:oktatas:programozas:c:c_fuggveny_reszei.png?400|}} | ||
| + | ===== Megjegyzés ===== | ||
| + | |||
| + | A C nyelv lehetővé teszi egy és többsoros megjegyzés elhelyezését. | ||
| + | |||
| + | |||
| + | <code c> | ||
| + | // egy soros megjegyzés | ||
| + | </code> | ||
| + | |||
| + | |||
| + | <code c> | ||
| + | /* több | ||
| + | soros | ||
| + | megjegyzés | ||
| + | */ | ||
| + | </code> | ||
| + | |||
| + | ===== Gyakorlat 002 ===== | ||
| + | |||
| + | * Írjon programot, ami kiírja a településének a nevét, és irányító számot egy újabb sorba. | ||
| + | * Az előző programban, írja többsoros megjegyzésbe saját nevét. | ||
| ===== Kivitel ===== | ===== Kivitel ===== | ||
| Sor 138: | Sor 166: | ||
| | \n | Sortörés | | | \n | Sortörés | | ||
| | \t | Tabulátor | | | \t | Tabulátor | | ||
| - | | <nowiki>\"</nowiki> | Idézőjel | | + | | <nowiki>\"</nowiki> | Idézőjel | |
| + | | \% | Százalékjel | | ||
| + | |||
| + | ===== Gyakorlat 003 ===== | ||
| + | |||
| + | * Írjon programot, ami "Kék János" nevet. | ||
| + | * A következő sorba, tabulátorral tagolva a fizetését írja ki, ami 2856000. | ||
| + | * A program írja ki a saját (szerző) nevét is, a "szerző: " szöveg után. | ||
| Sor 221: | Sor 256: | ||
| </code> | </code> | ||
| + | |||
| + | ===== Valós típus ===== | ||
| + | |||
| + | Legnagyobb tárolható double típus: | ||
| + | <code c valos.c> | ||
| + | #include <stdio.h> | ||
| + | #include <float.h> | ||
| + | int main() { | ||
| + | printf("double: %g\n", DBL_MAX); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | <code c> | ||
| + | printf("float : %g\n", FLT_MAX); | ||
| + | </code> | ||
| + | |||
| + | |||
| + | | FLT_MAX | | ||
| + | | DBL_MAX | | ||
| + | ===== Gyakorlat 004 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Mi a legnagyobb tárolható szám, ha short típust adok meg? | ||
| + | * Mi a legnagyobb tárolható szám, ha char típust adok meg? | ||
| + | * Mi annak az állandónak a neve, amiből kideríthető, mi legnagyobb tárolható int típus? | ||
| + | |||
| Sor 310: | Sor 372: | ||
| <code c konst.c> | <code c konst.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | + | int main() { | |
| - | main() | + | |
| - | { | + | |
| const int a = 5; | const int a = 5; | ||
| printf("%d\n", a); | printf("%d\n", a); | ||
| Sor 324: | Sor 384: | ||
| #define MERET 3 | #define MERET 3 | ||
| typedef double Ttomb[MERET]; | typedef double Ttomb[MERET]; | ||
| - | main() | + | int main() { |
| - | { | + | |
| Ttomb tomb = {3.7, 5.2, 2.8}; | Ttomb tomb = {3.7, 5.2, 2.8}; | ||
| printf("%f\n", tomb[0]); | printf("%f\n", tomb[0]); | ||
| Sor 340: | Sor 399: | ||
| {{:oktatas:programozas:c:szoveges_allando.png?400|}} | {{:oktatas:programozas:c:szoveges_allando.png?400|}} | ||
| + | |||
| + | A const módosító mondja meg, hogy nevesített állandót szeretnénk, | ||
| + | létrehozni. Amikor a programozó állandót hoz létre, azt vállalja, | ||
| + | hogy ezt a memória területet a program tovább része alatt nem | ||
| + | szeretné megváltoztatni. | ||
| + | |||
| + | ===== Gyakorlat 005 ===== | ||
| + | |||
| + | * Írjon programot, amely két állandót tartalmaz: | ||
| + | * a programban használja a #define utasítást | ||
| + | * az egyik szám, egy iskolában adható legkisebb osztályzatot tartalmazza | ||
| + | * a másik szám, az iskolában adható legnagyobb osztályzatot tartalmazza | ||
| + | * az állandók neveit válassza meg tetszőlegesen | ||
| + | |||
| ===== Deklarációk ===== | ===== Deklarációk ===== | ||
| Sor 377: | Sor 450: | ||
| int strlen(const char[ ]); | int strlen(const char[ ]); | ||
| </code> | </code> | ||
| - | ===== Ellenőrző kérdések ===== | + | ===== Gyakorlat 006 ===== |
| - | * Milyen nyelvet tanulunk most? | + | * Válaszoljon a következő kérdésekre: |
| - | * Ki találta ki ezt a nyelvet amit tanulunk? | + | * Milyen nyelvet tanulunk most? |
| - | * Mikor let a nyelv kifejlesztve? | + | * Ki találta ki ezt a nyelvet amit tanulunk? |
| - | * Mire használjuk? | + | * Mikor let a nyelv kifejlesztve? |
| - | * Van-e szabványosított verziója? | + | * Mire használjuk? |
| - | * Mi az az előfordítás? | + | * Van-e szabványosított verziója? |
| - | * Mivel kezdjük az előfordítói utasításokat? | + | * Mi az az előfordítás? |
| - | * Mi az a konstans? | + | * Mivel kezdjük az előfordítói utasításokat? |
| - | * Hogyan hozunk létre C nyelvben konstanst? | + | * Mi az a konstans? |
| - | * Milyen az írásmódja a változóknak és a konstansoknak? | + | * Hogyan hozunk létre C nyelvben konstanst? |
| - | * A C nyelv kis és nagybetű érzékeny? | + | * Milyen az írásmódja a változóknak és a konstansoknak? |
| - | * A C nyelv kiírató utasítása? | + | * A C nyelv kis és nagybetű érzékeny? |
| - | * Hol nem szükséges a C nyelvben az utasítás végére (;) pontosvessző? | + | * A C nyelv kiírató utasítása? |
| + | * Hol nem szükséges a C nyelvben az utasítás végére (;) pontosvessző? | ||
| Sor 452: | Sor 526: | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | + | int main() { | |
| - | main() | + | |
| - | { | + | |
| int a = 3; | int a = 3; | ||
| int b = 5; | int b = 5; | ||
| Sor 563: | Sor 635: | ||
| A zárójel mindig módosítja a kiértékelés sorrendjét. | A zárójel mindig módosítja a kiértékelés sorrendjét. | ||
| - | ===== Formátumozott kivitel ===== | + | ===== Gyakorlat 007 ===== |
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Mire való a % operátor? | ||
| + | * Mire való a && operátor? | ||
| + | * Mire való a || operátor? | ||
| + | * Mire való a ++ operátor? | ||
| + | |||
| + | |||
| + | |||
| + | ===== Formázott kivitel ===== | ||
| A printf() függvény formátumozott kivitelt tesz lehetővé számunkra. | A printf() függvény formátumozott kivitelt tesz lehetővé számunkra. | ||
| Sor 580: | Sor 662: | ||
| * egész karakterek esetén a kiírt számjegyek maximális számát | * egész karakterek esetén a kiírt számjegyek maximális számát | ||
| * egy h betű, ha egy egész számot short típusként vagy egy l betű, ha long típusként írun ki | * egy h betű, ha egy egész számot short típusként vagy egy l betű, ha long típusként írun ki | ||
| + | |||
| + | |||
| + | A leggyakrabban használt konverziós karakterek, a d, f, c és s. | ||
| + | |||
| + | |||
| + | A d konverziós karaktert egész számok kiíratására használjuk. | ||
| + | |||
| + | {{:oktatas:programozas:c:egsz_szam_formazasa.png?200|}} | ||
| + | |||
| + | Az f konverziós karaktert valós számok kiíratására használjuk. | ||
| + | |||
| + | {{:oktatas:programozas:c:valos_szam_formazasa.png?200|}} | ||
| + | |||
| + | A c konverziós karaktert, karakterek kiíratására használjuk. | ||
| + | |||
| + | {{:oktatas:programozas:c:karakter_formazasa.png?200|}} | ||
| + | |||
| + | Az s konverziós karaktert, karaktersorozatok, vagyis szövegek kiíratására használjuk. | ||
| + | |||
| + | {{:oktatas:programozas:c:szoveg_formazasa.png?200|}} | ||
| + | |||
| + | |||
| + | |||
| Sor 585: | Sor 690: | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| double a = 31.123456; | double a = 31.123456; | ||
| printf("%.2f\n", a); | printf("%.2f\n", a); | ||
| - | |||
| } | } | ||
| Sor 597: | Sor 700: | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| double a = 31.123456; | double a = 31.123456; | ||
| printf("%20.2f\n", a); | printf("%20.2f\n", a); | ||
| Sor 609: | Sor 711: | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| double a = 31.123456; | double a = 31.123456; | ||
| printf("|%-20.2f|\n", a); | printf("|%-20.2f|\n", a); | ||
| - | |||
| } | } | ||
| Sor 621: | Sor 721: | ||
| - | ^ formátum karakter ^ típus ^ | + | ^ formátum karakter ^ típus ^ Használatra példa ^ |
| | ld | long | | | ld | long | | ||
| | d | int, short, char | | | d | int, short, char | | ||
| Sor 627: | Sor 727: | ||
| | c | char, int | | | c | char, int | | ||
| | Lg | long double | | | Lg | long double | | ||
| + | | <nowiki>%</nowiki> | százalék jelet ír a képernyőre | <nowiki>printf("%%\n");</nowiki> | | ||
| + | |||
| + | ===== Gyakorlat 008 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Milyen formátum karakter szükséges egy egész érték kiíratásához? | ||
| + | * Milyen formátum karakter szükséges egy valós érték kiíratásához? | ||
| + | * Milyen formátum karakter szükséges egy karakter kiíratásához? | ||
| + | * Milyen formátum karakter szükséges egy karaktersorozat kiíratásához? | ||
| + | |||
| ===== Matematikai függvények ===== | ===== Matematikai függvények ===== | ||
| Sor 643: | Sor 753: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <math.h> | #include <math.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| printf("%f\n", M_PI); | printf("%f\n", M_PI); | ||
| } | } | ||
| Sor 650: | Sor 759: | ||
| ==== Szinusz ==== | ==== Szinusz ==== | ||
| + | |||
| + | A trigonometriai függvények szög helyett radiánban várják az értéküket. | ||
| + | A feladatokban általában szögben adják meg az értékeket, amit át kell számolnunk | ||
| + | radiánban. | ||
| + | |||
| + | |||
| + | Ha például van 30 fokunk, akkor meg kell szorozni PI értékével, | ||
| + | majd az eredményt el kell osztani 180-nal. | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <math.h> | #include <math.h> | ||
| - | main() | + | |
| - | { | + | int main() { |
| - | printf("%f\n", sin(1 * M_PI / 180)); | + | printf("%f\n", sin(30 * M_PI / 180)); |
| } | } | ||
| + | </code> | ||
| + | Készítsük el példaprogramot, majd fordítsuk és futtassuk. | ||
| + | |||
| + | A matematikai függvények használata esetén szükség van egy új kapcsolóra, a -l. | ||
| + | A -l értéke egy "m" betű, utalva a math-ra. Egy matematikai függvény használata esetén, | ||
| + | tehát így fordítunk egy C forráskódot: | ||
| + | |||
| + | <code bash> | ||
| + | cc -l m -o main main.c | ||
| </code> | </code> | ||
| Sor 680: | Sor 806: | ||
| double sqrt (double); | double sqrt (double); | ||
| double ceil (double); // Felfele kerekít | double ceil (double); // Felfele kerekít | ||
| - | double floor (double); // Felfele kerekít | + | double floor (double); // Lelfele kerekít |
| double fabs (double); // Abszolút érték | double fabs (double); // Abszolút érték | ||
| double ldexp (double, int); | double ldexp (double, int); | ||
| Sor 686: | Sor 812: | ||
| double modf (double, double*); | double modf (double, double*); | ||
| double fmod (double, double); | double fmod (double, double); | ||
| - | |||
| - | int abs(int) //Abszolút érték | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <math.h> | #include <math.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| printf("%f\n", sqrt(9.5)); | printf("%f\n", sqrt(9.5)); | ||
| } | } | ||
| Sor 702: | Sor 825: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <math.h> | #include <math.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| printf("%f\n", pow(2,8)); | printf("%f\n", pow(2,8)); | ||
| } | } | ||
| </code> | </code> | ||
| - | ===== Ellenőrző kérdések 2 ===== | ||
| - | * Mi az az math.h? | + | ==== Az abszolút érték egész számokkal ==== |
| - | * A maradék képzést milyen operátorral valósítjuk meg? | + | |
| - | * Mondjon két egy operandusú operátort. | + | Érdekesség, hogy az abs() függvény másik programozói könyvtárban van, a stdlib.h könyvtárban. |
| - | * Mondjon négy bitenkénti operátort. | + | |
| - | * Milyen utasítással írathatunk ki formázott kivitelt. | + | Szintaxis: |
| - | * Formázott kivitel esetén, valós számot milyen formátumkarakterrel tudunk kiíratni? | + | <code> |
| + | int abs(int) //Abszolút érték | ||
| + | </code> | ||
| + | |||
| + | Használata, például: | ||
| + | <code c main.c> | ||
| + | #include <stdlib.h> | ||
| + | |||
| + | int main() { | ||
| + | int szam = -4; | ||
| + | int ered = abs(szam); | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | |||
| + | Ha fordításnál kihagyjuk az stdlib.h programozói könyvtárat, | ||
| + | akkor figyelmeztetést kapunk: | ||
| + | <code> | ||
| + | warning: implicit declaration of function 'abs' [-Wimplicit-function-declaration] | ||
| + | int ered = abs(szam); | ||
| + | </code> | ||
| + | |||
| + | |||
| + | |||
| + | Az újabb GCC 5-s verzióban az alapértelmezetten C szabvány a C11. | ||
| + | Ez megköveteli, hogy szerepeltessük az #include fordítási direktívával, | ||
| + | a stdlib.h könyvtárat. | ||
| + | |||
| + | |||
| + | A fordító rávehető, hogy C89/C90 szabványt használjon, ami nem találja | ||
| + | hibának, ha nem fordítjuk az stdlib.h könyvtárat hozzá. | ||
| + | |||
| + | cc -std=gnu89 -o main main.c | ||
| + | |||
| + | Az alapértelmezett C11 szabványt nem kell megadni, de megadható: | ||
| + | cc -std=gnu11 -o main main.c | ||
| + | |||
| + | |||
| + | ==== Egész osztás ==== | ||
| + | |||
| + | Az stdlib.h fejállományban van egy div() függvény, amellyel egész osztást | ||
| + | végezhetünk. A div() függvény egy div_t struktúrát ad vissza. | ||
| + | |||
| + | <code c oszt.c> | ||
| + | #include <stdio.h> | ||
| + | #include <stdlib.h> | ||
| + | |||
| + | int main() { | ||
| + | div_t a = div(5, 2); | ||
| + | printf("%d\n", a); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | A struktúra így néz ki: | ||
| + | <code c> | ||
| + | typedef struct | ||
| + | { | ||
| + | int quot; | ||
| + | int rem; | ||
| + | } div_t; | ||
| + | </code> | ||
| + | |||
| + | |||
| + | Mivel az eredményt struktúrában kapjuk, kiírathatjuk külön az | ||
| + | osztás eredményét, és a maradékot is: | ||
| + | |||
| + | <code c oszt.c> | ||
| + | #include <stdio.h> | ||
| + | #include <stdlib.h> | ||
| + | |||
| + | int main() { | ||
| + | div_t a = div(5, 2); | ||
| + | printf("%d\n", a.quot); | ||
| + | printf("%d\n", a.rem); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | |||
| + | |||
| + | ===== Gyakorlat 009 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Mi a math.h? | ||
| + | * A maradék képzést milyen operátorral valósítjuk meg? | ||
| + | * Mondjon két egy operandusú operátort. | ||
| + | * Mondjon négy bitenkénti operátort. | ||
| + | * Milyen utasítással írathatunk ki formázott kivitelt. | ||
| + | * Formázott kivitel esetén, valós számot milyen formátumkarakterrel tudunk kiíratni? | ||
| ===== Véletlen szám ===== | ===== Véletlen szám ===== | ||
| Sor 721: | Sor 931: | ||
| ==== Függvények ==== | ==== Függvények ==== | ||
| + | Egy számítógépen nem könnyű valódi véletlen számot generálni, mivel | ||
| + | minden folyamat jól meghatározott algoritmusok mentén fut. | ||
| + | A C nyelvben az stdlib.h fejállományban (programozói könyvtár), | ||
| + | van definiálva két függvény, ami véletlen szám generálást, segíti. | ||
| - | Az stdlib.h fájlban találhatók a következő függvények. | + | A következő táblázatban ezeket látjuk: |
| - | int rand(void) | + | |
| - | void srand(unsigned int) | + | | int rand(void) | Véletlen szám generálás | |
| + | | void srand(unsigned int) | A véletlen szám generálás előkészítése | | ||
| A két függvény az ANSI szabvány része. | A két függvény az ANSI szabvány része. | ||
| + | |||
| + | A rand() függvény 0 és egy nagy egész szám között generál véletlen számot. | ||
| + | A nagy egész szám a stdlib.h fejállományban van definiálva, neve **RAND_MAX**, ami | ||
| + | egy állandó. Ez tartalmazza a legnagyobb generálható egész számot. | ||
| + | 64 bites Debian GNU/Linux 10 verzióban ez: **2147483367**. | ||
| + | |||
| + | Általában nem ilyen számra van szükség van szükség, helyette valamilyen | ||
| + | adott tartományban van véletlen számra szükségünk. | ||
| + | |||
| + | Ezért a kapott véletlen számon, elvégzünk egy egész osztást, és | ||
| + | annak maradékát vesszük figyelembe. Ha például 0 és 3 közötti | ||
| + | számra van szükségünk (ebbe bele értve a 0 és a 3-t is, akkor, | ||
| + | 4-gyel osztunk. A kapott maradék 0, 1, 2 vagy 3 lesz. | ||
| + | Ez lesz a véletlen számunk. | ||
| + | |||
| + | Ha 1, 2, 3 és 4-s számok közül szeretnénk véletlenszerűen számokat | ||
| + | kapni, akkor az előző eredményhez adjunk hozzá 1-t. A véletlen szám | ||
| + | generálása, ekkor így néz ki: | ||
| + | <code c> | ||
| + | int vel = rand() % 4 + 1; | ||
| + | </code> | ||
| + | |||
| + | Az srand() függvényre azért van szükségünk, mert nélküle mindig | ||
| + | ugyanazt a véletlen számot kapjuk. Paraméterként egy time() | ||
| + | függvény szokás futtatni NULL paraméterrel: | ||
| + | <code c> | ||
| + | srand(time(NULL)); | ||
| + | int vel1 = rand() % 4 + 1; | ||
| + | int vel2 = rand() % 4 + 1; | ||
| + | </code> | ||
| + | |||
| + | A time() függény a time.h fejállományban található. | ||
| + | |||
| + | ==== Maximum kiíratása ==== | ||
| + | Írjunk egy programot, ami kiírja a legnagyobb generálható egész számot. | ||
| + | |||
| + | <code c maxrand.c> | ||
| + | #include <stdio.h> | ||
| + | #include <stdlib.h> | ||
| + | |||
| + | int main() { | ||
| + | printf("%d\n", RAND_MAX); | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | Fordítás és futtatás: | ||
| + | <code bash> | ||
| + | cc -o maxrand maxrand.c | ||
| + | ./maxrand | ||
| + | </code> | ||
| + | |||
| ==== Példa 1 ==== | ==== Példa 1 ==== | ||
| Sor 736: | Sor 1002: | ||
| #include <time.h> | #include <time.h> | ||
| - | int main() | + | int main() { |
| - | { | + | |
| printf("Véletlen\n"); | printf("Véletlen\n"); | ||
| srand(time(NULL)); | srand(time(NULL)); | ||
| Sor 756: | Sor 1021: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| #include <time.h> | #include <time.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| srand(time(NULL)); | srand(time(NULL)); | ||
| Sor 779: | Sor 1043: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | int sajatVeletlen(int n) { | + | int veletlen(int n) { |
| unsigned int vel; | unsigned int vel; | ||
| FILE *f; | FILE *f; | ||
| Sor 791: | Sor 1055: | ||
| int main() { | int main() { | ||
| - | printf("%d\n", sajatVeletlen(6)); | + | printf("%d\n", veletlen(6)); |
| } | } | ||
| </code> | </code> | ||
| + | |||
| + | ===== Gyakorlat 010 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Milyen fejállományban van a rand() függvény? | ||
| + | * Milyen fejállományban található a time() függvény? | ||
| + | * Milyen fejállományban található a RAND_MAX állandó? | ||
| + | * Milyen fejállományban található a srand() függvény? | ||
| + | * Írjon programot, amely kockadobást szimulál. | ||
| + | * Mentés: kocka.c | ||
| + | * Írjon programot, amely pókerhez 5 kockadobást szimulál. | ||
| + | * Mentés: poker.c | ||
| + | |||
| + | |||
| + | |||
| ===== Konverzió ===== | ===== Konverzió ===== | ||
| + | ==== Típusátalakítások ==== | ||
| - | ==== Konvertáláshoz használt függvények ==== | + | Egy int típusú változó értéke gond nélkül áttehető egy short típusú változóba, amíg az elfér a |
| + | a short típusban. | ||
| + | <code c> | ||
| + | int a = 35; | ||
| + | short b = a; | ||
| + | </code> | ||
| + | |||
| + | A short típusban a legnagyobb tárolható szám: 32767. Mi történik, akkor, ha | ||
| + | 32768 számot tesszük "a" változóba, ami int típusú? | ||
| + | |||
| + | <code c> | ||
| + | int a = 32768; | ||
| + | short b = a; | ||
| + | </code> | ||
| + | |||
| + | Az eredeti szám ilyenkor nem marad meg, értékvesztés történik. | ||
| + | |||
| + | Ha valós típusú változó értékét tesszük egész típusú változóba, | ||
| + | akkor a törtrészek elvesznek, de a típusátalakítás működik: | ||
| + | |||
| + | <code c> | ||
| + | double a = 35.123; | ||
| + | int b = a; | ||
| + | </code> | ||
| + | |||
| + | ==== Karaktersorozatok és számok közötti konverziók ==== | ||
| + | |||
| + | A függvények az stdlib.h programozói könyvtárban találhatók. | ||
| <code c> | <code c> | ||
| Sor 809: | Sor 1116: | ||
| ==== String egész számmá ==== | ==== String egész számmá ==== | ||
| + | |||
| + | A következő példában egy s változót hozunk létre, | ||
| + | amelyben 2 karakter szeretnénk tárolni. | ||
| + | A C nyelvben nincs karaktersorozat (string) számára típus. | ||
| + | Ezért egy karakter tömböt fogunk használni. A char s[3], | ||
| + | egy tömb amiben karaktereket tárolhatunk, összesen 3 darabot. | ||
| + | |||
| + | Mi csak két karakter szeretnénk tárolni "15", de a | ||
| + | karaktersorozatot lezáró \0 érték számára is helyet | ||
| + | kell foglalni, ezért 3 byte számára foglalunk helyet. | ||
| + | |||
| + | |||
| + | <code c> | ||
| + | char s[3]; | ||
| + | strcpy(s, "15"); | ||
| + | int a = atoi(s); | ||
| + | </code> | ||
| + | |||
| + | Az **atoi()** függvény a **stdlib.h** programozói könyvtárból érhető el. | ||
| + | Az **strcpy()** függvény a **string.h** programozói könyvtárból érhető el. | ||
| + | |||
| + | A helyfoglalást, néha a malloc() függvénnyel szokták megoldani, | ||
| + | amelynek a használata kicsit összetettebb, de az eredmény egyenértékű | ||
| + | a fenti megoldással: | ||
| <code c> | <code c> | ||
| Sor 816: | Sor 1147: | ||
| </code> | </code> | ||
| - | Az atoi() függvény a stdlib.h fejállományból érhető el. | + | A (char*) típusátalakítás jelent. A malloc() a típusfoglalást után |
| + | void típust ad vissza, de nekünk char* típusra van szükség. | ||
| + | |||
| + | Ha azt írom char s; akkor egyetlen karakter akarok tárlni az s változóban. | ||
| + | Ha azt írom char *s; akkor egy karaktersorozatra (string) mutató értéket | ||
| + | szeretnék tárolni s-ben. | ||
| ==== String hosszú egész számmá ==== | ==== String hosszú egész számmá ==== | ||
| Sor 874: | Sor 1211: | ||
| char ch = s[0]; | char ch = s[0]; | ||
| </code> | </code> | ||
| + | ===== Gyakorlat 011 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Milyen függvénnyel lehet átkonvertálni egy karaktersorozatot (string), egész számmá? | ||
| + | |||
| ===== Bevitel ===== | ===== Bevitel ===== | ||
| Sor 879: | Sor 1221: | ||
| ==== Szám bekérése ==== | ==== Szám bekérése ==== | ||
| + | Bekéréshez használhatjuk a scanf() függvényt, ami a stdio.h fejállományban van leírva. | ||
| + | A scanf() a printf() függvényhez hasonlóan használható. | ||
| - | <code c Program01.c> | + | ^ Formátumkarakterek ^^ |
| + | ^ Karakter ^ mikor használható ^ | ||
| + | | %d | egész szám bekérése | | ||
| + | | %f | valós szám bekérése | | ||
| + | | %lf | valós szám bekérése double típusú változóba | | ||
| + | | %c | karakter bekérése | | ||
| + | | %s | egy szó bekérése | | ||
| + | |||
| + | |||
| + | A scanf() függvénynek minimum két paramétere van. Az első a formátumstring, utána pedig | ||
| + | annyi változó, amennyi a formátumstringben megadtunk, vesszővel tagolva. | ||
| + | A formtáumstringbe egy változó leírását a "%" karakterrel kezdjük, és egy vagy két | ||
| + | formátumkarakterrel fejezzük be. Egy egész szám bekérése például: | ||
| + | scanf("%d", &a); | ||
| + | |||
| + | |||
| + | |||
| + | <code c prog.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int a; | int a; | ||
| printf("Szam: "); | printf("Szam: "); | ||
| Sor 893: | Sor 1253: | ||
| </code> | </code> | ||
| - | ==== Szöveg bekérése ==== | + | Ebben a példában egyetlen egész számot kérünk be az "a" változóba. |
| + | Vegyük észre az "a" változó előtt a "&" karaktert. Erre azért van szükség, mert | ||
| + | a második paraméter nem a változó neve, hanem annak címe kell legyen. | ||
| - | Az fgets állományok olvasására való, azonban az stdio.h fejlécállományban | + | Ebből következik, hogy egy változó címét úgy kapjuk meg, hogy "&valtozonev" formát |
| - | deklarálva van egy stdin nevű fájl, amely billentyűzetet szimbolizálja. | + | használom. |
| - | Így egy valódi állomány helyett a billentyűzetet is olvashatjuk. | + | |
| - | <code c Prgram01.c> | + | |
| + | Több változó is bekérhető egyszerre. | ||
| + | A következő példában egyszerre két változót kérünk be. | ||
| + | <code c prog.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | int szam1, szam2; |
| - | char nev[100]; | + | printf("Két szám: "); |
| - | + | scanf("%d %d", &szam1, &szam2); | |
| - | printf("Név: "); | + | printf("Ezeket írtad: %d %d\n", szam1, szam2); |
| - | fgets(nev, 100, stdin); | + | |
| - | printf("Ezt írtad: %s\n", nev); | + | |
| } | } | ||
| + | |||
| </code> | </code> | ||
| + | A program végrehajtásakor, ilyenkor az első szám után 1 vagy több szóközt, | ||
| + | tabulátor vagy sortörést (whitespace karakterek) írok. az első bekért szám | ||
| + | után egy Enter is írható, így a második számot a következő sorba írom be. | ||
| - | Az fgets() függvény csak adott számú karaktert kér be, amit a második | + | ==== Valós szám bekérése ==== |
| - | paraméterben adhatunk meg. Az fgets() függvény beolvassa az Enter billentyűt is. | + | Ha egy float típusú változóba kérünk be számot, a formátumkarakter "f" karakter: |
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| - | Ha szeretnénk sortörés elhagyni, akkor a | + | int main() { |
| - | következő egyszerű példa erre mutat egy lehetőséget. | + | float szam1; |
| - | A karaktersorozat első elemének címét az „s” | + | printf("Valós szám: "); |
| - | mutató tartalmazza: | + | scanf("%f", &szam1); |
| + | printf("Ezt írtad: %f\n", szam1); | ||
| + | } | ||
| - | <code c> | ||
| - | if (s[strlen(s)-1]=='\n') s[strlen(s)-1] = '\0'; | ||
| </code> | </code> | ||
| - | A fenti utasítás csak akkor tünteti el az utolsó | + | Dupla pontos szám bekérésénél a formátumkarakterből kettő kell: "lf". |
| - | karaktert, ha az valóban egy sortörés. Működése: | + | |
| - | megnézzük , hogy az utolsó karakter sortörése. | + | |
| - | Ha igen, akkor lecseréljük karakter sorozat végét | + | |
| - | jelölő null karakterre. | + | |
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| - | <code c Program01.c> | + | int main() { |
| + | double szam1; | ||
| + | printf("Valós szám: "); | ||
| + | scanf("%lf", &szam1); | ||
| + | printf("Ezt írtad: %f\n", szam1); | ||
| + | |||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | ==== Karakter bekérése ==== | ||
| + | |||
| + | Egy karakter bekérése esetén a formátumkarakter egy "c" betű. | ||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | |||
| + | int main() { | ||
| + | char ch; | ||
| + | printf("Karakter: "); | ||
| + | scanf("%c", &ch); | ||
| + | printf("Ezt írtad: %c\n", ch); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | ==== Szó bekérése ==== | ||
| + | |||
| + | A scanf() függvény alkalmas karaktersorozat beolvasására. | ||
| + | A scanf() azonban a whitespace karaktereket szeparátornak | ||
| + | tekinti, ezért csak szavakat képes beolvasni. | ||
| + | |||
| + | |||
| + | Az alábbi program képes beolvasni egy nevet, amiben nincs szóköz vagy | ||
| + | tabulátor. | ||
| + | |||
| + | <code c prog.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *nev; | char *nev; | ||
| nev = (char*) malloc(100 * sizeof(char)); | nev = (char*) malloc(100 * sizeof(char)); | ||
| + | printf("Név: "); | ||
| + | scanf("%s", nev); | ||
| + | printf("Ezt írtad: %s\n", nev); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | Vegyük észre, hogy a scanf() függvény, második paraméterében, a nev változó neve elé | ||
| + | nem tettünk "&" karaktert, pedig azt írtuk, hogy oda cím kell. Azért nem szükséges, | ||
| + | mert a nev változót eleve mutató típusnak deklaráltam, ez a "*" karakter jelzi | ||
| + | a kódban: | ||
| + | |||
| + | char *nev; | ||
| + | |||
| + | Ez pedig azt jelenti, hogy eleve a változó címével dolgozunk. | ||
| + | |||
| + | A char nev[30] egy karaktertömb, amiben maximum 30 karakter tárolható. | ||
| + | Így is használható, így nem szükséges külön malloc() vagy hasonló függvénnyel | ||
| + | helyet foglalni a nev változónak: | ||
| + | char nev[30] | ||
| + | |||
| + | Egy konkrét példa a használatra: | ||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | |||
| + | int main() { | ||
| + | char nev[30]; | ||
| + | printf("Keresztnév: "); | ||
| + | scanf("%s", nev); | ||
| + | printf("Ezt írtad: %s\n", nev); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | A bekérésnél itt sem kell a "&" karakter. | ||
| + | |||
| + | |||
| + | ==== Mondat bekérése ==== | ||
| + | |||
| + | Az fgets() függvény az állományok olvasására használható és az stdio.h | ||
| + | fejállományban található. Az stdio.h fejlécállományban | ||
| + | deklarálva van egy stdin nevű fájl is, amely billentyűzetet szimbolizálja. | ||
| + | Így egy valódi állomány helyett a billentyűzetet is olvashatjuk az fgets() | ||
| + | függvénnyel. | ||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | |||
| + | int main() { | ||
| + | char nev[100]; | ||
| + | |||
| printf("Név: "); | printf("Név: "); | ||
| fgets(nev, 100, stdin); | fgets(nev, 100, stdin); | ||
| printf("Ezt írtad: %s\n", nev); | printf("Ezt írtad: %s\n", nev); | ||
| } | } | ||
| + | </code> | ||
| + | |||
| + | Az fgets() függvény csak adott számú karaktert kér be, amit a második | ||
| + | paraméterben adhatunk meg. Az fgets() függvény beolvassa az Enter billentyűt is. | ||
| + | |||
| + | Ha szeretnénk sortörést törölni, ami az Enter hatására kerül az | ||
| + | adatszerkezetbe, akkor a következő egyszerű példa erre mutat egy lehetőséget. | ||
| + | |||
| + | A karaktersorozat első elemének címét az „s” mutató tartalmazza: | ||
| + | |||
| + | <code c> | ||
| + | if (s[strlen(s)-1]=='\n') s[strlen(s)-1] = '\0'; | ||
| </code> | </code> | ||
| + | A fenti utasítás csak akkor tünteti el az utolsó | ||
| + | karaktert, ha az valóban egy sortörés. | ||
| + | Működése: | ||
| + | megnézzük, hogy az utolsó karakter sortörés-e. | ||
| + | Ha igen, akkor lecseréljük karaktersorozat végét | ||
| + | jelölő null karakterre. | ||
| - | <code c Program01.c> | + | |
| + | |||
| + | <code c prog.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *nev; | char *nev; | ||
| nev = (char*) malloc(100 * sizeof(char)); | nev = (char*) malloc(100 * sizeof(char)); | ||
| printf("Név: "); | printf("Név: "); | ||
| - | scanf("%s", nev); | + | fgets(nev, 100, stdin); |
| printf("Ezt írtad: %s\n", nev); | printf("Ezt írtad: %s\n", nev); | ||
| } | } | ||
| Sor 963: | Sor 1434: | ||
| </code> | </code> | ||
| + | A Karaktersorozat fejezetben még lesz szó, azok bekéréséről. | ||
| + | |||
| + | ===== Gyakorlat 012 ===== | ||
| + | |||
| + | * Válaszoljon a következő kérdésekre: | ||
| + | * Milyen fejállományban található a scanf() függvény? | ||
| + | * Mire használhatjuk a scanf() függvényt? | ||
| + | * Melyik függvénnyel lehet mondatokat bekérni? scanf() vagy fgets() | ||
| ===== Szelekció ===== | ===== Szelekció ===== | ||
| ==== if ==== | ==== if ==== | ||
| + | |||
| + | Bizonyos utasítások végrehajtását feltételhez köthetjük. | ||
| Sor 972: | Sor 1453: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int a = 5; | int a = 5; | ||
| if(a > 0) | if(a > 0) | ||
| printf("Pozitív szám\n"); | printf("Pozitív szám\n"); | ||
| - | |||
| } | } | ||
| Sor 985: | Sor 1464: | ||
| ==== if-else ==== | ==== if-else ==== | ||
| - | <code c> | + | <code c Program01.c> |
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int a = 5; | int a = 5; | ||
| if(a > 0) | if(a > 0) | ||
| Sor 1009: | Sor 1487: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int szam; | int szam; | ||
| Sor 1016: | Sor 1493: | ||
| scanf("%d", &szam); | scanf("%d", &szam); | ||
| - | switch(szam) | + | switch(szam) { |
| - | { | + | |
| case 1 : | case 1 : | ||
| printf("Egy\n"); break; | printf("Egy\n"); break; | ||
| Sor 1030: | Sor 1506: | ||
| Minden case részt meg kell szakítani egy break utasítással, ha nem szeretnénk | Minden case részt meg kell szakítani egy break utasítással, ha nem szeretnénk | ||
| - | a következő case utáni rész is végrehajtani. | + | a következő case utáni rész is végrehajtani. |
| + | |||
| + | ===== Gyakorlat 013 ===== | ||
| + | |||
| + | * Írjon programot, amely -2 és 2 között generál egy számot. | ||
| + | * A lehetséges számok -2, -1, 0, 1, 2 | ||
| + | * Ha szám nagyobb mint 0, írja a képernyőre, hogy a következőt: "Pozitív" | ||
| + | * Az előző programot, egészítse ki: | ||
| + | * 0 vagy negatív szám esetén írja a képernyőre: "Nulla vagy negatív" | ||
| + | * Az előző programot, írja át: | ||
| + | * 0-nál nagyobb szám esetén kiírja: "Pozitív" | ||
| + | * 0 esetén "Nulla" | ||
| + | * 0-nál kisebb szám esetén: "Negatív" | ||
| + | |||
| + | |||
| + | |||
| ===== Iteráció ===== | ===== Iteráció ===== | ||
| ==== for ==== | ==== for ==== | ||
| + | |||
| + | A for() utasítás, egy növekményes ciklusok számára megvalósított eszköz. | ||
| + | Három paramétere van. A paramétereket ";" karakterrel tagoljuk. | ||
| + | Az első paraméter a kezdőérték. A második paraméter a feltétel, amely | ||
| + | tartalmazza, meddig ismétlődjön a ciklus. Az utolsó paraméter a növekmény. | ||
| + | Itt növeljük a i változó tartalmát. | ||
| + | |||
| + | <code> | ||
| + | for(kezdőérték ; feltétel ; növekmény ) { | ||
| + | //ciklus törzse | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | A ciklus törzsébe írjuk azokat az utasításokat, amelyek szeretnénk | ||
| + | minden egyes iterációban végrehajtani. A ciklus törzsét "{" karakterrel | ||
| + | kezdjük, és "}" karakterrel zárjuk. Ha csak egyetlen utasításunk van, | ||
| + | nem kötelező a kapcsos zárójelek használata. A kód átláthatósága érdekében, | ||
| + | azonban ajánlott használni mindig. | ||
| <code c> | <code c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int i; | int i; | ||
| for(i=0; i<10;i++) | for(i=0; i<10;i++) | ||
| Sor 1046: | Sor 1555: | ||
| </code> | </code> | ||
| + | |||
| ==== while ==== | ==== while ==== | ||
| + | |||
| + | A while() ciklusnak egyetlen paramétere van, a feltétel. | ||
| + | Ha feltétel igaz, a ciklus törzsében található utasítások | ||
| + | végrehajtódnak. Ha hamis, a ciklus véget ér. | ||
| <code c> | <code c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int i=0; | int i=0; | ||
| - | while(i<10) | + | while(i<10) { |
| - | { | + | |
| printf("%d\n", i); | printf("%d\n", i); | ||
| i++; | i++; | ||
| Sor 1065: | Sor 1577: | ||
| ==== do-while ==== | ==== do-while ==== | ||
| + | |||
| + | A do-while, egy hátul tesztelő ciklus. A ciklus törzsét először végrehajtja, | ||
| + | és csak ez után vizsgálja meg, hogy a feltétel igaz vagy hamis. | ||
| + | Ha feltétel igaz, a ciklus törzsét újra végrehajtja. Ha hamis, | ||
| + | a ciklus véget ér. | ||
| <code c> | <code c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main(){ |
| - | { | + | |
| int i=0; | int i=0; | ||
| do { | do { | ||
| Sor 1080: | Sor 1596: | ||
| </code> | </code> | ||
| + | |||
| + | ===== Gyakorlat 014 ===== | ||
| + | |||
| + | * Írjon programot, amely véletlen számokat generál. | ||
| + | * Mentés: nulig.c | ||
| + | * A program írja ki a generált véletlen számot. | ||
| + | * Ha a szám nem 0, akkor generáljon újabb számot. | ||
| Sor 1095: | Sor 1618: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| enum het {hetfo, kedd, szerda, csutortok, pentek, szombat, vasarnap}; | enum het {hetfo, kedd, szerda, csutortok, pentek, szombat, vasarnap}; | ||
| Sor 1128: | Sor 1650: | ||
| </code> | </code> | ||
| Egy ilyen növelés után a tartalma már kedd lesz. | Egy ilyen növelés után a tartalma már kedd lesz. | ||
| - | |||
| Megjegyzés: A későbbiekben még veszünk összetett adattípusokat. Ilyen lesz a | Megjegyzés: A későbbiekben még veszünk összetett adattípusokat. Ilyen lesz a | ||
| tömb meg a struktúra. | tömb meg a struktúra. | ||
| + | ===== Gyakorlat 015 ===== | ||
| + | |||
| + | * Írjon programot, amelyben az év hónapjait egy enum szerkezetben tárolja. | ||
| + | * Mentés: havi.c | ||
| + | * Írassa ki a hónapokat az 5-dik hónapot. | ||
| Sor 1139: | Sor 1665: | ||
| ==== Tárolás ==== | ==== Tárolás ==== | ||
| - | |||
| A karaktersorozat (angolul string) típus nem létezik a C nyelvben. | A karaktersorozat (angolul string) típus nem létezik a C nyelvben. | ||
| - | Ha karakter sorozatot szeretnénk tárolni, akkor egy karakteres mutató | + | Ha karaktersorozatot szeretnénk tárolni, akkor egy karakteres mutató |
| típusú változót hozok létre, ahol a mutatótól kezdve a memóriában | típusú változót hozok létre, ahol a mutatótól kezdve a memóriában | ||
| több karaktert is tárolhatok. A mutató típusú változó a karaktersorozat | több karaktert is tárolhatok. A mutató típusú változó a karaktersorozat | ||
| Sor 1153: | Sor 1678: | ||
| </code> | </code> | ||
| + | |||
| + | A példa kedvéért legyen a "Hello" szöveg eltárolva a fe1011 memóriacímtől kezdve. | ||
| + | Az alábbi táblázat mutatja, mit tartalmaz a memória. | ||
| ^ betűk | 'H' | 'e' | 'l' | 'l' | 'o' | 0 | | ^ betűk | 'H' | 'e' | 'l' | 'l' | 'o' | 0 | | ||
| Sor 1159: | Sor 1687: | ||
| Az utolsó tehát nem számjegy, hanem egy 0 értékű bájt. | Az utolsó tehát nem számjegy, hanem egy 0 értékű bájt. | ||
| - | Ezt persze nem kell nekünk a karakter sorozat végére tenni, mert az | + | Ezt persze nem kell nekünk a karaktersorozat végére tenni, mert azt |
| a fordító automatikusan megteszi. Egy ilyen mutató létrehozása | a fordító automatikusan megteszi. Egy ilyen mutató létrehozása | ||
| - | a következő képen néz ki: | + | a következő módon valósítható meg: |
| Sor 1169: | Sor 1697: | ||
| A működéshez le kell még foglalni annyi karakter helyet a memóriában, amennyit | A működéshez le kell még foglalni annyi karakter helyet a memóriában, amennyit | ||
| - | szeretnénk eltárolni. A helyfoglaláshoz két függvényt szoktunk használni: | + | szeretnénk eltárolni. A helyfoglaláshoz két függvényből egyet szoktunk használni: |
| * malloc() | * malloc() | ||
| * calloc() | * calloc() | ||
| - | Mind a kettő az stdlib.h programozói könyvtárakban van. | + | Mindkettő az stdlib.h programozói könyvtárakban van. |
| Mi most a malloc() használatát nézzük meg. | Mi most a malloc() használatát nézzük meg. | ||
| Sor 1188: | Sor 1716: | ||
| </code> | </code> | ||
| - | A malloc() azonban void típus ad vissza, amit át kell alakítanunk | + | A malloc() azonban void típust ad vissza, amit át kell alakítanunk |
| char* típusúvá: | char* típusúvá: | ||
| Sor 1202: | Sor 1730: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *s; | char *s; | ||
| s = (char*) malloc(30); | s = (char*) malloc(30); | ||
| Sor 1214: | Sor 1741: | ||
| használunk. Ez függhet az adott rendszertől. A helyfoglaló | használunk. Ez függhet az adott rendszertől. A helyfoglaló | ||
| függvényt ezért szokás kibővíteni egy vizsgálattal, amely megmondja | függvényt ezért szokás kibővíteni egy vizsgálattal, amely megmondja | ||
| - | mekkora egy char típus az adott rendszerben. Erre a sizeof() | + | mekkora egy char típus az adott rendszeren. Erre a sizeof() |
| operátort használhatjuk. Az általa visszaadott értéket | operátort használhatjuk. Az általa visszaadott értéket | ||
| szorozzuk be 30-al: | szorozzuk be 30-al: | ||
| Sor 1221: | Sor 1748: | ||
| <code c> | <code c> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *s; | char *s; | ||
| s = (char*) malloc(30 * sizeof(char)); | s = (char*) malloc(30 * sizeof(char)); | ||
| Sor 1229: | Sor 1755: | ||
| </code> | </code> | ||
| - | Ha szeretnénk megváltoztatni a lefoglalt hely mérettét az következő utasítással tehetjük meg: | + | Ha szeretnénk megváltoztatni a lefoglalt hely méretét az következő utasítással tehetjük meg: |
| * realloc() | * realloc() | ||
| Sor 1235: | Sor 1761: | ||
| * free() | * free() | ||
| - | ==== A változó használata ==== | ||
| + | Példa: | ||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | #include <stdlib.h> | ||
| + | #include <string.h> | ||
| + | |||
| + | int main() { | ||
| + | char *nev; | ||
| + | nev = (char*) malloc(10* sizeof(char)); | ||
| + | strcpy(nev, "Lajos"); | ||
| + | printf("%s\n", nev); | ||
| + | |||
| + | nev = (char*) realloc(nev, 30 * sizeof(char)); | ||
| + | strcpy(nev, "Ferdinándházi Lajos"); | ||
| + | printf("%s\n", nev); | ||
| + | |||
| + | free(nev); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | ==== A változó használata ==== | ||
| Most már használhatjuk a "s" változót. A C nyelvben egy | Most már használhatjuk a "s" változót. A C nyelvben egy | ||
| - | karakter sorozatot nem adhatunk meg egy egyenlőség jel jobboldalán. | + | karaktersorozatot nem adhatunk meg egy egyenlőség jel jobboldalán. |
| - | Ha egy változóban egy karaktersorozatot szeretnénk elhelyezni, | + | Ha egy változóba egy karaktersorozatot szeretnénk elhelyezni, |
| akkor arra az strcpy() függvény használható, amely a string.h | akkor arra az strcpy() függvény használható, amely a string.h | ||
| könyvtárakban találhatók: | könyvtárakban találhatók: | ||
| Sor 1247: | Sor 1794: | ||
| #include <stdlib> | #include <stdlib> | ||
| #include <string.h> | #include <string.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *gyumolcs; | char *gyumolcs; | ||
| gyumolcs = (char*) malloc(30 * sizeof(char)); | gyumolcs = (char*) malloc(30 * sizeof(char)); | ||
| Sor 1256: | Sor 1802: | ||
| </code> | </code> | ||
| - | ==== Kiíratás ==== | + | Ha tömböt használunk, akkor nem szükséges külön helyfoglaló utasítást használni, |
| + | például a malloc(), mivel a eleve helyfoglalás történik. Legyen a példa kedvéért | ||
| + | egy "nev" nevű tömb, amiben 30 karakternek foglalok helyet: | ||
| + | char nev[30]; | ||
| + | Itt lefoglaltam a helyet 30 karakter számára, nem kell külön malloc() függvény. | ||
| + | A használatra példa: | ||
| + | <code c> | ||
| + | #include <string.h> | ||
| + | int main() { | ||
| + | char gyumolcs[30]; | ||
| + | strcpy(gyumolcs, "szilva"); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | |||
| + | ==== Kiíratás ==== | ||
| Ha egy változóban lévő karaktersorozatot akarunk a képernyőre íratni, akkor | Ha egy változóban lévő karaktersorozatot akarunk a képernyőre íratni, akkor | ||
| az "s" formátumkódot kell használnunk. A fenti gyumolcs változó tartalmának | az "s" formátumkódot kell használnunk. A fenti gyumolcs változó tartalmának | ||
| képernyőre íratása: | képernyőre íratása: | ||
| - | |||
| Sor 1270: | Sor 1831: | ||
| #include <stdlib> | #include <stdlib> | ||
| #include <string.h> | #include <string.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *gyumolcs; | char *gyumolcs; | ||
| gyumolcs = (char*) malloc(30 * sizeof(char)); | gyumolcs = (char*) malloc(30 * sizeof(char)); | ||
| Sor 1283: | Sor 1843: | ||
| ==== Bekérés ==== | ==== Bekérés ==== | ||
| + | A karaktersorozatok bekéréséről már volt szó a Bekérés című fejezetben. | ||
| + | Itt most átismételjük a tanultakat. | ||
| <code c bekerstr.c> | <code c bekerstr.c> | ||
| Sor 1288: | Sor 1850: | ||
| #include <stdlib> | #include <stdlib> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *gyumolcs; | char *gyumolcs; | ||
| gyumolcs = (char*) malloc(30 * sizeof(char)); | gyumolcs = (char*) malloc(30 * sizeof(char)); | ||
| Sor 1298: | Sor 1859: | ||
| </code> | </code> | ||
| - | Ha egy változóba egy értéket teszünk a scanf() függvénnyel, akkor | + | Ha egy változóba egy értéket szeretnénk beolvasni a scanf() függvénnyel, akkor |
| - | sosem magát a mutató, hanem annak címét kell megadnunk. Ezt úgy | + | sosem magát a változó nevét kell megadni, hanem annak címét. Ezt úgy |
| érjük el, hogy a változó név elé egy "&" karaktert teszünk. | érjük el, hogy a változó név elé egy "&" karaktert teszünk. | ||
| A gyumolcs változó elé mégsem tettünk, mert az eleve mutató típus, | A gyumolcs változó elé mégsem tettünk, mert az eleve mutató típus, | ||
| Sor 1306: | Sor 1867: | ||
| A scanf() függvény azonban csak egyetlen szó bekérésére alkalmas, | A scanf() függvény azonban csak egyetlen szó bekérésére alkalmas, | ||
| mert whitespace karakterig olvas. A szóközök után írt karaktereket | mert whitespace karakterig olvas. A szóközök után írt karaktereket | ||
| - | már nem tárolja el. Ezért mondatokat nem tudunk vele beolvasni. | + | már nem tárolja el. |
| - | Mondatokat a gets vagy fgets függvények alkalmasak. | + | |
| + | Mondatok beolvasását az fgets() függvénnyel valósítjuk meg. | ||
| + | Rendelkezésre áll a gets() függvény is, de használata | ||
| + | biztonsági kockázatot jelent. | ||
| + | |||
| + | Példa az fgets() használatára. | ||
| + | |||
| + | <code c mondat.c> | ||
| + | #include <stdio.h> | ||
| + | #include <stdlib.h> | ||
| + | |||
| + | int main() { | ||
| + | char *mondat; | ||
| + | mondat = (char*) malloc(30 * sizeof(char)); | ||
| + | printf("Mondat: "); | ||
| + | fgets(mondat, 30, stdin); | ||
| + | printf("Ezt írtad: %s\n", mondat); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | Az fgets() valójában fájlok olvasására lett kitalálva, | ||
| + | de van egy speciális fájl, aminek a neve stdin. | ||
| + | Ha ezt a fájlt olvassuk, akkor billentyűzet leütéseit | ||
| + | kapjuk meg. | ||
| + | |||
| + | A nem ajánlott gets() függvényre példa: | ||
| + | <code c noget.c> | ||
| + | #include <stdio.h> | ||
| + | #include <stdlib.h> | ||
| + | |||
| + | int main() { | ||
| + | char *mondat; | ||
| + | mondat = (char*) malloc(30 * sizeof(char)); | ||
| + | printf("Mondat: "); | ||
| + | gets(mondat); | ||
| + | printf("Ezt írtad: %s\n", mondat); | ||
| + | } | ||
| + | |||
| + | </code> | ||
| ==== Karaktersorozat darabolása ==== | ==== Karaktersorozat darabolása ==== | ||
| Sor 1348: | Sor 1948: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *str = (char*) malloc(30 * sizeof(char)); | char *str = (char*) malloc(30 * sizeof(char)); | ||
| char *token = NULL; | char *token = NULL; | ||
| Sor 1355: | Sor 1954: | ||
| token = (char*) strtok(str, ":"); | token = (char*) strtok(str, ":"); | ||
| - | while(token != NULL) | + | while(token != NULL) { |
| - | { | + | |
| printf("%s\n", token); | printf("%s\n", token); | ||
| token = (char*) strtok(NULL, ":"); | token = (char*) strtok(NULL, ":"); | ||
| Sor 1368: | Sor 1966: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *jarmu = (char*) malloc(30 * sizeof(char)); | char *jarmu = (char*) malloc(30 * sizeof(char)); | ||
| char elvalaszto[] = ":"; | char elvalaszto[] = ":"; | ||
| Sor 1376: | Sor 1973: | ||
| resz = (char*) strtok(jarmu, elvalaszto); | resz = (char*) strtok(jarmu, elvalaszto); | ||
| - | while(resz != NULL) | + | while(resz != NULL) { |
| - | { | + | |
| printf("%s\n", resz); | printf("%s\n", resz); | ||
| resz = (char*) strtok(NULL, elvalaszto); | resz = (char*) strtok(NULL, elvalaszto); | ||
| Sor 1388: | Sor 1984: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *jarmu = (char*) malloc(30 * sizeof(char)); | char *jarmu = (char*) malloc(30 * sizeof(char)); | ||
| char elvalaszto[] = "#"; | char elvalaszto[] = "#"; | ||
| Sor 1396: | Sor 1991: | ||
| resz = (char*) strtok(jarmu, elvalaszto); | resz = (char*) strtok(jarmu, elvalaszto); | ||
| - | while(resz != NULL) | + | while(resz != NULL) { |
| - | { | + | |
| printf("%s\n", resz); | printf("%s\n", resz); | ||
| resz = (char*) strtok(NULL, elvalaszto); | resz = (char*) strtok(NULL, elvalaszto); | ||
| Sor 1409: | Sor 2003: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| char *jarmu = (char*) malloc(30 * sizeof(char)); | char *jarmu = (char*) malloc(30 * sizeof(char)); | ||
| char elvalaszto[] = "#:;"; | char elvalaszto[] = "#:;"; | ||
| Sor 1417: | Sor 2010: | ||
| resz = (char*) strtok(jarmu, elvalaszto); | resz = (char*) strtok(jarmu, elvalaszto); | ||
| - | while(resz != NULL) | + | while(resz != NULL) { |
| - | { | + | |
| printf("%s\n", resz); | printf("%s\n", resz); | ||
| resz = (char*) strtok(NULL, elvalaszto); | resz = (char*) strtok(NULL, elvalaszto); | ||
| Sor 1428: | Sor 2020: | ||
| * [[oktatas:programozás:c:c_példaprogram#sztring_darabolás]] | * [[oktatas:programozás:c:c_példaprogram#sztring_darabolás]] | ||
| + | |||
| + | |||
| + | ==== Üres vagy nem üres ==== | ||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | |||
| + | int main () { | ||
| + | char szoveg[30]; | ||
| + | if(szoveg[0]) { | ||
| + | printf("Üres\n"); | ||
| + | } | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | #include <string.h> | ||
| + | |||
| + | int main () { | ||
| + | char szoveg[30]; | ||
| + | if(szoveg && szoveg[0]) { | ||
| + | printf("Üres\n"); | ||
| + | } | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | |||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | #include <string.h> | ||
| + | |||
| + | int main () { | ||
| + | char szoveg[30]; | ||
| + | strcpy(szoveg, ""); | ||
| + | if(szoveg[0] == '\0') { | ||
| + | printf("Üres\n"); | ||
| + | } | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | ==== Összefűzés ==== | ||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | #include <string.h> | ||
| + | |||
| + | int main () { | ||
| + | char szoveg1[30]; | ||
| + | char szoveg2[30]; | ||
| + | |||
| + | strcpy(szoveg1, "alma"); | ||
| + | strcpy(szoveg2, "körte"); | ||
| + | strcat(szoveg1, szoveg2); | ||
| + | printf("Szöveg: %s\n", szoveg1); | ||
| + | |||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | ==== Összehasonlítás ==== | ||
| + | |||
| + | <code c prog.c> | ||
| + | #include <stdio.h> | ||
| + | #include <string.h> | ||
| + | |||
| + | int main () { | ||
| + | char szoveg[30]; | ||
| + | strcpy(szoveg, "alma"); | ||
| + | |||
| + | if(!strcmp(szoveg, "alma")) { | ||
| + | printf("Egyezik\n"); | ||
| + | }else { | ||
| + | printf("Nem egyezik\n"); | ||
| + | } | ||
| + | } | ||
| + | |||
| + | </code> | ||
| + | |||
| + | ===== Gyakorlat 016 ===== | ||
| + | |||
| + | * Írjon programot, amelyben bekéri egy dolgozó nevét, települését és fizetését. | ||
| + | * Mentés: dole.c | ||
| + | |||
| + | |||
| + | |||
| ===== Tömb ===== | ===== Tömb ===== | ||
| ==== Vektor ==== | ==== Vektor ==== | ||
| Sor 1476: | Sor 2159: | ||
| <code c tomb1.c> | <code c tomb1.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| int tomb[] = {3, 5, 6, 7, 8, 9 }; | int tomb[] = {3, 5, 6, 7, 8, 9 }; | ||
| printf("%d\n", tomb[0]); | printf("%d\n", tomb[0]); | ||
| Sor 1506: | Sor 2188: | ||
| typedef int Ttomb[MAX]; | typedef int Ttomb[MAX]; | ||
| - | void kiir(int *tomb) | + | void kiir(int *tomb) { |
| - | { | + | |
| tomb[0]=8; | tomb[0]=8; | ||
| } | } | ||
| - | main() | + | |
| - | { | + | int main() { |
| Ttomb tomb; | Ttomb tomb; | ||
| Sor 1519: | Sor 2200: | ||
| kiir(tomb); | kiir(tomb); | ||
| printf("%d\n", tomb[0]); | printf("%d\n", tomb[0]); | ||
| + | } | ||
| + | </code> | ||
| + | ==== Tömb bejárása ==== | ||
| + | |||
| + | <code c tomb.c> | ||
| + | #include <stdio.h> | ||
| + | int main() { | ||
| + | int tomb[] = {3, 8, 5, 6, 2, 9 }; | ||
| + | int i; | ||
| + | for(i=0; i<6; i++) { | ||
| + | printf("%d\n", tomb[i]); | ||
| + | } | ||
| + | } | ||
| + | </code> | ||
| + | |||
| + | ==== Tömb mérete ==== | ||
| + | |||
| + | <code c> | ||
| + | int tomb[] = {3, 8, 5, 6, 2, 9 }; | ||
| + | int n = sizeof tomb / sizeof tomb[0]; | ||
| + | </code> | ||
| + | Vagy: | ||
| + | |||
| + | <code c> | ||
| + | int tomb[] = {3, 8, 5, 6, 2, 9 }; | ||
| + | size_t meret = sizeof(tomb) / sizeof(tomb[0]); | ||
| + | </code> | ||
| + | |||
| + | |||
| + | Vagy: | ||
| + | <code c> | ||
| + | int tomb[] = {3, 8, 5, 6, 2, 9 }; | ||
| + | int n = sizeof tomb / sizeof *tomb; | ||
| + | </code> | ||
| + | |||
| + | |||
| + | Komplett példa: | ||
| + | <code c tomb.c> | ||
| + | #include <stdio.h> | ||
| + | int main() { | ||
| + | int tomb[] = {3, 8, 5, 6, 2, 9 }; | ||
| + | int n = sizeof tomb / sizeof *tomb; | ||
| + | int i; | ||
| + | for(i=0; i<n; i++) { | ||
| + | printf("%d\n", tomb[i]); | ||
| + | } | ||
| } | } | ||
| </code> | </code> | ||
| Sor 1592: | Sor 2319: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | void rendez(int *tomb) | + | void rendez(int *tomb) { |
| - | { | + | if(tomb[0] > tomb[1]) { |
| - | if(tomb[0] > tomb[1]) | + | |
| - | { | + | |
| int tmp = tomb[0]; | int tmp = tomb[0]; | ||
| tomb[0] = tomb[1]; | tomb[0] = tomb[1]; | ||
| Sor 1601: | Sor 2326: | ||
| } | } | ||
| } | } | ||
| - | main() | + | |
| - | { | + | int main() { |
| int tomb[2]; | int tomb[2]; | ||
| tomb[0] = 3; | tomb[0] = 3; | ||
| Sor 1612: | Sor 2337: | ||
| Az átadott tömb cím szerint adódik át. | Az átadott tömb cím szerint adódik át. | ||
| + | |||
| + | ===== Gyakorlat 017 ===== | ||
| + | |||
| + | * Írjon programot, amelyben valós számokat tárol. | ||
| + | * Mentés: valostomb.c | ||
| + | |||
| Sor 1669: | Sor 2400: | ||
| - | int sum(TEgeszTomb ptomb) | + | int sum(TEgeszTomb ptomb) { |
| - | { | + | |
| int osszeg = 0, i; | int osszeg = 0, i; | ||
| for(i=0; i<5; i++) | for(i=0; i<5; i++) | ||
| Sor 1677: | Sor 2407: | ||
| } | } | ||
| - | main() | + | int main() { |
| - | { | + | |
| TEgeszTomb tomb = {3, 5, 8, 2, 7}; | TEgeszTomb tomb = {3, 5, 8, 2, 7}; | ||
| Sor 1725: | Sor 2454: | ||
| ==== Írás ==== | ==== Írás ==== | ||
| - | |||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *f; | FILE *f; | ||
| f = fopen("adat.txt","w"); | f = fopen("adat.txt","w"); | ||
| Sor 1739: | Sor 2466: | ||
| } | } | ||
| </code> | </code> | ||
| - | |||
| Sor 1747: | Sor 2473: | ||
| <code c main.c> | <code c main.c> | ||
| #include <stdio.h> | #include <stdio.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *f; | FILE *f; | ||
| f = fopen("adat.txt","a"); | f = fopen("adat.txt","a"); | ||
| Sor 1772: | Sor 2497: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp = fopen("adat.txt", "r"); | FILE *fp = fopen("adat.txt", "r"); | ||
| char *str = (char*) malloc(30 * sizeof(char)); | char *str = (char*) malloc(30 * sizeof(char)); | ||
| - | while(!feof(fp)) | + | while(!feof(fp)) { |
| - | { | + | |
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| if(!feof(fp)) | if(!feof(fp)) | ||
| Sor 1796: | Sor 2519: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp = fopen("adat.txt", "r"); | FILE *fp = fopen("adat.txt", "r"); | ||
| char *str = (char*) malloc(30 * sizeof(char)); | char *str = (char*) malloc(30 * sizeof(char)); | ||
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| - | while(!feof(fp)) | + | while(!feof(fp)) { |
| - | { | + | |
| printf("%s", str); | printf("%s", str); | ||
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| Sor 1827: | Sor 2548: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| #include <string.h> | #include <string.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp = fopen("adat2.txt", "r"); | FILE *fp = fopen("adat2.txt", "r"); | ||
| char *str = (char*) malloc(30 * sizeof(char)); | char *str = (char*) malloc(30 * sizeof(char)); | ||
| Sor 1834: | Sor 2554: | ||
| int ar; | int ar; | ||
| - | while(!feof(fp)) | + | while(!feof(fp)) { |
| - | { | + | |
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| - | if(!feof(fp)) | + | if(!feof(fp)) { |
| - | { | + | |
| sscanf(str, "%s %d\n", nev,&ar); | sscanf(str, "%s %d\n", nev,&ar); | ||
| printf("%s %d\n", nev, ar); | printf("%s %d\n", nev, ar); | ||
| Sor 1852: | Sor 2570: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| #include <string.h> | #include <string.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp = fopen("adat2.txt", "r"); | FILE *fp = fopen("adat2.txt", "r"); | ||
| char *str = (char*) malloc(30 * sizeof(char)); | char *str = (char*) malloc(30 * sizeof(char)); | ||
| Sor 1859: | Sor 2576: | ||
| int ar; | int ar; | ||
| - | while(!feof(fp)) | + | while(!feof(fp)) { |
| - | { | + | |
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| - | if(!feof(fp)) | + | if(!feof(fp)) { |
| - | { | + | |
| sscanf(str, "%s", nev); | sscanf(str, "%s", nev); | ||
| sscanf(str + strlen(nev), "%d", &ar); | sscanf(str + strlen(nev), "%d", &ar); | ||
| Sor 1878: | Sor 2593: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp = fopen("adat.txt", "r"); | FILE *fp = fopen("adat.txt", "r"); | ||
| Sor 1900: | Sor 2614: | ||
| #include <stdio.h> | #include <stdio.h> | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp = fopen("adat.txt", "r"); | FILE *fp = fopen("adat.txt", "r"); | ||
| Sor 1922: | Sor 2635: | ||
| #include <stdlib.h> | #include <stdlib.h> | ||
| #include <errno.h> | #include <errno.h> | ||
| - | main() | + | int main() { |
| - | { | + | |
| FILE *fp; | FILE *fp; | ||
| - | if((fp= fopen("adat.txta", "r"))== NULL) | + | if((fp= fopen("adat.txta", "r"))== NULL) { |
| - | { | + | |
| perror("Hiba a fájl megnyitása során\n"); | perror("Hiba a fájl megnyitása során\n"); | ||
| printf("Hibaszám: %d.\n", errno); | printf("Hibaszám: %d.\n", errno); | ||
| Sor 1935: | Sor 2646: | ||
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| - | while(!feof(fp)) | + | while(!feof(fp)) { |
| - | { | + | |
| printf("%s", str); | printf("%s", str); | ||
| fgets(str, 30, fp); | fgets(str, 30, fp); | ||
| Sor 1944: | Sor 2654: | ||
| } | } | ||
| </code> | </code> | ||
| - | |||
| - | |||
| ===== Függvények ===== | ===== Függvények ===== | ||
| Sor 1951: | Sor 2659: | ||
| Érték szerint átadott paraméterek: | Érték szerint átadott paraméterek: | ||
| <code c> | <code c> | ||
| - | int novel(int szam) | + | int novel(int szam) { |
| - | { | + | |
| return szam + 1; | return szam + 1; | ||
| } | } | ||
| Sor 1965: | Sor 2672: | ||
| int szam = 0; | int szam = 0; | ||
| - | void novel() | + | void novel() { |
| - | { | + | |
| szam = szam + 1; | szam = szam + 1; | ||
| } | } | ||
| Sor 1976: | Sor 2682: | ||
| <code c> | <code c> | ||
| - | void novel(int *szam) | + | void novel(int *szam) { |
| - | { | + | |
| *szam = *szam + 1; | *szam = *szam + 1; | ||
| } | } | ||
| - | main() | + | |
| - | { | + | int main() { |
| int szam = 0; | int szam = 0; | ||
| novel(&szam); | novel(&szam); | ||
oktatas/programozas/c/c_nyelv.txt · Utolsó módosítás: 2023/03/14 21:58 szerkesztette: admin
Hacsak máshol nincs egyéb rendelkezés, ezen wiki tartalma a következő licenc alatt érhető el: CC Attribution-Share Alike 4.0 International
