Fájlkezelés Programozási tételek

Az előadások a következő témára: "Fájlkezelés Programozási tételek"— Előadás másolata:

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

2 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();

3 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

4 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;

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

6 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

7 Ö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

8 Ö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; }

9 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.

10 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; }

11 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)

12 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;

13 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}

14 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); }

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

16 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.

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

18 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; }

19 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.

20 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; }

21 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)

22 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

23 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; }

24 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; }

25 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...

26 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; }

27 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.

28 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

29 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!!!)

30 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!

31 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)

32 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)