Fájlkezelés Programozási tételek C++ alapok, második óra Fájlkezelés Programozási tételek

Fájlkezelés Kell: „#include <fstream>” Input és output fájl külön típus: ifstream f1; //inputfájl ofstream f2; //outputfájl Mindkét esetben meg kell nyitni a fájlt a munka előtt és be kell zárni utána: f.open(fájlnév); //a fájlnév char* !!! f.close();

Ellenőrzés&olvasás f.fail() -> megadja hogy sikeres volt-e a megnyitás Olvasás: if >> x; //x egy változó Kiírás: of << x << ‘’alma‘’; Sor kiolvasása: getline(if,str,’\n’); Fájl vége: f.eof() -> true, ha vége

Egyszerű példa Legyen az input.txt fájl tartalma egész számok sorozata, vegyük ki őket és a négyzetüket írjuk bele az output.txt nevű fájlba! #include <fstream> using namespace std; int main() { ifstream inp(‘’input.txt‘’); //így automatikusan openel is if(inp.fail()) { cout << ‘’HIBA\n‘’; return 1;} ofstream myfile; myfile.open(‘’output.txt‘’); if(myfile.fail()) {cout << ‘’HIBA\n‘’; inp.close(); return 2;} while(!inp.eof()) int x;

Példa folytatása... inp >> x; myfile << x*x << endl; } myfile.close(); inp.close(); return 0;

Programozási tételek Egyszerű feladatok és megoldásaik Összegzési tétel Megszámlálási tétel Maximumkeresés Feltételes maximumkeresés Lineáris keresés Lineáris keresés intervallumon Rekurzív függvény kiszámítása

Összegzés tétele f(i) i=n..m Feladat: adott n,m egész számok, amelyekre teljesül, hogy n<=m. Valamint adott egy f:[n,m]  Z függvény – itt Z helyén bármi állhat, a lényeg, hogy legyen rajta összeadás és az asszociatív legyen. A feladat a függvény [n,m]-en felvett értékeinek szummázása. f(i) i=n..m

Összegzés tétele 2 Megoldás: int n,m; //adott számok int s; //ebbe állítjuk elő az eredményt int k; //az index, ami befutja az intervallumot s=0; k=n-1; while(k<m) { s=s+f(k+1); k=k+1; }

Megszámlálás tétele Feladat: n,m adott egészek; n<=m. A feladat megszámolni hány [n,m]-beli számra lesz igaz egy :[n,m]{igaz,hamis} logikai függvény. Ez tulajdonképpen visszavezethető az összegzésre: legyen :{i,h}  {0,1} olyan függvény, hogy (i)=1 és (h)=0. Ekkor a feladat tulajdonképpen az f= függvény összegzése az [n,m] intervallumon.

Megszámlálás tétele 2 Megoldás: int n,m; //adottak előre int k,s; s=0; k=n-1; while(k<m) { if(beta(k+1)) s=s+1; k=k+1; }

Maximumkeresés tétele Feladat: Adott f:[n,m]  R függvény maximumát keressük. (n<=m) (R helyett természetesen bármilyen teljesen rendezett halmazt is vehetünk)

Maximumkeresés tétele 2 Megoldás: int n,m; //adottak int i; //a maximum hely float max; //a maximum int k; k=n; i=n; max=f(n); while(k<m) { if(f(k+1)>max) i=k+1; max=f(k+1); } k=k+1;

Feltételes maximumkeresés Feladat: f:[n,m]  R :[n,m]  {igaz,hamis} A feladat f-et maximalizálni a  igazhalmazán. Azaz a következő kiszámítása: max{f(i)| (i) és n<=i<=m}

Feltmaxker 2 Megoldás: int n,m; //adottak bool l; //találtunk-e megoldást int i; float max; //a max helye és értéke int k; k=n-1; l=false; while(k<m) { if((k+1)) if(!l) l=true; i=k+1; max=f(k+1); }

Feltmaxker 3 else if(f(k+1)>max) { i=k+1; max=f(k+1); } k=k+1;

Lineáris keresés Feladat: Adott N{igaz,hamis} feltétel és i index. Keressük azt a legkisebb j indexet, ami nemkisebb i-nél és kielégíti -át. A feladat előfeltétele, hogy létezik ilyen j.

Lineáris keresés 2 Megoldás: int n; //adott int i; i=n; while(!(i)) { }

Lineáris keresés 3 A  kitranszformálható a ciklusfeltételből a következőféleképpen: int n; //adott int i; bool l; i=n-1; l=false; while(!l) { l=(i+1); i=i+1; }

Lineáris keresés intervallumon Feladat: mint az előbb, csak annyi a különbség, hogy egy adott m indexnél nemnagyobb megoldást keresünk. Ekkor persze előfordulhat, hogy nem járunk sikerrel és nem találunk ilyen j indexet.

Lineáris keresés intervallumon 2 Megoldás: int n,m; //adottak int i; bool l; i=n-1; l=false; while(i<m&&!l) { l= (i+1); i=i+1; }

Rekurzív függvény helyettesítési értéke Feladat: Adott f rekurzív függvény a következő módon: Adott f(-k+1),...,f(0) jelöljük t(index)-szel ezeket az elemeket. Azaz adott f értéke az első k helyen. Adott F k+1 változós függvény, amivel kiszámolható a többi helyettesítési érték: f(i+1)=F(i,f(i),f(i-1),...,f(i-k+1)) (ha i>=0)

Rekurzív függvény 2 Megoldás: //változók: int n; //adott n>=0, célunk f(n) meghatározása //<k> előre adott, mindenütt a konkrét számot írjuk //<t(j)> ez is előre adott, j=-k+1...0 int y[<k>]; //ha k=1, akkor nem is kell tömböt használni //ebben fogjuk a megelőző értékeket tárolni //y[0] a legnagyobb kiszámított érték, y[1] az azelőtti, stb. int i; //index //minden lépésben y[0]-ba f(i)-t próbáljuk kiszámítani

Rekurzív függvény 3 i=0; y[0]=t(0); y[1]=t(-1); ... y[k-1]=t(-k+1); while(i!=n) { int seged= F(i+1,y[0],...,y[k-1]); //k=1 esetén nem kell y[1]=y[0]; ... y[k-1]=y[k-2]; //ezt lehetett volna for ciklussal is y[0]=seged; i=i+1; }

Példa (k=1) Feladat: 5 faktorálisának kiszámítása. f(i+1)=(i+1)*f(i); n=5 int i,y; i=0; y=1; while(i!=5) { y=(i+1)*y; i=i+1; }

Példa (k=2) Feladat: Adott egy n(>=1) szám. Keressük az n-edik Fibonacci számot. F(0)=0, F(1)=1 és F(i+1)=F(i)+F(i-1) ha i>1 (most F-fel jelöltem a tételbeli f-et) Megjegyzés: Most sem kell feltétlenül tömböt használni Elcsúsztatjuk az indexeket (-1,0 helyett 0,1 adottak) Ha n lehet 0 is, azt le kell kezelni külön...

Fibonacci számok int n; //adott int i, y, y1; i=1; y=1; //F(1) while(i!=n) { int seged=y+y1; y1=y; y=seged; i=i+1; }

Típustranszformációk f:[0..m]Z függvény helyett int t[m] tömb. Ekkor f(i) helyére mindenütt t[i]-t kell írnunk. Persze például összegezhetünk egy G:Z Z függvényt a t tömbön is. Ekkor f(i) helyére G(t[i])-t írunk. Tömb helyett vegyük az elemeket egy fájlból. Ekkor i<m helyére !fajl.eof() kerül ha a fájl végéig olvasunk és t[i] helyett kiolvasunk egy elemet egy j változóba és azt használjuk fel.

Feladatok Fájlkezelés: Olvassunk be az inputról egy 10 elemű egészekből álló tömböt, majd írjuk ki a tartalmát a képernyőre! Adott egy input.txt fájl, ami egészeket tartalmaz. Válogassuk szét őket a paritásuk szerint egy ps.txt és egy ptlan.txt nevű fájlba

Feladatok 2 Összegzés: Számítsuk ki a [-5,10] intervallumon a számok negyedik hatványának az összegét! Számítsuk ki egy 10 elemű tömb elemeinek a négyzetösszegét! *Adott fájlból olvassunk be 10 elemet és számoljuk ki a szorzatukat. (itt most szorzunk összeadás helyett!!!)

Feladatok 3 Megszámlálás: Számoljuk meg, hogy a [-100,50] intervallumon hány olyan egész van, ami páros és vagy héttel vagy kilenccel osztható! Számoljuk meg, hogy egy 10 elemű tömb elemei közül hány ad 5-öt maradékul 7-tel osztva. A tömböt kérjük be a billentyűzetről!

Feladatok 4 Maximumkeresés: Keressük meg annak az f-nek a maximumát a [0,100] intervallumon, amit így is felírhatunk: f(i)=(i mod 11) * (i mod 9)! Keressük meg, hogy egy 10 elemű tömb elemei közül melyik adja a legtöbb maradékot nyolccal osztva! *Keressük meg f(i)=((i-1)^2)/i^3 valósértékű függvény minimumát az [1..25] intervallumon! (i egész)

Feladatok 5 Lineáris keresés&linker intervallumon: Keressük meg az 1345 utáni első 245-tel osztható számot! Keressük meg az első 7-tel vagy 9-cel osztható számot az [n,m] intervallumon. n és m-et az exe paraméterként kapja. Keressük meg egy 10 elemű tömb első 7-tel osztható elemét (ha van egyáltalán ilyen)