Első program A programok megírása előtt már célszerű elmenteni a programunkat, ugyanis a mentéskor meghatározott kiterjesztés meghatározza, hogy milyen nyelven íródott a program. Amikor elkezdjük a programot beírni, már automatikusan zajlik egy helyesírás ellenőrzés és színekkel jelöli a programban használt szavak szerepét. Első lépésként a File/New/Empty file paranccsal kérünk egy új lapot. Ennek a program automatikusan ad egy nevet Untitled1. Most mentsük el az üres programunkat a kívánt néven a File/Save paranccsal. Programunk neve legyen elso.cpp. Természetesn kiválaszthatjuk azt a könyvtárat, amibe menteni szeretnénk, majd névként írjuk be az elso.cpp-t. A cpp a c++ -ra utal, ilyen fordítót fogunk használni. Ezek után gépeljük be a következő programot: #include<stdio.h> main() { printf( „ Ez az elso programom. ”); } A legegyszerűbb program egyetlen függvényt (=alprogramot), a main függvényt tartalmazza. Alakja: fgv. neve fgv. törzse A függvény neve: Argumentumlista:
A függvény törzse:
main () { }
argumentumlista
main zárójelek között kell felsorolni a változókat, amelyeken keresztül ezt a program egy másik programmal kommunikál, magasabb szinten használjuk az argumentumokat, de a zárójelek minden esetben kellenek kapcsos zárójelek között található, a zárójeleknek mindig szerepelnie kell, itt kell felsorolni a végrehajtandó utasításokat, minden utasítást ; zár le
Ebben a main függvényben egyetlen végrehajtandó utasítás található, a printf(). A printf() maga is függvény, méghozzá beépített függvény. Ez azt jelenti, hogy a program készítői már előre megírták és beépítették azt a programba. Ez a függvény az stdio.h állományban található. Nem minden beépített függvény itt található, ezért, ha a programunkban használunk egy beépített függvényt, akkor a program elején mindig meg kell mondanunk, hogy azt hol találja a fordító. Erre szolgál a következő sor: #include<stdio.h> Mindig amikor egy beépített függvénnyel megismerkedünk, megtanuljuk azt is, hogy melyik állományban található a leírása. Minden esetben a#include előfordítót fogjuk használni és utána <> jelek között az állomány nevét szerepeltetjük. A printf() függvény arra szolgál, hogy megjelenítse a képernyőn az argumentumlistájában szereplő szöveget, az ott meghatározott módon. A függvény neve: Argumentumlista:
printf zárójelek között szerepeltetni kell a szöveget, amit ki akarunk íratni a képernyőre, a szövegnek ” ” között kell szerepelnie. Tehát a printf( „ Ez az elso programom. ”);utasítás megjeleníti a képernyőn azt, hogy Ez az elso programom.
Vegyük észre, hogy az utasítást ; zárja le. A program beírása után nézzük meg, hogy mit csinál. Ehhez elsőként le kell fordítanunk, majd futtatnunk kell. Fordítás lehetőségei (mindhárom ugyanazt csinálja, csak az egyiket válasszuk): Build/Build, CTRL F9, ikon. A fordítás eredményeként az alsó ablakban információk jelennek meg a fordításról: errors – hibák, warnings – figyelmeztetések. Azok a hibák, amik itt megjelennek azok a szintaktikai hibák. Ez azt jelenti, hogy nem jól használtuk a nyelvet, értelmetlen „mondatokat” (=utasításokat) fogalmaztunk meg, mondhatni helyesírási hibát vétettünk. Nem kell megijedni a tömérdek hibától, gyakran egy ; hiánya is generálhat több hibát. A fordító jelzi, hogy ő mely sorban lát hibát és, hogy mi a hiba. A hibákat ki kell javítani futtatás előtt, a figyelmeztetések javítása nélkül viszont fut a programunk. A fordítás eredményeként megjelenik egy új állomány a programunk mellett, neve elso.obj. Ez az ún. tárgyprogram. Futtatás lehetőségei: Build/Run, CTRL F10, ikon. A futtatás eredményeként megjelenik a konzolablak és benne az eredmények. Ha jól dolgoztunk megjelenik az Ez az elso programom. szöveg és alatta a program futási ideje. Tetszőleges billentyű megnyomásával visszatérhetünk a programíró ablakba. Figyeljünk oda, hogy ha ezt a konzol ablakot nem zárjuk be, akkor a programíró ablakban „kiszürkülnek”, azaz használhatatlanná válnak a fordítás és futtatás ikonjai. Így mindenképpen be kell zárnunk a konzolablakot, mielőtt a szerkesztő ablakban munkához látunk. A futtatás eredményeként elkészült a harmadik állományunk is könyvtárunkban, az elso.exe. Ez egy futtatható állomány, amit bárhova magunkkal vihetünk, mert mindenhol fut, nem szükséges hozzá c fordító. A fordítást és a futtatást egy lépésben is megtehetjük: Build/ Build and run, F9,
ikon.
Nézzük meg kicsit jobban a printf függvény lehetőségeit, hogyan tudok például új sorban megjeleníteni szöveget. Ehhez vezérlő karaktereket kell írnom a függvény argumentumlistájába. A leggyakrabban használt két ilyen karakter: \n új sor \t tabulálás Feladat: Írjunk programot, amely megjeleníti a következő szöveget a megadott elrendezésben! mondd, játszanád velem, ha kérném, az életed, veled én nem félnék, játszanék veled, remélném, az életem neked épp jó játék. s ha felrónák nekünk,
hogy élni így nem érdekünk, mi csak nevetve köszönnénk szépen, mert ha véget ér a játék veled, tudom jól, hogy vár még a játékos végtelen.
Gyakran használt vezérlőkarakterek még: \v függőleges tabulálás \\ \ jel kiirtása, pl: \Petőfi Sándor\ \? ? kiiratása \” ” kiiratása \’ ’ kiiratása Eddig csak szövegekkel foglalkoztunk, nézzük most a numerikus adatokat.
Numerikus adatok a képernyőn Írjuk be a következő programot: #include<stdio.h> main() { printf(”A szamokosszege:%d. ”, 1+2+3); } Futtassuk a programot, a képernyőn megjelenik:A szamokosszege:6. Mi az újdonság az eddigiekhez képest?A %d . A d a double rövidítése és azt jelzi, hogy itt egy egy ún. hosszú egész számot kell megjeleníteni, a hangsúly az egészen van. Ilyen esetben az ”” jelek után írjuk magát a megjeleníteni kívánt adatot, ami itt egy összeadás eredménye lesz. A program előbb kiszámolja, majd az eredményt megjeleníti. Az 1+2+3 számok helyett tetszőleges számokat írhatunk és futtathatjuk a programot. Feladat: Írjunk programot két szám átlagának megjelenítésére! #include<stdio.h> main() { printf(” A szamokatlaga:%d. ”, (1+2)/2); } Futtatás után a következő eredményt kapjuk: A szamokatlaga:1.De miért is? Hiszen a helyes eredmény az 1.5. A magyarázat a számok típusában keresendő. Két dolgot kell átállítanunk, hogy helyes eredményt produkáljon a programunk. Az egyik a kiiratásra váró szám típusának megadása. A %d helyett írjunk %f-et. Az f a float rövidítése és valós típusú számot jelöl. A másik, hogy a számok közül legalább az egyiket valós típusúnak kell megadnunk, hiszen ha mindegyik egész, akkor az eredmény is az lesz. A program helyesen tehát: #include<stdio.h> main() {
printf(” A szamokatlaga:%f. ”, (1+2.0)/2); } A kiíratás eredménye: A szamokatlaga:1.50000. Az eredmény alapértelmezés szerint 6 tizedes jeggyel jelenik meg. A kiíratást formázhatjuk a következőképpen: %.3f 3 tizedes jeggyel %.0f nincs tizedes jegy
Változók A programban nem mindig ugyanazokkal az adatokkal akarunk dolgozni, hanem azt szeretnénk, hogy programjaink különböző értékekre is lefussanak, azaz változtathatóak legyenek az értékek. Változó: olyan programozási eszköz, melynek négy tulajdonsága van:
neve o o o típusa o o o címe o értéke o o
karaktersorozat, amely betűvel kezdődik és betűvel/számmal folytatódhat, a programban a változóra a nevével hivatkozunk, célszerű beszélő nevet választanunk. minden változóhoz egy típust rendelünk, a program deklarációs részében rendelünk típust a változóhoz, a típus határozza meg, hogy milyen műveleteket végezhetünk a változóval. megmutatja, hogy a változó a memória mely területén helyezkedik el. a típus határozza meg, hogy milyen értéket vehet fel a változó értéket kaphat egy változó: kezdőértékadással (a deklarációs részben, ahol a típusát is megadom), értékadó utasítással (változónév=érték;), input utasítással (a változó értékét valamilyen perifériáról olvasom be),
Írjuk be a következő programot! #include<stdio.h> main() { int a,b; a=30; b=66; printf(”%d+%d=%d”,a,b,a+b); } A program futtatása a következő eredményt hozza: 30+66=96 És most lássuk, hogyan történik mindez! int a,b; ez a deklarációs rész, itt határozzuk meg, hogy milyen változókat kívánunk használni a programban. Két változót deklaráltunk, a és b változókat, ez a nevük. A típusuk int, azaz integer. Az integer is egy egész számokra használható típus, akárcsak a double. A
double nagyon nagy számok tárolására alkalmas, az általunk végzett feladatok megoldhatók int típussal is. a=30; b=66; itt két értékadó utasítás következik, a változó neve a, értéke 30, a másik változó neve b, értéke 66. Az utasítások után ; található. printf(„%d+%d=%d”,a,b,a+b); a képernyőre történő kiíratás utasítása, argumentumában található, hogy írja ki az a értékét, majd + jelet, b értékét, majd = jelet és végül a+b értékét. A változókról tanultaknál említettük, hogy nem csak értékadó utasítással kaphat értéket egy változó, hanem kezdőérték adással is. Ez a következőt jelentené ebben a programban: int a,b; a=30; helyett int a=30,b=66; b=66; Tetszésünknek megfelelően használhatjuk egyik vagy másik megoldást. Az utasításokat nem kell mindig új sorban kezdeni, attól még tökéletesen működnek, ha egy sorba kerülnek. A jobb átláthatóság miatt szoktuk így tagolni. Feladat: Terjesszük ki a programot a kivonás és a szorzás műveletre is! A változók egy harmadik módon is kaphatnak értéket, mégpedig input utasítással. Az input utasítás arra szolgál, hogy egy perifériáról (alapértelmezés szerint a billentyűzetről) beolvasunk egy értéket a változóba. Ezt egy beépített függvénnyel valósíthatjuk meg: scanf(). Például: scanf(”%d”,&a); idézőjelek között megadjuk a formátumot, hogy milyen típusú adatot várunk, majd pedig a változó memóriabeli címét adjuk meg, ahová az adatot helyezni szeretnénk. A változó címét úgy jelöljük, hogy neve elé egy & jelet helyezünk. Tehát itt egy egész típusú adatot olvasunk be az a változóba. Feladat: Írjunk programot, amely az a változóba és a b változóba is bekér egy-egy egész számot és kiírja az összegüket, különbségüket és szorzatukat! Feladat: Billentyűzetről olvassuk be egy tetszőleges háromszög három oldalának hosszát cm-ben. Számoljuk ki és írassuk ki a kerületét és a területét! A feladat megoldása során használnunk kell egy függvényt a négyzetgyök kiszámítására: sqrt(x)
x négyzetgyökét adja vissza
ez a függvény a <math.h> könyvtárban található, így az include előfordítók között ezt is meg kell adnunk. Más függvények is vannak a könyvtárban, amelyeket gyakran használnunk kell: abs(x)
x int tipusú kifejezés abszolút értéke
floor(x)
x nél kisebb egészek közül a legnagyobb
ceil(x)
x nél nagyobb egészek közül a legkisebb
cos(x)
cosinus x
sin(x)
sinus x
tan(x)
tangens x
hypot(x,y)
x,y befogójú derékszögű háromszög átfogóját adja vissza
log(x)
logaritmus x
pow(x,y)
x az y hatványon
Feladat: Egy derékszögű háromszög két befogóját olvassuk be a billentyűzetről és számoljuk ki a kerületét és a területét! Feladat: Írjunk programot, amely a százalékalap és a százalékláb ismeretében kiszámolja a százalékértéket! Feladat: Olvassuk be egy kör sugarát cm-ben, majd számoljuk ki és írassuk ki a kerületét és a területét! Feladat:Írjuk ki 0-tól az első 8 darab 23-al osztható számot! Feladat: Készítsünk programot egy bérkifizetőhely számára. A program egy a billentyűzetről beolvasott értékről eldönti, hogy a kifizetéshez hány 20.000, 10.000, 5.000, 2.000, 1.000, 500, 200, 100, 50, 20, 10 fortintos szükséges!
Kifejezés Nagyon gyakran a program egy adott pontján már ismert értékekből új értékeket kell kiszámolni. A kifejezés olyan programozói eszköz, amelynek két komponense van: típus, név. A kifejezés részei: operandus (változó, konstans, függvény, nevesített konstans), operátor, zárójelek. A legegyszerűbb kifejezés egy operandusból áll. Pl. : a=5; b=3; Kiértékelésnek nevezzük azt a folyamatot, amikor a konkrét kifejezés értéke meghatározásra kerül. A kiértékelésnek meghatározott sorrendje van, ezt precedencia sorrendnek nevezzük. Feladat: A pontos időből (óra, perc) számítsuk ki, hogy a nap hányadik percében vagyunk! Feladat: E év latt X összegből N %-os kamatláb mellett mennyi pénzünk lesz? (kamatos kamatszámítás) Feladat: Csúcsai koordinátáival adott egy háromszög. Számítsuk ki a háromszög területét és kerületét!
Feladat: Készítsünk programot, amely kiszámítja egy legfeljebb négyjegyű szám jegyeinek összegét! Feladat: Adott kettes számrendszerben egy tetszőleges négyjegyű pozitív szám. Alakítsuk át tízes számrendszerbelivé! Feladat: Írjunk programot, amely két közönséges törttel alapműveleteket végez! Kiíratási kép:
Szelekciós utasítás Valamely tevékenység (utasítás) végrehajtását egy kifejezés (feltétel) értékétől tehetjük függővé. if (kifejezés) utasítás; Ha a kifejezés értéke igaz, akkor végrehajtódik az utasítás. Feladat: Olvassunk be a billentyűzetről egy számot és írassuk ki, hogy a szám pozitív, negatív vagy nulla. Az összehasonlítás során a következő operátorokat használhatjuk: a
b a nagyobb mint b a>=b a nagyobb vagy egyenlő b-vel a==b a egyenlő b-vel a!=b a nem egyenlő b-vel a&&b a és b a||b a vagy b Ha a kifejezés hamis értékére is akarunk valamit csináltatni a programmal, akkor az if – else szerkezetet kell használnunk: if (kifejezés) utasítás 1; else utasítás 2; Feladat: Olvassunk be a billentyűzetről egy egész számot és döntsük el róla, hogy páros vagy páratlan! Feladat: Olvassunk be két számot a billentyűzetről és határozzuk meg a viszonyukat: egyenlő, melyik a nagyobb/kisebb! Az if utasításokat egymásba is ágyazhatjuk, pl.: if (a==b) printf („Egyenlok.”); elseif (a>b) printf( „%d nagyobb, mint %d”, a,b); elseprintf(„ %d nagyobb, mint %d”, b,a); Feladat: olvassunk be a billentyűzetről egy szöget és döntsük el, hogy null-, hegyes-, derék-, tompa-, fél-, homorú- vagy teljesszög. Feladat: Kérjük be három szakasz hosszát! Vizsgáljuk meg, hogy szerkeszthető-e belőle háromszög. Ha igen, akkor számoljuk ki a kerületét és a területét. Ha nem, akkor írjuk ki, hogy nem.
Feladat: Kérjünk be három darab szöget és állapítsuk meg, hogy lehetnek-e egy háromszög szögei. Ha nem, akkor írjuk ki, hogy „Ezek a szögek nem lehetnek egy háromszög szögei.”. Ha igen, akkor írjuk ki, hogy a háromszög derék-, tompa-, vagy hegyeszögű. Feladat:Tetszőleges 0 és 1.000.000 közötti egész számról mondjuk meg, hogy hány jegyű! Feladat: Rendezzük csökkenő sorba három, billentyűzetről beolvasott számot! Feladat: Két tetszőleges egész szám esetén döntsük el, hogy osztója –e valamelyik a másiknak. Feladat: Három növekvő sorrendben lévő egész számról döntsük el, hogy számtani vagy mértani sort alkotnak-e? Feladat: Írjon programot, amely meghatározza egy pontról, amelynek ismerjük a koordinátáit, hogy melyik síknegyedben van! Feladat: Írjunk programot, amely a billentyűzetről bekéri egy hónap sorszámát és kiírja, hogy hány napos. Feladat: Oldjuk meg a tetszőleges ax2+bx+c=0 másodfokú egyenletet! Tetszőleges együtthatókra készítsük fel a gépet!
Ciklusok A program során előfordul, hogy egy utasítást többször kell megismételnünk. Ezt iterációval, ciklusokkal tudjuk megoldani. A ciklus részei formálisa:
fej, törzs, vég.
ismétlődő utasítások
Fajtái:
előírt /megadott lépésszámú, elöltesztelő, hátultesztelő.
Előírt lépésszámú ciklus for (kezdőérték adás; feltételes kifejezés; léptető kifejezés) utasítás; pl.: for (i=1; i<11; i=i+1) printf( ”SZERETLEK”); Működése: 1. kezdőérték adás = inicializálás, itt az i a ciklusváltozó, kezdőértéke 1, 2. feltételes kifejezés kiértékelése, ettől függően, ha
a. igaz, akkor az utasítás végrehajtódik, a ciklusváltozó értéke megváltozik, majd ugrás a 2. lépésre b. hamis esetén befejeződik a ciklus működése A ciklusfejben megváltoztathatók az adatok, úgy hogy ugyanazt a hatást érjük el. Pl.: for (i=5; i<15; i=i+1) for (i=10; i<101;i=i+10) Tehát, ha a ciklusváltozóra nincs szükség a cikluson belül, akkor mindegy, hogy milyen értéket vesz fel. De, bizonyos esetekben a ciklusváltozót felhasználjuk a ciklusban, ilyenkor nem mindegy, hogy milyen értékeket vesz fel a ciklusváltozó! Feladat: Írjunk programot, amely kiírja 1-től 10-ig a számokat, négyzetüket és köbüket! Feladat: Írjuk ki 3-tól 100-ig a hárommal osztható számokat! Feladat: Írjunk programot, amely a-tól, b-ig kiírja az a-val osztható számokat! Feladat: Írjunk programot, amely 1-től 10-ig összeadja a számokat! Összegző algoritmus a=0; for (i=1;i<11;i++) a=a+i; Feladat: Alakítsuk át az előző programot úgy, hogy az első 10 szám szorzatát számolja ki! Feladat: Az előző programot alakítsuk át úgy, hogy n!-t számoljon, ahol az n-t a billentyűzetről olvassuk be! Feladat: Készítsen számtani sorozatot, úgy, hogy a billentyűzetről beolvassa az első elemet, a differenciát és az elemek számát! Feladat: Olvassuk be 10 számot (0-tól különböző, egész szám), és számoljuk meg, hogy mennyi belőle páros és páratlan! Véletlen szám generálása #include<stdlib.h> rand()%100 Ez 0 és 100 között generál számokat, a legnagyobb felvehető értéke a 99. Feladat: Állítsunk elő véletlenszerűen 20 számot 0 és 100 között és irassuk ki! Feladat: Állítsunk elő véletlenszerűen 30 db számot -100 és 100 között. Számoljuk meg, hogy hány pozitív negatív és nulla van benne!
Feladat: Szimuláljunk egy N-szeres kockadobást: dobjuk fel N-szer egy kockát a gép segítségével! Írjuk ki a dobások eredményét, majd a sorozat végén a dobások átlagát!
Tömbök Eddig olyan változókat használtunk, amelyek csak egyetlen érték tárolására alkalmasak. A programozás során azonban gyakran van arra szükség, hogy azonos típusú elemekből álló adathalmazt a memóriában tároljuk és az adatokon valamilyen műveletet hajtsunk végre. Ez megoldható egyedi változók sokaságával, de a feldolgozás rettenetes. Léteznek egy és többdimenziós tömbök. A vektor egy kiterjedéssel rendelkezik, egydimenziós tömb. Általános alakja: típus tömbnév [méret] Pl.: int a[5] ez a tömb egész típusú elemeket tartalmaz, 5 darabot, az elemek indexelve vannak: a[0], a[1], a[2], a[3], a[4]. Tömb feltöltése elemekkel: int a[5]; for (i=0; i=1; i++) a[i]= i*i;
scanf(”%d”,&a[i]);
a[i]=rand()%11;
Tömb elemeinek kiírtaása: for (i=0; i<5; i++) printf(„%d\tˇ, a[i]); Feladat: Töltsünk fel egy 20 elemű tömböt -100 és 100 közti egész számokkal (0<=x<=100). Írjuk ki az elemeket egymás mellé!
Elemi algoritmusok 1.
Összegzés a. az algoritmus egy sorozat elemeit adja össze b. az összeget egy változóban tároljuk c. a változó értékét nullázzuk, majd egy ciklusban egyesével hozzáadjuk a tömb elemeit osszeg=0; for (i=0; i
Töltsünk fel egy 10 elemű tömböt véletlenszerűen 0 és 10 közötti egész számokkal, majd számoljuk ki a tömb elemeinek összegét! Töltsünk fel egí 10 elemű tömböt 1-től 10-ig elemekkel, majd számoljuk ki az elemek szorzatát! Töltsünk fel egy 5 elemű tömböt véletlenszerűen 0-100-ig egész számokkal, majd írassuk ki az elemeket és az átlagokat!
2.
Megszámlálás a. egy tömb adott tulajdonságú elemeinek a számát határozza meg b. számlálásra bevezetünk egy változót c. a számlálót lenullázzuk d. ha találunk adott tulajdonságú elemet, akkor megnöveljük a számláló értékét eggyel szamlalo=0; for (i=1; i
Töltsünk fel egy 30 elemű tömböt véletlenszerűen -20 és 20 közötti egész számokkal és számoljuk meg, hány nulla van benne. Egészítsük ki az előző programot, hogy a pozitív, negatív számokat is számolja össze. Töltsünk fel egy 31 elemű tömböt véletlenszerűen a januári napi átlaghőmérsékletekkel -15 és 10 között. Határozzuk meg a hideg ( -10 alatt) és meleg ( 5 felett) napok számát. 3.
Maximum- és minimumkiválasztás a. egy sorozat/tömb legnagyobb/legkisebb elemének kiválasztása b. az első elemet tekintjük maximumnak/minimumnak c. a második elemtől kezdve összehasonlítjuk a sorozat elemeit az addig talált legnagyobb/legkisebb értékkel d. ha nagyobbat/kisebbet találunk, akkor lecseréljük vele max=a[0]; for (i=1; imaxmax=a[i];
Töltsünk fel egy 30 elemű tömböt véletlenszerűen 0 és 100 közötti egész számokkal. Keressük meg a legnagyobb elemet! Egészítsük ki a programot és keressük mega legkisebb elemet is! Egy tömbben tároljuk egy műkorcsolyázó 10 bírótól kapott pontjait. 0-10-ig terjedő 0,25-ös beosztású skála. Teljesítményét úgy határozzák meg, hogy szűkített átlagot számolnak. Szűkített átlag: két szélső értéket levesszük és a többi átlagát számoljuk. Egy tömbben egy család havi bevételeit, egy másikban ugyanazon hónap kiadásait tároljuk egy évben. határozzuk meg, melyik hónapban tudtak a legtöbbet megtakarítani! Egy (x,y) koordinátájú pont távolsága az origótól az sqrt(x*x+y*y) képlettel számolható ki. Tároljuk egy-egy tömbben a 20 db véletlenszerűen előállított pont koordinátáit. Határozzuk meg, hogy melyik pont van a legmesszebb és melyik a legközelebb az origóhoz! Az ideális testfelépítést a BMI index határozza meg. BMI=(kg-ban mért tömeg/ méterben mért magasság négyzete). Tároljuk egy 30 fős osztály súlyát és magasságát egy-egy tömbben. Írassuk ki a súlyt, magasságot és a BMI indexet és mellé az értékelést. Értékelés 15 vagy alatta sovány, 18,5 alatt normál, 24,9 alatt túlsúlyos, felette elhízott.
Karakter adattípus Egy tetszőleges karakter tárolására alkalmas a char adattípus. chara; A karakterek beolvasása és a kiíratása a tanult módon történik a %c formátumkóddal. Több karakter karaktertömbbötalköt, amit sztringnek nevezünk. pl.: char sor[81], ahol az egyes karakterek elérhetőek a sor[0]-tól a sor[80]-ig. A sztringek beolvasását a gets (sor) utasítással tehetjük meg, kiíratása a tanult módon a %s formátumkóddal történik. A leggyakrabban használt szrtingkezelő függvények <string.h> könyvtárból: strlen(s)
a sztring hosszát adja vissza
strlwr(s)
sztring átalakítása kisbetűssé
strupr(s)
sztring átalakítása nagybetűssé
strcat(s1,s2)
sztringek összekapcsolása
strrev
sztring megfordítása
strcpy(s1,s2)
s2-be másolja az s1-et
Kérjük be a nevünket és írassuk ki a hosszát! Írassuk ki a nevünket betűnként egymás alá! Írjuk ki a nevünket fordítva! Kérjünk be egy szöveget és egy karaktert. Számoljuk meg, hogy hányszor szerepel a szövegben az adott karakter! Kérjünk be egy szöveget és szedjük ki belőle a szóközöket! Kérjünk be két szöveget. Számoljuk meg, hogy hány karakteren tartalmaz azonos jelet! Írassuk ki a két szöveget betűnként egymás alá és csillagozzuk meg az azonos karaktereket! Olvassunk be egy szöveget és 2 karaktert. Az első karakter minden előfordulását cseréljük ki a második karakterrel! Olvassunk be egy szöveget és állapítsuk meg, hogy palindrom-e. Határozzuk meg egy beolvasott név monogramját!
Többdimenziós tömbök
