Mutatók. Felsorolt típus. Állapotgép

A tipikus hiba

Feladat: milyen számjegynek (0…9) felel meg a beolvasott karakter?

char c;

if (c>='0' && c<='9')
   ertek = c-'0';
else
   ertek = -1; /* nem szám */

switch (c) {
   case '0': ertek = 0; break;
   case '1': ertek = 1; break;
   case '2': ertek = 2; break;
   case '3': ertek = 3; break;
        ...

A programozásban…

Nem azokkal a nyelvi elemekkel kell megoldani a feladatot, amik a legutóbbi órán szerepeltek, hanem azokkal, amik valók hozzá!

A házi szabadon választott, egyénileg elkészített!

• Ötletek a honlapon – hasonló nehézségű saját is lehet
• A választást a laborvezető mindenkinél esetben jóvá kell hagyja!
• Kb. 500 soros C program, kötelező elemek:
  • strukturált felépítés (függvények, típusok, több forrásfájl)
  • fájlkezelés, dinamikus memóriakezelés

Beadandók (elektronikusan)

1. Feladat választása: 7. hétig
2. Pontosított specifikáció: 8. hétig
3. Félkész program: 10. hétig
4. Végleges változat: 13. hétig; laboron bemutatva!
   • Kód + felhasználói, programozói, tesztelési dokumentáció

Mutatók (pointerek)

Mutató (pointer)

• A mutató egy meghatározott típusú változó memóriabeli helye, más néven: címe
• A cím képzése a & címképző operátorral történik: &valtozo
• A mutatott változó elérhető a * indirekció operátorral: *ptr
• Ez a cím eltárolható egy változóban

Indirekció (indirection)

double x;
double *ptr;

ptr = &x;    // cím képzése (address of)

*ptr = 3.14; // mutatott értékre hivatkozás

Az &x (address of x) kifejezéssel képezzük az x változó címét. Azt a címet kapjuk meg, ahova a fordító, ahova a memóriában elhelyezte a változót. Ezt a címet bemásoljuk a ptr nevű változóba, amely, double* típusú lévén, pont ilyet tud tárolni.

*ptr azt jelenti, hogy a pointer által mutatott érték. Mivel ptr éppen az x változóra mutat, ezért ez egyenértékű azzal, mintha x-ről beszélnénk, azaz x-nek adnánk értéket.

A ptr pointer később más változóra is mutathat. Mivel a típusa double*, bármelyik double típusú változó címét tárolhatja. A pointer maga egyébként egy teljesen szokványos változó: értéket kell adni neki használat előtt, átadható függvénynek paraméterként stb.

A címet gyakran referenciának (reference) is szokás nevezni. Ezért mondják a * operátorra, hogy dereferál (dereference), azaz megszünteti a referenciát, és általa már a mutatott, tényleges értéket látjuk.

#include <stdio.h>

int main() {
    int a=5, b=10;
    int *p;

    p = &a;
    printf("p=%p \n *p=%d \n\n", p, *p);

    p = &b;
    printf("p=%p \n *p=%d \n\n", p, *p);

    return 0;
}

A paraméterként kapott változók tartalmát megcserélő függvény:

/* Megcseréli a két számot. */
void csere(int *pa, int *pb) {
   int temp;
   temp = *pa; // dereferálás
   *pa = *pb;
   *pb = temp;
}

Használat:

int a=3, b=4;

csere(&a, &b);     // címképzés: hol van a változó?

Két visszatérési értékű függvény:

void szamol(int a, int b, int *possz, int *pszorz) {
    if (possz!=NULL) *possz = a+b;
    if (pszorz!=NULL) *pszorz = a*b;
}

int sz;
szamol(5, 7, NULL, &sz);    // csak a szorzatot kérem

A NULL pointer egy olyan mutatót jelent, amely nem mutat semmilyen változóra. Bármilyen típusú pointer (int*, double*, struct Pont* stb.) lehet NULL értékű. Egy lehetséges használatra a fenti kód mutat példát: a függvény kiszámolja a két paraméter összegét és szorzatát, amelyeket az ossz és szorz változókba tesz. A számolás mindkét esetben csak akkor történik meg, ha nem NULL pointert kapott az adott változóhoz. Vagyis megtehetjük azt, hogy csak az összeg vagy csak a szorzat kiszámolására kérjük meg a függvényt.

NULL-e? Nem NULL-e?

if (ptr!=NULL)
  printf("Mutat valahova.\n");
if (ptr==NULL)
  printf("Sehova sem.\n");

if (ptr)
  printf("Mutat valahova.\n");
if (!ptr)
  printf("Sehova sem.\n");

int *p=0;

C-ben egy tömbbel egy valamit lehet csinálni: a nevét írva megkapjuk a tömb kezdőcímét, vagyis az első elemének helyét a memóriában.

int tomb[5], *p1, *p2, tav;

p1=tomb;       // a tömb kezdőcíme

p2=&tomb[4]-1; // tomb[4-1] címe

tav=p2-p1;     // távolság: 3

Mivel az elemeik egymás után helyezkednek el, a többi elem címe kiszámítható!

A pointer aritmetika azt jelenti, hogy memóriacímekkel végzünk számításokat. Ennek tömböknél van értelme, hiszen ezáltal a tömb kezdőcímének és a típusának ismeretében meghatározható az egyes elemek címe. (Ahogyan azt is meg tudjuk mondani, mi a szomszédos ház címe.) Ezt a kódban úgy jelöljük, hogy a pointerhez hozzáadunk egy egész számot – azt a számot, hogy a tömbben a címtől számítva hányadik elem címére vagyunk kíváncsiak. A hozzáadás a tömb vége felé, a kivonás a tömb eleje felé való mozgást jelent. Két pointert akár ki is vonhatunk egymásból, hogy megkapjuk a közöttük lévő távolságot (ugrásszámot). Sőt még a <=, > stb. operátorokat is használhatjuk. Természetesen ezeknek csak akkor van értelme, ha a két pointer ugyanazon tömb belsejére mutat.

Emiatt is fontos a pointerek típusa. A típusból tudja a fordító, hogy az adott változó, amire a pointer mutat, hány bájtból áll. Ha például a pointer 8 bájtos double típusra mutat, a p+1 azt jelenti, hogy 8 bájtot ad hozzá a p pointer értékéhez. Ezzel azonban nekünk nem kell foglalkozni, a fordító ezt automatikusan megoldja a háttérben! Nekünk csak arra kell gondolni, hogy p+1 a következő double, p+2 az azt követő stb. A bájtok számolgatását végző kódért a fordító felel.

Tudni kell azt, hogy egy önálló int változóra mutató int *p pointer esetén is helyes szintaktikailag a p+1 kifejezés. Vagyis a program lefordítható, csak szemantikailag helytelen. Ugyanis nem tudhatjuk, hogy milyen változót helyezett el a fordító az adott egész után. Ilyen hibákat elkövetve ahhoz hasonló misztikus hibákat és programlefagyásokat kelthetünk, mint amilyeneket például tömb túlindexeléssel is.

Néhány szó a fenti változódefiníciókról. Az

int tomb[5], *p1, *p2, tav;

definíciók azt jelentik, hogy négy változót hozunk létre egyszerre, amelyek mind egész számokkal kapcsolatosak. Nevezetesen: megfelelő módon használva azokat, mindegyik által egész számokhoz juthatunk. A tav változó egy szokványos int. A tomb egy öt elemű tömb: valami, amit ha megindexelünk [], egy int-et kapunk. p1 és p2 int-re mutató pointerek: az indirekció * operátorát használva rajtuk int-eket kapunk.

int* pi, i;

Látható az elv, hogy C-ben a változókat a használat módja alapján kell létrehozni. Ezért szokás a *-ot a változók neve mellé tenni, nem pedig a típus neve (itt az int) mellé. Hiszen ha több pointert hozunk létre, akkor mindegyik neve mellé oda kell tennünk a csillagot. Hiába tesszük a csillagot az int mellé, a jobb oldali példában akkor is egy pointert és egy egész számot hozunk létre. Ezért ne használjuk így, hanem inkább a fenti formában!

A fentiek alapján a * karakter a programkódban kétféle dolgot jelenthet, attól függően, hogy deklaratív helyen van (vagyis egy változó típusának megadásakor), vagy utasításban. Deklaratív helyen: int *pi azt jelenti, hogy a nevezett változó egy pointer. Utasításban: *pi=5 jelentése az, hogy a pi pointert dereferáljuk, azaz az általa mutatott változóról beszélünk. A két jelentés persze nincs távol egymástól: az előbbinél megmondjuk, hogy hogyan fogjuk használni, az utóbbi pedig a konkrét használat.

Tömbök és pointerek

int tomb[10];

*(tomb+2)=3;
tomb[2]=3;   // ugyanaz

int *p = tomb;

*(p+2)=3;
p[2]=3;      // ugyanaz

Tömbös ciklusok

double t[100];
int i;

/* i=0→99, 100 már nem */
for (i=0; i!=100; ++i)
    t[i] = 0.0;

double t[100];
double *p;

/* p=t+0→t+99, t+100 nem */
for (p=t; p!=t+100; ++p)
    *p = 0.0;

A tömbökön végigmenő ciklusokat nem csak indexeléssel, hanem pointerek használatával is megírhatjuk. A bal oldalon látható a szokásos, indexelő operátort használó forma (annyi különbséggel, hogy i<100 helyett i!=100 szerepel, de jelen esetben ezek egyformán viselkednek). A jobb oldalon a pointeres. A ciklus kezdetén a pointert beállítjuk a tömb elejére, és egészen addig fut a ciklus, amíg el nem éri a pointer a tömb 100. indexű elemét. Mivel a tömb csak 0…99-ig indexelődik, a t+100 cím használata már túlindexelés lenne, ezért a ciklus itt megáll.

A két forma egymással teljesen egyenértékű. Mindkét esetben egyébként balról zárt, jobbról nyílt intervallummal dolgoznak a ciklusok: az i=0 indexű, azaz a t+0 című elemet feldolgozzák, az i=100 indexű, azaz t+100 címűt pedig nem.

Fejléc és törzs

Az alábbi függvények tömböt vesznek át paraméterként. A kiir() kiírja az elemeiket visszafelé (az utolsótól az elsőit), a beolvas() pedig feltölti a tömböt a billentyűzetről beolvasott értékekkel.

void kiir(double *tomb, int meret)      // kezdőcím és méret
{
	int i;
    for (i=meret-1; i>=0; --i)
        printf("%g ", tomb[i]);         // indexelő operátor
    printf("\n");
}

void beolvas(double tomb[], int meret); // ugyanazt jelenti (!) 

Hívás (használat)

double szamok[10];
kiir(szamok, 10);                       // neve → kezdőcím

A híváskor a tömb nevét adjuk első paraméternek, ilyenkor a függvény a tömb kezdőcímét kapja meg. Természetesen a tömb méretét is meg kell adni. Fontos viszont, hogy mivel a függvény cím szerint veszi át a tömböt, meg is tudja változtatni az elemeit! Ebből a szempontból nagy a különbség a beépített típusok és a tömbök függvény paraméterként történő átadása között. De, mint azt eddig láttuk, igazából semmi különbség nincsen – ilyenkor is érték adódik át, csak az érték a tömb kezdőcíme (ami pointerként egy beépített típus), nem pedig a teljes tartalma. A beolvas() függvény egyébként így képes ellátni a feladatát, hogy a billentyűzetről számokkal töltse fel a tömböt.

int tomb[3][4]; // 3 sor, 4 oszlop

A két dimenziós tömbök sorfolytonosan helyezkednek el a memóriában:

• Első sor vége után a második sor eleje
• Indexelés: tömb[sor][oszlop]
• A fordító az y*szélesség+x képletet használja.

Emiatt két dimenziós tömböt úgy kell átadni függvénynek, hogy a szélességét is meg kell adnunk, már a típusban:

void fuggveny(int tomb[][4], int magassag); // int (*tomb)[4]

A void fuggveny(int tomb[][]) emiatt szabálytalan!

int a;
scanf("%d", &a);  // cím szerinti átadás

Így már érthető! Különben nem tudná beleírni a beolvasott számot.

A többi furcsaság

• Az elmondottak miatt nincs t1=t2 tömb értékadás
• Ezért nincs sztring értékadás (azok is tömbök)
• Ezért nem lehet sztringeket == operátorral összehasonlítani. A címüket hasonlítja össze, nem a tartalmukat!

"Sztringek"

Sztringek

A sztringek nullával ('\0' vagy 0) lezárt karaktertömbök.

h

e

l

l

o

\0

±

¤

%

X

§

»

"

$

»

A NUL nevű ASCII vezérlőkódot a sztringek végének jelölésére tartjuk fenn. A karakter kódja 0. Ezt a forráskódban '\0' és 0 formában írhatjuk – de nem keverendő a '0'-val, ami a nullás számjegyet jelöli, és a kódja 48!

Sztring létrehozása és inicializálása

char szoveg1[50] = { 'h', 'e', 'l', 'l', 'o', '\0' };
char szoveg2[50] = "hello";

A karaktertömb tartalma: a karakterek és a lezáró nulla. Ha a "Hello" formát írjuk, akkor is hozzáteszi a fordító a lezáró nullát. Ezért a fenti két inicializálás tökéletesen ugyanazt jelenti, de természetesen az alsót használjuk inkább. (Az ilyesmit szintaktikai édesítőszernek (syntactic sugar) szokás nevezni – szebb, olvashatóbb kódot kapunk.)

A tömb ilyenkor 50 karakterből áll. Abból a szöveg 5 bájtos, de végülis a sztring 6 bájt helyet foglal el belőle, mert 1 bájt a lezáró nullának is kell!

Egy adott méretű tömbbe méret−1 hosszú, azaz egy karakterrel rövidebb szöveg fér csak! A lezáró 0-nak is kell hely!

Erre a szabályra nagyon fontos emlékezni! Az „alma” szó eltárolásához például egy 5 (öt!) elemű karaktertömbre van szükség: char szoveg[5]="alma". Négy nem elég, mert a lezáró nulla akkor már nem férne bele. A számonkéréseken pontlevonás járhat azért, ha valaki erre nem figyel.

A fenti utasítások egyébként nem értékadások, hanem inicializálások. Az = jel itt azt jelenti, hogy létrehozunk egy tömböt, amelyet kezdeti értékekkel töltünk fel. Nem pedig értékadást – hiszen tömbök közötti értékadás nincs.

#include <stdio.h>

int main() {
   char str[50]="hello";

   printf("1. %s\n", str);

   str[0]='H';
   printf("2. %s\n", str);

   str[5]='!';
   str[6]='\0';
   printf("3. %s\n", str);

   return 0;
}

int sztring_hossza(char *sztring) {
   int i;
   for (i=0; sztring[i]!='\0'; ++i)
      ;  /* üres */
   return i;
}

Az üres ciklus igazából nem üres: ++i.

char str[20]="Hello";

printf("%d", sztring_hossza(str)); // 5

Miért nem adjuk most át a függvénynek a tömb méretét?

#include <ctype.h>

void sztringet_nagybetusit(char *sztring) {
   int i;
   for (i=0; sztring[i]!='\0'; ++i)
      sztring[i] = toupper(sztring[i]);
}

A sztringet címével látja, ezért meg is változtathatja azt!

char str[]="Hello";
sztringet_nagybetusit(str); // Hello → HELLO

Nem kell & operátor a paraméter átadásánál! A sztring egy tömb, amelynek a nevét írva már eleve pointert kapunk a tömb elejére!

void sztringet_masol(char *ide, char *innen) {
   int i;

   for (i=0; innen[i]!='\0'; ++i) // ugyanolyan indexűeket
      ide[i]=innen[i];
   ide[i]='\0';                   // és még a lezáró nulla!
}

A ciklus átmásolja az „értékes” karaktereket.

• Utána pedig még a lezáró nullát kell, pont az ide[i] helyre

Túlindexelés veszélye: a függvény nem tudja, mekkora a cél tömb!

• Emiatt nem tud felelősséget vállalni ezért! Ha túl kicsi, túlírja!
• A függvény hívója felel érte, hogy elég nagy legyen!

Alapmű: Brian Kernighan and Dennis Ritchie: The C Programming Language.

void masol(char *ide, char *innen) {
    while (*ide++ = *innen++)
        ;
}

A ciklus feltételében értékadás van!

• Főhatás: a másolt karakter kódja
• Mellékhatás: mindkét pointer a következő karakterre mutat (postincrement, utólagos)

A főhatás a ciklus feltétele: ha a lezáró nulla, az logikai hamis. Ettől megáll a ciklus, de azt még átmásolta.

#include <string.h>

char str[50], *hol;

strcpy(str, "alma");
strcat(str, "fa");
printf("%d", strlen(str));
hol=strstr(haystack, needle);

#include <stdio.h>

gets(str); // problémás
puts(str);
scanf("%s", str); // !
printf("str: %s\n", str);
sprintf(str, "x=%d", 19);
sscanf(str, "%d", &i);

Összehasonlítás (compare)

int strcmp(char *a, char *b);

if (strcmp(s1, s2)==0)
    printf("Egyformák.\n");

Felsorolt típus

Olyan típus, amelynek értékkészlete egy névvel megadott értékhalmaz.

enum Lampa {
   piros,
   piros_sarga,
   zold,
   sarga
};

enum Lampa l;

l=piros;

if (l==zold)
   printf("Mehet!\n");

A színfalak mögött

• Minden névhez egy egész számot rendel a fordító
• A lefordított programban azok a számok szerepelnek
• Így a program gyors, nekünk pedig érthető a kód!

Számozás

enum Lampa {
   piros,
   piros_sarga=2,
   zold,
   sarga
};

• Ha mást nem adunk meg, 0-tól 1-esével
• Ezt módosíthatjuk:
  piros=0, piros_sárga=2, zöld=3, sárga=4
• De ha ilyet teszünk, gondoljuk meg: ilyenkor általában helytelen választás az enum

Trükkös konstans

enum { MERET=100 };

int i, tomb[MERET];     // fordítási idejű konstans!

for (i=0; i<MERET; ++i)
   scanf("%d", &tomb[i]);

Persze így csak egész szám konstanst lehet létrehozni. Ha a felsorolt típus neveihez egész számértéket rendelünk, akkor még akár azt is megtehetjük, hogy az egyes nevekhez ugyanazt. Ilyenkor azok egymással ekvivalens nevek lesznek.

enum Cella {
   ures,
   kor,
   iksz
};

typedef enum Cella Cella;

/* egyben a typedeffel */

typedef enum Cella {
   ures,
   kor,
   iksz
} Cella;

/* rögtön két változó is */

enum Cella {
   ures,
   kor,
   iksz
} c1=ures, c2=iksz;

/* névtelenül - ritkán */

enum {
   ures,
   kor,
   iksz
} palya[3][3];

Ugyanazok a szintaktikák használhatóak, mint a struct esetén. Névtelen típust azonban nem ajánlott létrehozni – ha más miatt nem, azért, mert a fordító a hibaüzeneteiben nem tud rá hivatkozni.

enum Lampa {
   piros,
   piros_sarga,
   sarga,
   zold
};

/* a lámpa állapota */
enum Lampa lampa1;


/* az egyes lencsék */
int p, s, z;

switch (lampa1) {
   case piros:       p=1; s=0; z=0; break;
   case piros_sarga: p=1; s=1; z=0; break;
   case zold:        p=0; s=0; z=1; break;
   case sarga:       p=0; s=1; z=0; break;
}

Állapotgépek

Feladat: megkeresni a beírt szövegben a szmájlikat, és utána úgy kiírni a szöveget, hogy képek szerepelnek benne helyettük.

Szmájli	Ezt kell beírni
	:)  :-)
	:D  :-D
	8-)
	:(|)
	<3

Karakterek olvasása: a printf, scanf %c-n kívül használhatóak:

int getchar(); // beolvas

int putchar(int); // kiír

Nagyon fontos: a getchar() visszatérési típusa int!

int c;
c=getchar();
if (c == EOF)
   printf("Bemenet vége!");
else
   printf("Karaktert olvastam, kódja: %d", c);

Példa

Ez a ploglam minden 'r' betűt 'l' betűle cselél:

#include <stdio.h>

int main()
{
   int c;   /* kalaktel */

   while ((c=getchar()) != EOF) // éltékadás is egyben!
      if (c=='r')
         putchar('l');
      else if (c=='R')
         putchar('L');
      else
         putchar(c);

   return 0;                    // letuln zéló
}

Feladat: olvassunk be egy szöveget. Számoljuk meg benne az ly betűket:

• Az ly 1-nek számít: lyuk,
• az lly 2-nek: gally,
• nagybetűkkel most ne foglalkozzunk.

A probléma nehézsége

• Önmagában egyik karakternél sem egyértelmű a teendő!
• l-nél: nem tudjuk, mit kell majd csinálni: alma, lyuk, gally
• y-nál: a teendő attól függ, előbb mi történt: négy, lyuk

Azt azért sejtjük, hogy a végleges döntés az y karakternél fog megszületni. Az l-nél nem lehet, hiszen a jövőbe nem látunk. Úgyhogy az utóbbi gondolatmenet a járható út. Eltárolni a teljes szöveget viszont felesleges, hiszen elég mindig csak egy kis részletet látni belőle. A kidolgozatlan ötlet ezek alapján:

sz=0;

while ((c=getchar()) != EOF) {
   if (c=='y')              // ha ez egy y
      switch (… ELŐZMÉNYEK …) {
         case ………:
            sz+=1;          // … és l volt előtte
            break;
         case ………:
            sz+=2;          // … és ll volt előbb
            break;
         default:
            break;          // egyéb esetben semmi teendő
      }
}

printf("%d darab ly szerepelt.\n", sz);

Állapotgép (véges automata, finite-state machine)

Működése: az eddig kialakult állapottól és az eseménytől függ:

• Az elvégzendő tevékenység
• A következő állapot

Állapotok a múlt alapján

+0 négy
+1 lyuk
+2 gally

Három állapot lehetséges:

• Előbb l volt
• Előbb ll volt
• Valami más karakter volt előbb

Ez eltárolható egy változóban → felsorolt típus (enum).

Tervezzük meg! Melyik állapotban, milyen esemény hatására, mi a teendő?

Az állapottábla felépítése a következő. A táblázat sorai az egyes állapotokat mutatják (amelyekbe valamely régebbi események alapján került az automata). A táblázat oszlopai pedig az eseményeket (ezek most a beérkező karakterek). Minden eseménynél, vagyis minden karakter olvasásánál az aktuális állapottól és az éppen beolvasott karaktertől függően dől el az, hogy mit kell csinálni (tevékenység) és hova kell ugrani (állapot). Gyakran ezt két külön táblázatban adják meg – itt most az állapot- és tevékenységtábla egy táblázatba összegyúrva szerepel.

Számláló: 0

Az állapotgép működését gráffal is megadhatjuk:

Ez a megadás teljesen ekvivalens a táblázattal. Minden állapotra (a gráf csúcsai) megadja, hogy az egyes eseményeknél (élekre írt karakterek) mi a teendő. A nyíl az új állapot felé mutat, illetve az elvégzendő tevékenység is az él mellé írva szerepel.

typedef enum Allapot {
  alap,
  l_volt,
  ll_volt
} Allapot;

Allapot all=alap; /* kezdeti */

while ((c=getchar()) != EOF) {
  switch (all) {
    case alap:   // alap állapot
      if (c=='l')
        all=l_volt;
      break;

    case l_volt: // már volt egy 'l'
      switch (c) {
        case 'l': all=ll_volt; break;
        case 'y': szaml+=1; all=alap; break;
        default:  all=alap; break;
      }
      break;

    case ll_volt:

	normál	:	)	<	3
alap	→alap c	→kettőspont (semmi)	→alap c	→kisebb (semmi)	→alap c
kettőspont	→alap :, c	→kettőspont :	→alap	→kisebb :	→alap :, c
kisebb	→alap <, c	→kettőspont <	→alap <, c	→kisebb <	→alap

Itt is az állapotgép táblázatában minden cella tartalmaz egy következő állapotot (fent) és egy tevékenységet (lent). A tevékenység minden esetben valamilyen karakter vagy karakterek kiírását jelenti. c-vel jelöltem az épp beolvasott karakter képernyőre másolását; a többi kiírásnál pedig a megadott jelet kell majd a programnak kiírnia (pl. kisebb jel vagy kettőspont).

Tábla → táblázat → csináljunk 2D tömböt a kódban!

• Minden cellában egy tevékenység és egy állapot. Ez azt jelenti, hogy struktúrák 2D tömbje lesz.
• A sorokat az állapot szerint indexeljük: tabla[all]
• Az oszlopot a karakter szerint indexeljük: tabla[all][kar_o]
• A tevékenységek: jelöljük meg enum-mal

A tevékenység az ly számláló példájában könnyen leképezhető akár egy egész számra. Összetettebb esetben ún. függvénymutatókat szokás ehhez használni, ez későbbi előadáson szerepel majd. Egész számokra a tevékenység azonban nem csak így képezhető le; el is nevezhetjük a tevékenységeket egy másik felsorolt típussal, és a programban aszerint switch()-elhetünk a tevékenység végrehajtásakor. Lásd lentebb.

typedef enum Allapot {        // állapot → egész szám
   Aalap, Akettospont, Akisebb
} Allapot;

int karakterosztaly(char c) { // char fajtája → egész szám
   switch (c) {
      default:  return 0;     /* sorminta, de csak kicsit */
      case ':': return 1;
      case ')': return 2;
      case '<': return 3;
      case '3': return 4;
   }
}

typedef enum Tevekenyseg {    // mit írunk ki?
   Tmosolyog, Tsziv, Takt, Tkpont,
   Tkpont_akt, Tkisebb, Tkisebb_akt, Tsemmi
} Tevekenyseg;

A fenti switch () szerkezetben a break utasítások elhagyhatóak, hiszen a return utáni részek úgysem hajtódnak végre a függvényből. Kicsit „sormintás”, de ha nem így lenne, akkor meg egy 256 elemű tömbre lenne szükségünk, amiben szinte minden érték nulla, csak néhány másik van – úgyhogy most jó lesz ez a megoldás is.

Itt legegyszerűbb, ha hagyjuk a fordítónak, a felsorolt típus egyes értékeihez az alapértelmezetteket társítsa. Azok 0, 1 és 2 lesznek. Mivel 0-tól számozódik, pont jó lesz számunkra tömbindexnek is.

struct TablaCella {      // tevékenység és köv. állapot
   Allapot all;
   Tevekenyseg tev;
} allapotgep[3][5] = {
   { {…}, {…}, {…}, {…}, {…} },
   { {…}, {…}, {…}, {…}, {…} }, // egy sor
   { {Aalap, Tkisebb_akt},
     {Akpont, Tkisebb},          // egy cella { }
     {Aalap, Tkisebb_akt},
     {Akisebb, Tkisebb},
     {Aalap, Tsziv} },
};

A fenti kódrészlet mutatja a struktúra definícióját, és a táblázat egy sorának kifejtését a kódban. A kifejtett sor az alábbi.

struct TablaCella {
   Tevekenyseg tev;
   Allapot all;
} allapotgep[3][5];

void csinal(Tevekenyseg t, char akt);

…

Allapot all;
int c;

all=Aalap;
while ((c=getchar())!=EOF) {
  int kar=karakterosztaly(c);

  csinal(allapotgep[all][kar].tev, c);
  all=allapotgep[all][kar].all;
}

A táblázatból kiolvassuk a tevékenységet és a következő állapotot.

Előnyök

• Tervezésnél: a tervezés eszköze!
• A felesleges állapotok kiszűrhetők
• Kódolásnál: mechanikusan kódolható
• Áttekinthetőbb, érthetőbb a kód, mint egy ad-hoc megoldás

Felhasználásuk

• Szűrőprogramok (fájlok feldolgozása); fordítóprogramok, nyelvi elemzők (pl. /* kommentek */ kiszűrése)
• Alkalmazások vezérlése (pl. egér kattintások, mozdulatok)
• Internetes alkalmazások kommunikációja (protokollok)
• Hardver: a processzor egy nagy állapotgép!

Érdekesség: hardver oldalról is fontos az állapotgép. A számítógép belseje is tele van ilyenekkel. A processzor működését is egy állapotgép vezérli: utasítás beolvasása, beolvasott utasítás dekódolása, utána további operandusok beolvasása (már a dekódolt utasítás jelentése alapján) stb. Erről Digitből lesz szó.