A megoldások az 5. gyakorlat anyagánál elérhetőek, a feladatkiírások helyén.
Ismétlő feladat:
(a) Használjunk konstansokat tömbök létrehozásához, feltöltéséhez és kiíratásához. 1 és 2 dimenziós tömbökkel is dolgozzunk.
(b) Hozzunk létre egy karakter tömböt. Töltsük fel és különböző képpen írassuk ki. Ellenőrizzük le a hosszát is.
Megoldás letöltése .
A típus definiálás általános alakja:
typedef típus név
F: Hogyan tudunk létrehozni egy olyan vector nevű tömb típust, amely egy háromdimenziós térbeli vektort reprezentál? typedef double vector[3]; F: Hogyan lehet létrehozni egy N hosszúságú sztringek tárolására szolgáló karaktertömb típust? typedef char string[N+1]; F: Hozz létre külön típust 16 bites nemnegatív értékek tárolására. typedef unsigned short int u16;
Felsorolás adattípus értékhalmaza a típusképzésben felsorolt azonosítók, mint konstans azonosítók által meghatározott értékek.
Feladat: Definiálj egy felsorolástípust a hét napjainak tárolására, majd írasd ki a napok értékeit!
#include <stdio.h> int main() { enum { Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap } nap; for(nap=Hetfo; nap <= Vasarnap; nap++) { printf("%d\n", nap); } return 0; }
Feladat: Vedd külön a típusdefiníciót és a változódeklarációt!
#include <stdio.h> typedef enum { Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap } het; int main() { het nap; for(nap=Hetfo; nap <= Vasarnap; nap++) { printf("%d\n", nap); } return 0; }
Egy enum változó tulajdonképpen egy egész változó.
Elmélkedjünk:
F: Mi történik, ha Hetfo=1 -ként adod meg az első elemet? F: Mi történik, ha Szombat=10 -ként adod meg a hatodik elemet? F: Adhatod-e az enum mindegyik elemének ugyanazt az int értéket?
Nézzük meg a következő összetettebb példát. Mi is történik és miért?
#include <stdio.h> int main() { enum het { Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap } nap; typedef enum { piros, zold, sarga } colors; colors col; printf("Milyen napon szeretnél almát enni? "); scanf("%d",&nap); printf("Milyen színű almát szeretnél enni? "); scanf("%d",&col); switch(nap) { case Hetfo : case Kedd : case Szerda : case Csutortok : case Pentek : printf("Csak hétvégén tudok almát felszolgálni!\n"); break; case Szombat : case Vasarnap : printf("Mivel hétvége van, alma is van!\n"); switch(col) { case piros: printf("A piros alma egészséges, jó választás!\n"); break; case zold : printf("Vigyázz, a zöldalma savanyú!\n"); break; case sarga : printf("A sárga alma is nagyon finom!\n"); break; default : printf("Nem ismerek ilyen színű almát!\n"); } break; default: printf("A hét csak 7 napból áll!\n"); break; } return 0; }
sizeof operátor - típusok méretének meghatározása byteokban. Pl.:
int i = sizeof(int); // ilyenkor az i változóba bele kerül az int típus mérete. ez a C esetén 4 byte
A legtöbb típust mind meglehet adni előjeles vagy előjeltelen formában. Egy típust előjelessé a signed, előjeltelenné az unsigned módosítóval tehetünk. A típusok alapértelmezés szerint általában előjelesek.
C típus méret(bájt) alsó határ felső határ _______________________________________________________ char 1 ? ? signed char 1 -128 127 unsigned char 1 0 255 short int 2 -32768 32767 unsigned short int 2 0 65535 int 4 -2147483648 2147483647 unsigned int 4 0 4294967295 long int 4 -2147483648 2147483647 unsigned long int 4 0 4294967295 long long 8 -263 263-1 float 4 -+3.4028234663852886E+38 double 8 -+1.7976931348623157E+308 long double 8 -+1.7976931348623157E+308
Túlcsordulás: Ha egy művelet eredménye túlhalad valamelyik irányban az azt eltárolni próbáló változó értékkészletén, akkor túlcsordulásról beszélünk. (Ha lefelé halad túl, szoktuk alulcsordulásnak is hívni.) Ilyenkor a "számláló körbefordul", tehát ha pl. egy unsigned char változóhoz, aminek az értéke 250 hozzáadunk 10-et, a változó értéke 5 lesz. ( Mivel a char típus mérete 1 byte = 255 bit. 250 + 10 = 260 bit. 5 bit a túlcsordulás. )
F: Hány bájton tárolódik a char típus? ============================================================================== #include <stdio.h> int main() { printf("char: %d\n", sizeof(char)); return 0; }
F: Írasd ki a 64 és 95 közé eső kódú karaktereket. ============================================================================== #include <stdio.h> int main() { char c; for(c=64; c<96; c++) { printf(" %c", c); } putchar('\n'); return 0; }
F: Alakítsd át az előző példát: írasd ki az 'a' és 'z' közé eső karakterek kódjait.
F: Mi a különbség a signed char és az unsigned char értékkészlete között? Írasd ki -128-tól 255-ig egy signed és egy unsigned char típusú változó számértékét! ============================================================================== #include <stdio.h> int main() { int i; signed char sc; unsigned char uc; for(i=-128; i<=255; i++) { sc=i; uc=i; printf("%hhd %hhu\n", sc, uc); } return 0; }
Feladat: Olvass be két legfeljebb 20 karakter hosszúságú szót, és fűzd őket egymás után egy harmadik sztringbe. A string.h függvényeit használd!
#include <stdio.h> #include <string.h> int main() { char egyik[21], masik[21], harmadik[41]; scanf("%s %s", egyik, masik); strcpy(harmadik, egyik); strcat(harmadik, masik); printf(" -> %s\n", harmadik); return 0; }
F: Hány bájton tárolódik a float és double típus? ============================================================================== #include <stdio.h> int main() { printf("float : %d\n", sizeof(float)); printf("double: %d\n", sizeof(double)); return 0; }
F: Mi a különbség a float és a double pontossága között? Add hozzá az 1, 0.1, 0.01, 0.001, ... sorozat elemeit egy-egy float és double változóhoz. Milyen értékeket kapsz lépésenként? ============================================================================== #include <stdio.h> int main() { int i; float f = 0.0, df = 1.0; double d = 0.0, dd = 1.0; for(i=0; i<20; i++) { f += df; d += dd; df *= 0.1; dd *= 0.1; printf("%d: float: %22.20f; double: %22.20lf\n", i + 1, f, d); } return 0; }
F: Mi a különbség a float és a double értékkészlete között? Szorozgasd egy float és double változó értékét 0.1-gyel, amíg 0 nem lesz mindkettő. Milyen értékeket kapsz lépésenként? ============================================================================== #include <stdio.h> int main() { float f = 1.0; double d = 1.0; int i = 0; do { printf("%d: float: %g; double: %lg\n", ++i, f, d); f *= 0.1; d *= 0.1; } while((f!=0.0) || (d!=0.0)); return 0; }
F: Hány bájton tárolódik a short int, int, long int, long long típus? ============================================================================== #include <stdio.h> int main() { printf("short int: %d\n", sizeof(short int)); printf("int : %d\n", sizeof(int)); printf("long int : %d\n", sizeof(long int)); printf("long long: %d\n", sizeof(long long)); return 0; }
F: Mi a különbség ugyanazon típus előjeles és előjeltelen verziója között? Deklarálj 6 változót (signed/unsigned, short/long/long long) változót, 0 kezdőértékkel, és vonj ki belőlük egyet. Milyen értékeket kapsz? Add értékül a változóknak a legnagyobb előjelesen ábrázolható értéket (ez fele az előjeltelen maximális értéknek), és adj hozzá egyet. Most mik a változók értékei? ============================================================================== #include <stdio.h> int main() { signed short int ssi = 0; unsigned short int usi = 0; signed long int sli = 0; unsigned long int uli = 0; signed long long sll = 0; unsigned long long ull = 0; ssi -= 1; usi -= 1; sli -= 1; uli -= 1; sll -= 1; ull -= 1; printf("0 mínusz 1\n"); printf("s16: %hd\n", ssi); printf("u16: %hu\n", usi); printf("s32: %ld\n", sli); printf("u32: %lu\n", uli); printf("s64: %lld\n", sll); printf("u64: %llu\n", ull); ssi = usi /= 2; sli = uli /= 2; sll = ull /= 2; printf("Legnagyobb ábrázolható előjeles szám...\n"); printf("s16: %hd\n", ssi); printf("u16: %hu\n", usi); printf("s32: %ld\n", sli); printf("u32: %lu\n", uli); printf("s64: %lld\n", sll); printf("u64: %llu\n", ull); ssi += 1; usi += 1; sli += 1; uli += 1; sll += 1; ull += 1; printf("... plusz 1\n"); printf("s16: %hd\n", ssi); printf("u16: %hu\n", usi); printf("s32: %ld\n", sli); printf("u32: %lu\n", uli); printf("s64: %lld\n", sll); printf("u64: %llu\n", ull); return 0; }
Egy kis szikra került a rendszerbe órán (a lényegen nem változtat), az elképzelt feladat kiírása: Írjunk egy ciklust, amely végig ellenőrzi egy bemenetként kapott n szám esetén, hogy 1-től 1000-ig mely számok oszthatóak n^2+n+1-gyel.
Megoldás letöltése .
Írjunk egy bombakereső játékot. A játékot a számítógép ellen játszuk. A számítógép induláskor feltölt egy 10*10-es tömböt random 0-kal és 1-esekkel, úgyh pl. 10 darab 1-es legyen a táblán, a többi mind 0. Az 1-esek szimbolizálják a bombákat. A játék kezdésekor a játékos úgyszint kitölt egy ugyanekkora táblát a saját elképzelése szerint, úgy, hogy megadja, hogy melyik pozícióra kerüljönek a bombái: [i,j]. Miután a random generátor feltöltötte az ellenfél tábláját, illetve a játékos is feltöltötte a sajátját, megkezdődhet a játék. Ezután felváltva találgathat a két játékos, hogy szerintük hol lehet bomba az ellenfél tábláján. Az nyer, aki előbb megtalálja az ellenfél összes bombáját. A játék végén írjuk ki, hogy ki nyerte a játszmát.
Megoldások beküldésének határideje: 2014.10.12., vasárnap éjfél.
Egy kis segítség: nyugodtan töltsük fel mindkét táblát kezdetben 0-kal, majd ahova érkezik 1-es, ott csak írjuk felül. A számítógép táblájának feltöltésére egy lehetséges megoldás, hogy két számot generáltatunk: az egyik lesz az oszlop indexe, a másik pedig a sornak az indexe. Így jön ki pl., hogy hova kerüljön 1-es. Bevezethetünk két segéd változót, amely azt figyeli, hogy ki hány bombát talált eddig. Ha valamelyik változó értéke eléri a 10-et, meg van az összes bomba, a játék véget ér. (Arra ügyeljünk, hogy kétszer ugyanoda tippelve, ne szerezzen egyik játékos sem mégegyszer pontot, legyegyszerűbb, ha egy találat esetén egyből felülírjuk 0-val az adott pozíciót az adott tömbben.)
A feladat megoldását/próbálgatását erősen ajánlom mindenkinek. Sok mindenre rá lehet jönni ilyenkor. Próbáljunk meg a körülményekhez mérten felhasználóbarát programot készíteni!
Egy lehetséges megoldás letöltése .
A házi feladatot megoldani nem kötelező és bemutatni sem kell, viszont a következő gyakorlaton visszakérhető (kikérdezés, táblához hívás, stb. formájában)! Ha a hallgató megoldása ötletes, szép kivitelezésű, plusz pont adható. Amennyiben viszont nem tudja megoldani gyakorlaton a házi feladatban szereplő példákat vagy nem tud válaszolni az azzal kapcsolatban feltett kérdésekre, mínusz pont adható. Plusz és mínusz pontból is egyaránt maximum 10 pontot gyűjthet össze egy-egy hallgató.
Házi feladat letöltése .
Gyakorló feladatok 01-feladat.txt, 02-feladat.txt .
További gyakorlásra a PUB-ban lévő további házi feladatok és az órán nem megoldott feladatok megoldása.
Téma:
5. gyakorlat anyaga. (De tudni kell az előző - 3. és 4. - gyakorlat anyagát is!)
Gyakorlásra:
A honlapomon a 3., 4. és 5. gyakorlathoz tartozó anyag, magyarázatokkal, példákkal.
A gyakorlatok végén lévő házi feladat és gyakorló feladatok megoldása.
A honlapom mellet további feladatok találhatóak a PUB-ban. (/n/pub/ProgramozasAlapjai/Gyakorlat/ - erős átfedés van az "itt" és "ott" található feladatok között).
Egyéb infó:
A gyakorlat 8:10-kor kezdődik és a ZH-t 8:15-kor kezdhetitek írni. Előreláthatóan 30 percetek lesz a feladat megoldására és beadására (tehát 8:45-ig). A feladatot a bíró rendszeren keresztül fogjátok megkapni és beadni is, és az értékelést is a bíró fogja csinálni ott helyben. Tehát egyből látni fogjátok a pontszámokat amiket a bíró adott. Aki késik, az is csak a fenti időintervallum alatt írhatja a ZH-t (a bíró rendszer nyit, majd automatikusan zár is). Hiányozni csak igazolással lehet, de a ZH akkor sem pótolható!
Vissza a lap tetejére.