Oszd meg!

Add a Twitter-hez Add a Facebook-hoz Add a Startlaphoz Add az iWiW-hez Add a Google Reader-hez

Közösség

Belépés

E-mail cím:
Jelszó:

Karakterláncok kezelése (string típusú változók)

Karakterláncok kezelése (string típusú változók)

A Turbo Pascal külön figyelmet fordít a szövegek megadására, feldolgozására és tárolására. A különféle programozási nyelvekben a szövegeket karaktersorozatnak (stringnek) nevezik.

A szövegkonstanst (sztringkonstanst) egyszeres idézőjelek, aposztrófok (‘) között kell megadni. Ha szövegen belül aposztróf szerepel, akkor azt duplázni kell (például ‘Rock’’n’’roll’) – de nincs kezdő és záró felsővessző a Pascalban. Ha a sztring semmit sem tartalmaz az aposztrófok között (‘’), akkor úgynevezett üres sztringről beszélünk. A sztring hossza az aposztrófok között megadott karakterek számának felel meg. Az üres string hossza értelemszerűen 0.

     A string típusú változókba szöveget tárolhatunk, olvashatunk be. Az adat bilentyűzetről történő beírása során nem kell az idézőjelet használni. Az ilyen változó maximális hossza 255 karakter. De ahogy láttuk helytakarékossági okból kisebb maximális méretet is megadhatunk. A maximális hossz megadását a string típusnév utáni [] zárójelbe tett szám jelzi. A változó ténylegesen ettől eggyel több bájtot foglal el. A legelöl található 0 sorszámmal jelölt bájton a változó tényleges, aktuális hossza található. Az aktuális hosszt a program kezeli tartja karban, ebbe nem nagyon szoktunk belenyúlni.

Var   veznev:string[25];

         kernev:string[15];

 

Ha a veznev és kernev fel van töltve, abban maximum a megadott hosszúságú név szerepelhet, ha ettől hosszabbat viszünk be a bekéréskor, akkor a vége csonkolódik.

 

Módunk van a programban hivatkozni a string típusú változó adott sorszámú helyen álló elemére. Például az előző változókkal a monogram: veznev[1] + kernev[1] lesz.

Feladat: Készítsünk programot, amely beolvas egy mondatot, majd kiírja hány karakterből áll a mondat.

Megoldás: A feladat megoldásához bevezetünk egy s változót, melynek típusa string. Beolvasás után ennek a változónak a hosszát a length() függvénnyel kapjuk meg. Programunk így néz ki:

program Pelda16;
var s:string;
begin
 write('Irj be egy mondatot: ');
 ReadLn(s);
 WriteLn('A mondat hossza: ',length(s),' karakret.');
end.

Feladat: Készítsünk programot, amely beolvas egy legfeljebb 100 betűs mondatot, majd kiírja a mondatot nagy betűkkel.

Megoldás: A feladat megoldásához bevezetünk egy s változót, melynek típusa string[100]. Beolvasás után a mondat minden egyes karakterét egy cikluson belül megváltoztatjuk nagy betűre. Az s változóban levő mondat első betűjét az s[1] adja meg, második betűjét az s[2] adja meg, stb. Egy karaktert nagy betűre az upcase() függvény segítségével változtathatunk meg. Programunk így néz ki:

program Pelda17;
var s:string[100]; {legfeljebb 100 karakter tárolása lehet}
    i:byte;
begin
 write('Irj be egy legfeljebb 100 betűs mondatot: ');
 ReadLn(s);
 for i:=1 to length(s) do 
begin
  s[i]:=upcase(s[i]);
end;
 WriteLn(s);
end.

Gondolkodtató feladat: Mi történik, ha egy szov:string nevű új változóba írjuk át az adatokat szov[1]:=upcase(s[1]) módon, és nem felülírjuk az eredeti változó tartalmát? Oldjuk meg helyesen az új változóba való átírást!

Feladat: Készítsünk programot, amely kiírja a karaktereket ASCII kódjuk ismeretében a 32-es kódtól (helyköz) a 255-ös kódig.

Megoldás: Ha tudjuk egy karakter ASCII kódját, a karaktert a chr() függvénnyel tudjuk kiíratni. Programunk így néz ki:

program Pelda18;
var i:integer;
begin
 for i:=32 to 255 do
   begin
      write(i:6);
      write(chr(i):2);
   end;
end.

Ha egy karakternek szeretnénk megtudni, hogy mi az ASCII kódja, akkor azt az ord() függvénnyel határozhatjuk meg. Pl. ord('A') értéke 65, mivel az A betű ASCII kódja 65. Az ord() függvény ellentettje a chr() függvénynek,de attól általánosabb.

A karakterek ASCII kódját és az említett két függvényt fogjuk kihasználni olyan programok készítésénél, ahol a programunkat a billentyűzet segítségével fogjuk irányítani (pl. nyilak segítségével játékprogramnál).

Elemezzük a szöveges változókra érvényes műveleteket, függvényeket és eljárásokat.

 A következőkben olyan programokat szeretnénk írni, amelyek szöveges változókat is kezelnek. A szöveges változókkal végezhető műveleteket és eljárásokat mutatja be a Szoveg nevű program (nem mindet):

Program Szoveg;

Uses  Crt;

Var A,B,C,D: String;

    n,i: Byte;

Begin

  ClrScr;

  A:= 'alma';

  B:= 'fa';

  C:= a+b;

  WriteLn(C);

  n:= Length(C);

  WriteLn(n);

  D:= Copy(C,2,3);

  WriteLn(D);

   WriteLn(Pos('ma',C));

  Delete(C,2,2);

  WriteLn(C);

  ReadLn;

End.

 

Szöveges változók között csak egyetlen művelet létezik, az összeadás, mely a két szöveg egymás után helyezését jelenti (konkatenáció). A Length függvény a szöveges változó hosszát adja vissza. A Copy függvény első paramétere egy szöveg, melyből a második paramétertől kezdődően, a harmadik paraméter hosszban másolatot készít. A String úgy tárolódik, hogy a nulladik karakterének kódja a String hosszát jelenti. Az Ord függvény a karakter sorszámát adja vissza (a Chr függvény fordítottja), azaz az ASCII kódtábla béli kódjának tízes számrendszerben kifejezett értékét. Az Insert eljárás első paraméterét, a második paraméterként megadott szövegbe, a harmadik paraméterben megadott helytől kezdve beszúrja. A Pos függvény az első paraméterként megadott szöveg helyét keresi a második paraméterként megadott szövegben. Visszaadott értéke a keresett szöveg első karakterének helye, ha ez 0, akkor a keresett szöveget nem találta. A Delete eljárás, az első paraméterként megadott szövegből, a második paraméterben megadott helytől kezdődően, a harmadik paraméterben megadott számú karaktert töröl. A fentiek szabványos leírása itt található, a tartalomból ki kell választani a keresett eljárást, függvényt, a rámutatás után az újabb link mutat a megfelelő helyre! Az eljárások, függvények a tartalomban betűrendbe szedve találhatók.

Feladat: Egy szöveges változó két elemének cseréjét oldjuk meg az alkalmas függvények és eljárások segítségével. (Tehát nem lehet a következő a megoldás: s:=szöv[j] ; szöv[j]:=szöv[i]; szöv[i]:=s!)