Programozás alapjai 8.Gy: Program struktúra

Átírás

1 Programozás alapjai 8.Gy: Program struktúra Elvarázsolt matekóra P R O A L A G 32/1 B ITv: MAN

2 Programozás történelem Kezdetben egy program egyetlen kódsorozat volt (ún. monolitikus program) Ahogy komolyodtak a programok, úgy lettek egyre átláthatatlanabbak, ezért elkezdték azzal foglalkozni, hogyan kellene összetett, bonyolult programokat írni Megszületett a moduláris programozás: A moduláris programozás olyan programozási mód, melyben a teljes program modulokból áll. Az egyes modulok jól meghatározott részfeladat megoldását végzik, kezelhető méretűek, egyértelmű céljuk van és jól definiáltan csatlakoznak a program többi moduljához. Minden modul önállóan lefordítható, önállóan is futásképes program A modulokat szubrutinnak (alprogramnak) szokás nevezni. 32/2

3 C program felépítése A modulokból felépülő programokhoz hasonló egy összetett C program felépítése: A C programot függvények építik fel Egy függvény egy jól körül határolt feladatot végez el A függvényeket egy fő függvényből (main) hívjuk meg Azokat a feladatokat célszerű önálló függvényként megírni, melyeket többször is használni akarunk egy programban, pl: Számítási algoritmusok, Kiíratások, Beolvasások, 32/3

4 C program felépítése C program Részegységek Elnevezésük C- ben: függvény. A függvény a matematikai értelemben vett függvény általánosítása, gyakorlatilag egy (rész-)algoritmus megvalósítása. 32/4 void kiir(char *a){ ; printf("%s", a); int fgv_1(int a){ x = ; return x; int main(){ n= ; k = fgv_1(n); s= ; kiir(&s); A függvény deklarációja azt mondja meg, hogy milyen típusú értékekből milyen típusú értéket állít elő. A függvény meghívásakor azt adjuk meg, hogy milyen konkrét értékeken hajtsuk végre a függvény által leírt algoritmust.

5 C program végrehajtása C program void kiir(char *a){ ; printf("%s", a); Mindig itt kezdődik egy C program végrehajtása 32/5 int fgv_1(int a){ x = ; return x; int main(){ n= ; k = fgv_1(n); s= ; kiir(&s); Az n érték átadódik az fgv_1-nek! Függvény hívás

6 C program végrehajtása C program void kiir(char *a){ ; printf("%s", a); Az fgv_1 függvényben lévő kód végrehajtása után visszatér a vezérlés a main függvénybe Az x érték átadódik k- nak! 32/6 int fgv_1(int a){ x = ; return x; int main(){ n= ; k = fgv_1(n); s= ; kiir(&s);

7 C program végrehajtása C program void kiir(char *a){ ; printf("%s", a); 32/7 int fgv_1(int a){ x = ; return x; int main(){ n= ; k = fgv_1(n); s= ; kiir(&s); Az s érték átadódik a kiir függvénynek! Függvény hívás

8 C program végrehajtása C program void: nem ad vissza értéket void kiir(char *a){ ; printf("%s", a); A kiir függvényben lévő kód végrehajtása után visszatér a vezérlés a main függvénybe 32/8 int fgv_1(int a){ x = ; return x; int main(){ n= ; k = fgv_1(n); s= ; kiir(&s); Mindig itt végződik egy C program végrehajtása

9 Függvények Jellegzetességek a C nyelvben: A függvények és eljárások (visszatérő érték nélküli függvények) szintaktikája nem különbözik, azaz csak függvények léteznek, a void visszatérési érték típussal jelezzük, ha nem akarunk visszaadni értéket. Nem lehet definiálni függvényt egy másik függvény belsejében. Bármelyik függvény meghívhatja bármelyik függvényt, még saját magát is (rekurzív hívás), vagy akár a main függvényt is. Visszatérési érték és paraméter nem lehet tömb, struktúra, union, lehet viszont ezekre irányuló mutató. A C program belépési pontja a main függvény, ez a főprogram Egy C nyelven írt program tulajdonképpen nem más, mint függvények (megfelelően strukturált és rendezett) összessége. 32/9

10 Függvények 2. Szintaktika: típus fgvnév(paraméterek) { utasítások; return visszatérő_érték; Pl.: double dszhterulet(double x, double y) { return x*y/2; 32/10

11 Függvény példa #include <stdio.h> double dszhterulet(double x, double y) { return x*y/2; int main (){ int a=3, b=5; double t; t= dszhterulet(a,b); printf ("Terület = %6.2f\n", t); Formális paraméterek Aktuális paraméterek 32/11

12 Függvény példa Készítsen egy függvényt, amely kap egy egész számot és visszaadja a szám faktoriálisát. long fakt(int a) { long szorzat; int j; for (j=1; j<=a; j++) szorzat *= j; return szorzat; N faktoriálisa: a számok szorzata 1-től N-ig. Készítsen egy függvényt, amely három oldalhosszúságról megállapítja, alkothatnak-e háromszöget! int alkothate(double a, double b, double c){ if (a+b<=c a+c<=b b+c<=a) return 1; 32/12 Visszatérő érték: 1 ha igen, 0 ha nem.

13 Függvény deklarálása, meghívása, definiálása TXT #include<stdio.h> void kiir(int); int negyzet(int); int main() { int a=4, b; b=negyzet(a); kiir(b); void kiir(int x) { printf("%d",x); int negyzet(int x){ return x*x; 32/13 Deklarációnál csak azt mondjuk meg, hogy mennyi és milyen típusú paraméterekből milyen típusú értéket fog kiszámolni a függvényünk. (Függvény prototípusok) A függvényhívásnál konkrét értékekre alkalmazzuk a függvényt, és a kiszámított értéket felhasználhatjuk további számolásainkhoz. Definíciónál azt is meg kell adnunk, hogy hogyan számoljon. Nagyobb programok esetén célszerű a program elején deklarálni, és a végén definiálni a függvényeket.

14 Függvény példa TXT #include<stdio.h> const char * eldont(int a, int b) { if (a==b) return "\negyenlő a két szám\n"; else if (a<b) return "\naz első szám kisebb\n"; else return "\naz első szám nagyobb\n"; void kiir_1(int a, int b){ printf("a két szám: %d és %d", a, b); void kiir_2(char *c) { printf("%s", c); int main() { int x=3, y=5; kiir_1(x, y); const char * s=eldont(x, y); kiir_2(s); 32/14 Minden függvényben szerepelnie kell legalább egy return utasításnak. Ha a függvényben végrehajtunk egy ilyen utasítást, akkor a függvény értékének kiszámítása befejeződik. A hívás helyén a függvény a return által kiszámított értéket veszi fel.

15 Faktoriális! 6 24 N faktoriálisa: a számok szorzata 1-től N-ig. 32/15

16 Kövessük a kódot TXT #include <stdio.h> void beolvas(int* x); int faktor(int x); Függvény deklarációk int main() { int szam; Főprogram beolvas(&szam); printf("%d! = %d\n", szam, faktor(szam)); int faktor(int x) { int fakt=1; while(x>1) { fakt *= x; x--; return fakt; 32/16 Miért 1-ről indul?

17 Kövessük a kódot void beolvas(int* x) { int adb; char sz[20]; do { printf("adj meg egy egész számot: "); adb=scanf("%d", x); if (adb==0) { printf("hibás adat! Add meg újra: \n"); scanf("%s", sz); while (adb!=1); 32/17

18 Tökéletes számok "Numerus Perfectus" Tökéletes szám az szám, amely megegyezik a nála kisebb osztóinak összegével (Pl.: 6=1+2+3; 28, 496, 8128). 32/18

19 Kövessük a kódot TXT #include <stdio.h> int tokeletes(int szam) { if (szam==kisebboszto_osszeg(szam)) return 1; Eldöntő függvény, visszatérő értéke igen (1) vagy nem (0) int kisebboszto_osszeg(int szam) { int osszeg, oszto; osszeg=0; for (oszto=1; oszto<=szam/2; oszto+=1) { if (szam%oszto == 0) osszeg += oszto; Egy szám önmagától kisebb osztóinak összege return osszeg; int main() { int x; printf("adj meg egy egész számot: "); scanf("%d", &x); if (tokeletes(x)) printf("\na megadott szám tökéletes\n"); else printf("\na megadott szám nem tökéletes\n"); 32/19

20 32/20

21 Kövessük a kódot A barátságos számpároknál az egyik szám önmagánál kisebb osztóinak összege a másik számmal egyenlő és fordítva. Pl.: (220;284) (1184;1210) (2620;2924) (5020;5564) (6232;6368) #include <stdio.h> void beolvas(int *hatar, char *c) { printf("%s", c); scanf("%d", hatar); return; Kiír egy szöveget, és beolvas egy számot void függvénynél is ki lehet írni a return; utasítást int baratsagos(int a, int b) { if (a==kisebboszto_osszeg(b) && b==kisebboszto_osszeg(a))return 1; Barátságos szám ellenőrzése int kisebboszto_osszeg(int szam) { int osszeg, oszto; osszeg=0; for (oszto=1; oszto<=szam/2; oszto+=1) { if (szam%oszto == 0) osszeg += oszto; Egy szám önmagától kisebb return osszeg; osztóinak összege 32/21 TXT

22 Kövessük a kódot TXT int main( ) { int alsohatar, felsohatar, i, j; beolvas(&alsohatar, "\nadd meg az alsó határt: "); do { beolvas(&felsohatar, "Add meg a felső határt: "); while (felsohatar < alsohatar); printf("a tartomány: %d, %d\n",alsohatar, felsohatar); 4 for (i=alsohatar; i<=felsohatar; i++){ for (j=i+1;j<=felsohatar;j++) { if (baratsagos(i, j)==1) printf("barátságos számpár: (%d,%d)\n", i, j); printf("vizsgálat vége!\n"); Beolvassa az alsó határt Beolvassa a felső határt 32/22 Kiírja a keresési tartományt 4 Két ciklus vezérli a számokat a határok között, és minden lehetséges számpárt megvizsgál

23 Négyzetszámok Azok a számok, melyek négyzet alakúak lehetnek 32/23

24 Kövessük a kódot TXT Hány darab négyzetszám van 1 és egy beolvasott határérték között? #include <stdio.h> #include <math.h> int negyzetszam_e(int szam) { int gyok=sqrt((double)szam); if (gyok*gyok==szam) return 1; int main() { int N, i, db=0; printf("\nnégyzetszámok keresése\n"); printf("add meg a felső határt: "); scanf("%d", &N); for (i=1; i<=n; i++) if (negyzetszam_e(i)==1) db++; printf("%d darab négyzetszám van 1 és %d között\n", db, N); 32/24

25 Kövessük a kódot Hány darab négyzetszám van 1 és egy beolvasott határérték között? Írjuk ki a számokat! #include <stdio.h> #include <math.h> int negyzetszam_e(int szam) { int gyok=sqrt((double)szam); if (gyok*gyok==szam) return 1; int main() { int N, i, db=0; printf("\nnégyzetszámok keresése\n"); printf("add meg a felső határt: "); scanf("%d", &N); for (i=1; i<=n; i++) if (negyzetszam_e(i)==1) {printf("%d\n", i); db++; printf("%d darab négyzetszám van 1 és %d között\n", db, N); 32/25

26 BitMan-számok :-) 32/26

27 Kövessük a kódot #include <stdio.h> int oszt2(int szam) { if (szam%2==0) return 1; int no_oszt8(int szam) { if (szam%8==0) return 1; int szamjegy_osszeg(int szam) { if (szam==8) return 1; if(szam>=10 && szam<100) { int s=szam/10; int s2=szam-s*10; if (s+s2==8) return 1; if(szam>=100 && szam<256) { int s=szam/100; int s2=(szam-s*100)/10; int s3=szam-s*100-s2*10; if (s+s2+s3==8) return 1; 32/27 TXT BitMan-számnak nevezem ( óta, és csak én) azokat a számokat, melyek párosak, de nem oszthatók 8-al, kisebbek 2 8 értékénél, és számjegyeik összege 8.

28 Kövessük a kódot BitMan-számnak nevezzük azokat a számokat, melyek párosak, de nem oszthatók 8-al, kisebbek 2 8 értékénél, és számjegyeik összege 8. TXT int main() { int i; printf("\nbinman-számok keresése\n"); for (i=1; i<256; i++) if (oszt2(i)+no_oszt8(i)+szamjegy_osszeg(i)==3) printf("a %d BitMan-szám\n", i); 32/28

29 Összefoglalás a függvényekről A függvény egy nagyobb program forráskódjának egy része, amely egy adott feladatot hajt végre, a kód többi részétől viszonylag független egység, és többször felhasználható anélkül, hogy a program kódjának több példányban is tartalmaznia kellene. Hasonló fogalmat jelölnek a szubrutin, metódus, procedúra, eljárás vagy alprogram nevek is. Egy bizonyos gyakorlat megszerzése után: egyszerűbbé teszi a kód megírását, átláthatóbb, rövidebb kódot eredményez, könnyebben, egyszerűbben javítható kódot eredményez, a megírt függvények bármikor újra felhasználhatók más programokban. 32/29

30 Házi feladatok 1. Írja meg az egész szám négyzetre emelését megvalósító függvényt. 2. Írjon C programot, ami meghatározza egy megadott szám számjegyeinek az összegét. 3. A 4. feladat mintájára írja ki N-ig, majd az első N db, ill. az N-jegyű tükörszámokat. Tükörszám az, amelyik megegyezik a fordítottjával. 4. Az összes N-jegyű Armstrong-szám kigyűjtése. Armstrong-számnak nevezünk egy n jegyű számot, ha minden számjegyét az n-edik hatványra emelve és összeadva, az eredeti számot kapjuk. Ilyenek az egyjegyű számok és 153; 370; 371; 407; 1634; 8208; 9474; stb. 32/30

31 32/31

32 VÉGE VÉGE 32/32