Programozási tételek és C++

Hasonló dokumentumok
Programozási alapismeretek 2009/2010

Algoritmizálás + kódolás C++ nyelven és Pascalban

Maximum kiválasztás tömbben

Programozási alapismeretek :: beadandó feladat. Felhasználói dokumentáció. Molnár Tamás MOTIABT.ELTE

Programozási alapismeretek beadandó feladat: ProgAlap beadandó feladatok téma 99. feladat 1

Szerző. Varga Péter ETR azonosító: VAPQAAI.ELTE cím: Név: Kurzuskód:

Programozási alapismeretek 3. előadás

Bánsághi Anna 2014 Bánsághi Anna 1 of 68

A C++ Standard Template Library rövid összefoglalás

Bevezetés a programozásba I 10. gyakorlat. C++: alprogramok deklarációja és paraméterátadása

Programozás II. 2. gyakorlat Áttérés C-ről C++-ra

Bevezetés a programozásba. 8. Előadás: Függvények 2.

Bevezetés a programozásba I.

Szerző Lővei Péter LOPSAAI.ELTE IP-08PAEG/25 Daiki Tennó

Programozás II. 2. Dr. Iványi Péter

Tartalomjegyzék. Általános Információ! 2. Felhasználói dokumentáció! 3. Feladat! 3. Környezet! 3. Használat! 3. Bemenet! 3. Példa!

Programozási alapismeretek 1. előadás

A C programozási nyelv II. Utasítások. A függvény.

Algoritmizálás + kódolás C++ nyelven és Pascalban

Programozási alapismeretek. 1. előadás. A problémamegoldás lépései. A programkészítés folyamata. Az algoritmus fogalma. Nyelvi szintek.

Programozási nyelvek I. 5. előadás (Gregorics Tibor anyagának felhasználásával)

Bevezetés a programozásba I.

117. AA Megoldó Alfréd AA 117.

Programozás alapjai gyakorlat. 4. gyakorlat Konstansok, tömbök, stringek

Programozás C és C++ -ban

1. Alapok. Programozás II

C programozás. 6 óra Függvények, függvényszerű makrók, globális és

Programozási tételek általánosítása 2. Szlávi Péter 2015

Algoritmizálás és adatmodellezés tanítása 2. előadás

Alprogramok, paraméterátadás

Alkalmazott modul: Programozás 4. előadás. Procedurális programozás: iteratív és rekurzív alprogramok. Alprogramok. Alprogramok.

Programozás II. 4. Dr. Iványi Péter

Algoritmizálás, adatmodellezés tanítása 2. előadás

Programozás II gyakorlat. 8. Operátor túlterhelés

OOP: Java 8.Gy: Abstract osztályok, interfészek

ELEMI PROGRAMOZÁSI TÉTELEK

10. gyakorlat Tömb, mint függvény argumentum

Gregorics Tibor Tanácsok modularizált programok készítéséhez 1

Bevezetés a programozásba I.

Algoritmizálás, adatmodellezés tanítása 1. előadás

A C# programozási nyelv alapjai

Felvételi vizsga mintatételsor Informatika írásbeli vizsga

3. Osztályok II. Programozás II

Bevezetés a programozásba. 9. Előadás: Rekordok

5. Gyakorlat. struct diak {

Programozás C++ -ban

Java II. I A Java programozási nyelv alapelemei

A C programozási nyelv I. Bevezetés

Programozás alapjai II. (1. ea) C++

Programozás alapjai II. (1. ea) C++

A programozás alapjai 1 Rekurzió

A C programozási nyelv I. Bevezetés

Pénzügyi algoritmusok

Programozás C nyelven (3. ELŐADÁS) Sapientia EMTE

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

1. Template (sablon) 1.1. Függvénysablon Függvénysablon példányosítás Osztálysablon

Géptermi zh-írás forgatókönyve

Bevezetés a C++ programozásba

Programozás I. Matematikai lehetőségek Műveletek tömbökkel Egyszerű programozási tételek & gyakorlás V 1.0 OE-NIK,

STL gyakorlat C++ Izsó Tamás május 9. Izsó Tamás STL gyakorlat/ 1

PROGRAMOZÁS tantárgy. Gregorics Tibor egyetemi docens ELTE Informatikai Kar

Bevezetés a programozásba. 6. Előadás: C++ bevezető

7. fejezet: Mutatók és tömbök

Programozás. (GKxB_INTM021) Dr. Hatwágner F. Miklós március 3. Széchenyi István Egyetem, Gy r

Programozás alapjai 9.Gy: Struktúra 2.

Alkalmazott modul: Programozás 2. fejezet. C++ alapismeretek. Giachetta Roberto. Eötvös Loránd Tudományegyetem Informatikai Kar

Programozás II gyakorlat. 4. Öröklődés

9. előadás. Programozás-elmélet. Programozási tételek Elemi prog. Sorozatszámítás Eldöntés Kiválasztás Lin. keresés Megszámolás Maximum.

Programozási segédlet

Függvény pointer. Feladat: Egy tömbben soroljunk fel függvényeket, és hívjuk meg valahányszor.

Operációs rendszerek. 11. gyakorlat. AWK - szintaxis, vezérlési szerkezetek UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED

Függvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)

Bevezetés a C++ programozási nyelvbe

Programozás I. Egyszerű programozási tételek. Sergyán Szabolcs

Programozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)

Bevezetés a programozásba 2

Bevezetés a programozásba. 11. Előadás: Esettanulmány

6. fejezet: Ciklusok

A feladat lényege egy felhasználói típusnak a zsák típusnak a megvalósítása.

500. CC Megoldó Alfréd CC 500.

C programozás. 1 óra Bevezetés

Gregorics Tibor Modularizált programok C++ nyelvi elemei 1

Objektumorientált Programozás VI.

hiányzott szeptemberben vagy A tanuló nem hiányzott szeptemberben szöveget

Statikus adattagok. Statikus adattag inicializálása. Speciális adattagok és tagfüggvények. Általános Informatikai Tanszék

4. Öröklődés. Programozás II

5. gyakorlat. Konstansok Tömbök Stringek

500. AA Megoldó Alfréd AA 500.

1. Jelölje meg az összes igaz állítást a következők közül!

Programozás I. Egyszerű programozási tételek. Sergyán Szabolcs

1. Írjunk programot mely beolvas két egész számot és kinyomtatja az összegüket.

Makrózás gyakorlat (GYAKORLAT)

Szerző. Természetesen aktualizálandó adatok.

0.1. Mi az a standard be- és kimenet? A két mintafeladat leírása

128. AA Megoldó Alfréd AA 128.

Bánsághi Anna 2014 Bánsághi Anna 1 of 33

2. Rekurzió. = 2P2(n,n) 2 < 2P2(n,n) 1

Programozás C- és Matlab nyelven C programozás kurzus BMEKOKAM603 Előfeldolgozó rendszer Tömbök. Dr. Bécsi Tamás 4. Előadás

1. Alapfogalmak Algoritmus Számítási probléma Specifikáció Algoritmusok futási ideje

Algoritmizálás és adatmodellezés tanítása 1. előadás

Átírás:

Programozási tételek és C++ Alábbiakban néhány kódolást könnyítő lehetőségét nézzük meg a a C++ nyelvnek. Elsősorban a programozási tételek kódolására gondolunk. A hagyományos kódolással kezdjük, amely a továbbiak alapja lesz. Ez szolgál kiinduló pontként a további kódolásrövidítő módszereknek: makróra építőnek és a tételeket függvényként implementálónak. Példaként a (lineáris) keresés tételt nézzük. Vázlat Specifikáció 1 a szokásos részletezésű specifikáció Specifikáció 2 a függvénnyel tömörített utófeltételű specifikáció Algoritmus Kód 1 normál kódolás Kód 2 makrós kódolás Kód 3 függvényes kódolás Tételalkalmazások Kifejtés Specifikáció1 Keresés Bemenet: N:Egész, X:Tömb[1..N:Valami] Kimenet: Van:Logikai, Ind:Egész Előfeltétel: N 0 Utófeltétel: Van= i (1 i N): T(X[i]) és Van 1 Ind N és T(X[Ind]) Specifikáció2 Keresés Utófeltétel: (Van,Ind)=VanÉsInd(1..N,X[ ],T( )) Definíció: VanÉsInd:Egész 2 Valami * (Valami Logikai) Logikai Egész VanÉsInd(e..v,x[ ],t( )):=(van,ind): van= i(e i v): t(x[i]) és van e ind v és t(x[ind]) Algoritmus Keresés

Programozási tételek és a C++ Kód1 normál kódolás Keresés A programparamétereknek a specifikáció bemeneti és kimeneti részei alapján az alábbi deklarációkat feleltetjük meg: //Bemeneti paraméterek: int N; const int maxn=100; valami X[maxN]; //Kimeneti paraméterek: bool Van; int Ind; //Tulajdonságfüggvény prototípusa: bool T(valami x); A lényegi rész kódját az algoritmusból származtatjuk, a természetes kódolási szabályokkal: //a lokális ciklusváltozó a tárolt 0-indexű elemnél kezdi int i=0; while (i<n &&!T(X[i])) ++i; Van=i<N; if (Van) Ind=i; Kód2 makrós kódolás Keresés Alapgondolat: minden tételnek megfeleltetünk egy makrót, amely kifejtését mint mechanikusan alkalmazandó átírási szabályt rábízzuk a preprocesszorra. E módszernek talán az a legfontosabb mondani valója, hogy a programozási folyamatban a tételek kóddá alakítása valóban mechanikusan elvégezhető feladat. A makródefiníció egyetlen sorból áll, és az alábbi szintaxisú: #define makrónév [ paraméterlista ] törzs ahol makrónév egy alfanumerikus jelsorozat paraméterlista kerek zárójelek közé írt, vesszővel elválasztott paraméter-sorozat paraméter egy definíción belül unikális alfanumerikus jelsorozat törzs jelsorozat, amelyben felbukkannak a paraméter-ek A [ ] között rész elmaradhat. A mi céljaink eléréséhez mindig kellenek paraméterek. A makróhívás egyszerűen a makrónév kiegészítve a konkrétan behelyettesítendő paraméterlista-val, természetesen ha van egyáltalán paramétere. Íme, a keresés tétel Kód 1 -beli kódolás mintáját követő változata. Nincs sortörés, most csak nyomdatechnikai okok miatt, és a könnyebb olvashatóság érdekében tagoltuk sorokra: #define VanEsInd(cv,e,v,felt,van,ind) cv=e; while(cv<=v &&!(felt)) ++cv; van=cv<=v; if(van) ind=cv; 1Def 2

Megjegyzések a fenti definícióhoz: Szlávi Péter 1. A makró definiálásánál a Specifikáció 2 -ban előforduló függvény szolgál ötletadóul. 2. Látható, hogy a paraméterek között az algoritmus kimeneti változói is felbukkannak; azaz a kiindulópontul szolgáló függvénytől eltérően nem függvényként definiáljuk a makrót, ami persze nem is meglepő, hiszen a majdani hívásnál nem lesz módunk függvényként alkalmazni. Valóban mechanikus kódbehelyettesítésként fog működni. 3. A felt paraméter a sorozat és a tulajdonság szerepét egyszerre tölti be; ez egy formális szimbólum, amely lehetővé teszi, hogy helyére tetszőleges logikai formulát (akár tulajdonságfüggvényt aktuális paraméterestül) illeszthessünk. 4. A látszólag fölösleges ciklusváltozó azért kell, mert a bemeneti paramétereket jelentő konkrét formulákban (pl. tömbelemben) ennek szerepelni kell. Egy hívási példával világítjuk meg a fentieket: VanEsInd(i,0,N-1,T(X[i]),Van,Ind) Ezt az alábbi kóddal helyettesíti a preprocesszor (persze egyetlen sorban): i=0; while(i<=n-1 &&!(T(X[i]))) ++i; Van=i<=N-1; if(van) Ind=i; Ezt összevetve a Kód 1 -ben szereplő kóddal, elégedettek lehetünk. Ha közelíteni akarjuk a specifikációbeli definícióhoz, akkor az alábbi módon is definiálhatjuk a makrót (piros a különbség): #define VanEsInd(cv,e,v,x,t,van,ind) cv=e; while(cv<=v &&!t(x[cv])) ++cv; van=cv<=v; if(van) ind=cv; Ennek hívása az alábbi lenne: VanEsInd(i,0,N-1,X,T,Van,Ind) Hogy ugyanazt a kódot kapnánk a kifejtés után, az nyilvánvaló. Az alkalmazás rugalmasságát tekintve azonban az első megoldás előnyösebb. Ugyanis ez megengedi az alábbi közvetlen kifejezést tartalmazó hívást is, amíg a második értelemszerűen nem: VanEsInd(i,0,N-1,X[i]%2==0,Van,Ind) Ez viszont nem működik: VanEsInd(i,0,N-1,X,X[i]%2==0,Van,Ind) 1Hiv 1Kif 2Def 2Hiv 1Hiv2 2Hiv2 Ugyanis a mechanikus behelyettesítés során az alábbi C++ nyelvbeli non sence kódot kapnánk: i=0; while(i<=n-1 &&!(X[i]%2==0(X[i])) ++i; Van=i<=N-1; if(van) Ind=i; 2Kif2 Második példaként a keresés index helyett érteket visszaadó változatát definiáljuk: az eredményt az Ert változó tartalmazza. Ebben a változatban a sorozat elemei nem csak a 3

Programozási tételek és a C++ tulajdonság függvényben bukkannak föl, ezért egy őket megtestesítő paramétert is szerepeltetni kell: #define VanEsErt(cv,e,v,sorelem,felt,van,ert) cv=e; while(cv<=v &&!(felt)) ++cv; van=cv<=v; if(van) ert=sorelem; Egy hívási példa, amely az első valódi osztóját keresi az N-nek: int oszto; bool oszthatoe; VanEsErt(i,2,sqrt(N),i,N%i==0,oszthatoE,oszto) Egy másik hívási példa, amely egy olyan értékét keresi meg a tömbnek, amelyet követő tömbelem 2-vel nagyobb nála: int Szam[10]; bool Van; int Ert; //a Szam tömb feltöltése VanEsErt(i,1,9,Szam[i],Szam[i+1]-Szam[i+1]==2,Van,Ert) Kód3 függvényes kódolás Keresés A függvény-alapú megoldásnál a tételeket valódi C++ függvényként kell implementálni. Itt a nehézséget maga a nyelv okozza, nem a preprocesszor képességei. Két problémára kell gyógyírt találni: 1. Az olyan tételeknél, amelyek valamilyen függvényre építenek (elsősorban a tulajdonság függvényre gondolunk), elegáns lenne, ha a tételfüggvény a kellő függvényt paraméterként venné át. 2. A konkrét feladatokban az érintett tételeket más és más típusú adatszerkezetekre kell alkalmazni. Ez azt jelenti, hogy ugyanaz a tételparaméter más és más típusúként kellene deklarálni, vagyis a típussal való paraméterezést is meg kell oldani. Megoldás: 1. Korlátozzuk vizsgálatunkat csupán a tulajdonság függvényekre! Az alapötlet az, hogy a függvényparaméter a függvény kezdőcímének átvételét jelentse. Természetesen megállapodunk abban, hogy a kezdőcím valamely konkrét szignatúrájú függvényekhez tartozik. bool (*bool2tip)(tip x) ez a bool2tip nevű függvény(paraméter) címét jelenti, ahol a tip helyére valamely konkrét típus képzelendő. Alább éppen azt fogjuk leírni, hogy miként kerülhet ide kódismétlés nélkül tetszőleges típus. 2. A típussal paraméterezést sablondefiniálással oldhatjuk meg: template<class tip> fejsor Itt a template kulcs-szó jelzi a sablondefiníció kezdetét. A <class tip> arra utal, hogy egy típus (pontosabban egy osztály, ami típus általánosítása) lesz a sablon paramétere, amelyre a tip formális névvel fogunk hivatkozni. A fejsor helyére egy függvény szokásos fejsora írandó, amelyben azonban és éppen ez a különlegesség szerepelhet valamely típus helyett a tip formális típusparaméter. Példa: template<class tip> tip Szumma(int tol, int ig, const tip t[]); 3Def 3Hiv 3Hiv 4

és egy másik: Szlávi Péter template<class tip> bool VanE(int tol, int ig, const tip t[], bool (*tulfv)(tip e)); Az első példa az összegzés tétel általánosított függvényének prototípusa. 3. paramétere egy tip típusú elemekből álló tömb, amelynek t[i] i=tol..ig elemeire vonatkozik az általánosított összegzés. A számítás eredménye is tip típusú. A függvény definíciója az alábbi: template<class T> T Szumma(int tol, int ig, const T t[]) T s=0; for (int i=tol;i<=ig;++i) s+=t[i]; return s; A második példa az eldöntés tétel egyik alakjának a prototípusa. Magyarázatra csupán az utolsó paramétere szorul: ez a tulajdonság függvény címét jelentő formális paraméter, amely függvény szignatúrája az alábbi: tulfv: tip bool Ilyen függvények lehetnek az alábbiak: bool paros(int n) return n%2==0; A függvény definíciója az alábbi: bool nemuresszoveg(string s) return s> ; template<class T> bool VanE(int tol, int ig, const T t[], bool (*tulfv)(t e)) int i=tol; while (i<=ig &&!tulfv(t[i])) ++i; return i<=ig; Tételalkalmazások Egy komplett programmal mutatjuk be a makró-alapú tételalkalmazásokat. Vannak sorok, amelyek hosszúk miatt eltörtek. Hogy ez ne okozzon gondot, a folytatás-sorokat egy sor előtti vonallal megjelöltük. //Szlávi Péter //SZPKAFT.ELTE //szlavip@elte.hu //FELADAT: // Algoritmusrövidítő makrók a programozásban. #include <iostream> #include <stdlib.h>//system-hez 5

Programozási tételek és a C++ #include <math.h>//sqrt-hez using namespace std; //algoritmus-minták makrókkal (ahol a parameter képlet is lehet, //ott célszerű zárójelezetten beilleszteni): #define ForCiklus(cv,tol,ig) for(int cv=(tol);cv<=(ig);++cv) /*ciklusmag nélkül!!!*/ #define SorozatKi(cv,tol,ig,sorozatElem) for(int cv=(tol);cv<=(ig);++cv) cout<<cv<<".:"<<sorozatelem<<endl; #define Hany(cv,tol,ig,felt,db) db=0; ForCiklus(cv,tol,ig) if(felt) ++db; #define Szumma(cv,tol,ig,sorozatElem,osszeg) osszeg=0; ForCiklus(cv,tol,ig) osszeg+=sorozatelem; #define VanE(cv,tol,ig,felt,van) cv=(tol); while(cv<=(ig) &&!(felt)) ++cv; van=cv<=(ig); #define MelyInd(ind,tol,felt) ind=(tol); while(!(felt)) ++ind; #define VanEsInd(cv,tol,ig,felt,van,ind) cv=tol; while(cv<=ig &&!(felt)) ++cv; van=cv<=ig; if(van) ind=cv; #define VanEsErt(cv,e,v,sorElem,felt,van,ert) cv=e; while(cv<=v &&!(felt)) ++cv; van=cv<=v; if(van) ert=sorelem; #define MaxInd(cv,tol,ig,tomb,mxI) mxi=tol; ForCiklus(cv,tol+1,ig) if(tomb[cv]>tomb[mxi]) mxi=cv; #define MinInd(cv,tol,ig,tomb,mnI) mni=tol; ForCiklus(cv,tol+1,ig) if(tomb[cv]<tomb[mni]) mni=cv; #define MnxInd(cv,tol,ig,tomb,r,mI) mi=tol; ForCiklus(cv,tol+1,ig) if(tomb[cv] r tomb[mi]) mi=cv; #define cout << endl; system("pause"); #define system("cls"); int main() cout << "'FORCIKLUS' makro: --------------------------------------------" << endl; cout << "ForCiklus(i,1,5) cout<<i<<endl;:" << endl; ForCiklus(i,1,5) cout << i << endl; cout << "'SorozatKi' makro: --------------------------------------------" << endl; const int HoHossz[12]=31,28,31,30,31,30,31,31,30,31,30,31; cout << "HoHossz[0..11]:" << endl; SorozatKi(i,0,11,HoHossz[i]) cout << "HoHossz[1..12]:" << endl; SorozatKi(i,1,12,HoHossz[i-1]) cout << "'Hany' makro: -----------------------------------------------" << endl; int db; Hany(i,0,11,HoHossz[i]>30,db) cout << "Hany HoHossz[0..11]>30? Darab=" << db << endl; Hany(i,0,11,HoHossz[i]==30,db) cout << "Hany HoHossz[0..11]=30? Darab=" << db << endl; Hany(i,0,11,HoHossz[i]<30,db) cout << "Hany HoHossz[0..11]<30? Darab=" << db << endl; cout << "'Szumma' makro: ---------------------------------------------" << endl; int ossz; Szumma(i,1,5,i,ossz) cout << "Szumma(1..5)=" << ossz << endl; Szumma(i,1,12,HoHossz[i-1],ossz) cout << "Szumma(HoHossz[1..12])=" << ossz << endl; cout << "'VanE' makro: ----------------------------------------------" << endl; ForCiklus(N,2,7) int i; bool oszthatoe; VanE(i,2,N/2,N%i==0,oszthatoE) cout << N << " prim-e: "; if(oszthatoe) 2

Szlávi Péter cout << "nem "; cout << "prim." << endl; cout << "'MelyInd' makro: -------------------------------------------" << endl; ForCiklus(N,2,7) int oszto; MelyInd(oszto,2,N%oszto==0) cout << "LKO(" << N << ")= " << oszto << endl; cout << "'VanEsInd' makro: -------------------------------------------" << endl; ForCiklus(N,17,25) int i,oszto; bool oszthatoe; VanEsInd(i,2,sqrt(N),N%i==0,oszthatoE,oszto) cout << N << " oszthato-e: "; if(oszthatoe) cout << "igen; LKO(" << N << ")= " << oszto << "." << endl; else cout << "nem." << endl; cout << "'VanEsErt' makro: -------------------------------------------" << endl; ForCiklus(N,1,4) int i,hanynapos; bool vane; VanEsErt(i,1,11,HoHossz[i],HoHossz[i+1]-HoHossz[i]==N,vanE,hanyNapos) cout << "Van-e olyan ho, amelyet kovetonek " << N << " nappal tobb napja van:"; if(vane) cout << "igen; megpedig a " << hanynapos << "." << endl; else cout << "nincs." << endl; cout << "'MaxInd/MinInd' makro: -----------------------------------------" << endl; int maxi; MaxInd(i,0,11,HoHossz,maxI) cout << "MaxInd(HoHossz[1..12])=" << maxi+1 << ", "; cout << HoHossz[maxI] << " napos." << endl; int mini; MinInd(i,0,11,HoHossz,minI) cout << "MinInd(HoHossz[1..12])=" << mini+1 << ", "; cout << HoHossz[minI] << " napos." << endl; MnxInd(i,0,11,HoHossz,<,minI) cout << "MnxInd(HoHossz[1..12],<)=" << mini+1 << ", "; cout << HoHossz[minI] << " napos." << endl; return 0; Egy komplett programmal mutatjuk be a függvény-alapú tételalkalmazásokat. //Szlávi Péter //SZPKAFT.ELTE //szlavip@elte.hu //FELADAT: // Függvények, függvénytípus, függvény mint paraméter. 3

Programozási tételek és a C++ #include <iostream> #include <stdlib.h>//az exit-hez, a 10.05-höz using namespace std; //Tulajdonság függvények: -------------------------------------------------------------- --- bool parose(int n); //paros:int->bool konkrét függvény template<class T> bool _10nelNagyobbE(T n);//_10nelnagyobbe:t->bool sablon függvény bool nagykezdetue(string s); //nagykezdetue:string->bool konkrét függvény //beolvasás: template<class T> void be(string kerd, T &e, bool (*tulfv)(t e),string hibauzenet); //tételfüggvények: template<class T> T Szumma(int tol, int ig, const T t[]); template<class T> bool VanE(int tol, int ig, const T t[], bool (*tulfv)(t e)); int main() //beolvasás: int m; be("kerek egy paros egeszet:", m, parose, "Ez nem paros egesz! Kerem ujra!"); be("kerek egy 10-nel nagyobb egeszet:", m, _10nelNagyobbE, "Ez nem 10-nel nagyobb egesz! Kerem ujra!"); double x; be("kerek egy 10-nel nagyobb valosat:", m, _10nelNagyobbE, "Ez nem 10-nel nagyobb valos! Kerem ujra!"); string szo;//az inputnak csak az elsö szavát tudjuk beolvasni alább! be("kerek egy szot nagybetuvel kezdve:", szo, nagykezdetue, "Ez nem nagybetuvel kezdodo szo! Kerem ujra!"); //tételfüggvények: const int egeszek[]=1,3,5,7,9,8,6,4,2; const int N=(sizeof egeszek)/sizeof(int); cout << "Az egeszek osszege:" << Szumma(0,N-1,egeszek) << endl; cout << "Az egeszek kozott "; if (!VanE(0,N-1,egeszek,parosE)) cout << "nem "; cout << "talalhato paros." << endl; cout << "Az egeszek kozott "; if (!VanE(0,N-1,egeszek,_10nelNagyobbE)) cout << "nem "; cout << "talalhato 10-nel nagyobb." << endl; return 0; bool parose(int n)//paros:int->bool konkrét függvény return (n%2==0); template<class T> bool _10nelNagyobbE(T n)//_10nelnagyobbe:t->bool konkrét függvény return n>10; bool nagykezdetue(string s)//nagykezdetue:string->bool konkrét függvény return s.length()>0 && isupper(s.at(0)); template<class T> T Szumma(int tol, int ig, const T t[]) T s=0; for (int i=tol;i<=ig;++i) s+=t[i]; return s; 2

Szlávi Péter template<class T> bool VanE(int tol, int ig, const T t[], bool (*tulfv)(t e)) int i=tol; while (i<=ig &&!tulfv(t[i])) ++i; return i<=ig; template<class T> void be(string kerd, T &e, bool (*tulfv)(t e),string hibauzenet) bool hiba; string tmp; do cout << kerd; cin >> e; hiba=cin.fail()!tulfv(e); if(hiba) cout << hibauzenet << endl; cin.clear(); getline(cin,tmp,''); while(hiba); 3