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:27] admin [Nevesített állandó] |
oktatas:programozas:c:c_nyelv [2020/05/19 14:47] admin [Üres vagy nem üres] |
||
---|---|---|---|
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 334: | Sor 393: | ||
A define előfordítói utasítással, és a const módosítóval. | A define előfordítói utasítással, és a const módosítóval. | ||
- | {{:oktatas:programozas:c:nevesitett_literalis_allando.png?400|}} | + | {{:oktatas:programozas:c:nevesitett_literalis_allando.png?300|}} |
A const egy módosító. A módosító után áll az állandó típusa. | A const egy módosító. A módosító után áll az állandó típusa. | ||
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> | ||
+ | |||
+ | ===== 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 2140: | ||
<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 2169: | ||
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 2181: | ||
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 2300: | ||
#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 2307: | ||
} | } | ||
} | } | ||
- | main() | + | |
- | { | + | int main() { |
int tomb[2]; | int tomb[2]; | ||
tomb[0] = 3; | tomb[0] = 3; | ||
Sor 1612: | Sor 2318: | ||
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 2381: | ||
- | 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 2388: | ||
} | } | ||
- | main() | + | int main() { |
- | { | + | |
TEgeszTomb tomb = {3, 5, 8, 2, 7}; | TEgeszTomb tomb = {3, 5, 8, 2, 7}; | ||
Sor 1725: | Sor 2435: | ||
==== Í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 2447: | ||
} | } | ||
</code> | </code> | ||
- | |||
Sor 1747: | Sor 2454: | ||
<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 2478: | ||
#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 2500: | ||
#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 2529: | ||
#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 2535: | ||
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 2551: | ||
#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 2557: | ||
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 2574: | ||
#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 2595: | ||
#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 2616: | ||
#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 2627: | ||
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 2635: | ||
} | } | ||
</code> | </code> | ||
- | |||
- | |||
===== Függvények ===== | ===== Függvények ===== | ||
Sor 1951: | Sor 2640: | ||
É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 2653: | ||
int szam = 0; | int szam = 0; | ||
- | void novel() | + | void novel() { |
- | { | + | |
szam = szam + 1; | szam = szam + 1; | ||
} | } | ||
Sor 1976: | Sor 2663: | ||
<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); |