Kontrol-egitura

Informatikako arloan, **kontrol-egitura**k programa baten exekuzio-fluxua bideratzeko erabiltzen dira. Kontrol-egituren (edo kontrol-sententzien) bitartez, prozesu errepikakor bat hainbat aldiz exekutatu daiteke, edo egiturak erabakiak har dezake. Egitura hauek garrantzi handia dute, programa baten fluxua kontrolatzen baitute behar den heinean.

Programazio-lengoaia gehienetan kontrol-egituren kanpo-itxura eta barne-funtzionamendua alda daiteke, baina emaitzari begira berdintasunak aurki daitezke. Hona hemen adibide batzuk:
* *If-Then-Else*: bi sekuentzia multzo ezberdin daude. Multzo horien aurretik baldintza bat dago. Baldintzaren arabera, multzo bat edo bestea exekutatuko da.
* *Switch-Case*: hainbat sekuentzia multzo ezberdin daude.  Zein multzo exekutatuko den, aldagai baten balioak finkatuko du. Adibidez: Aldagai bat bikoitia baldin bada, lehen multzoa exekutatuko da. Aldiz, bakoitia baldin bada, bigarren multzoa izango da exekutatuko dena.
* *While* begizta: baldintza bat betetzen den bitartean, sekuentzia multzo bat errepikatuko da.
* *For* begizta: Sententzia multzo bat exekutatuko da zenbait alditan.
Kontrol-egitura guztiek sarrera bakarra dute, baina bide desberdinetan bukatu daitezke. Hiru talde ezberdinetan sailkatu daitezke: sekuentzialak edo aukerazkoak, iteratiboak eta aurreratuak (bien arteko konbinazioak).

Programazio-lengoaia berri guztiek antzeko kontrol-egiturak dituzte. Horietan aldatzen den gauza bakarra sintaxia da, hau da, egitura idatziz adierazteko modua.

## Kontrol-egitura motak 
Kontrol-egitura motak,  programatzaileari komeni zaion agindua exekutatzeko ematen duen agindu edo agindu multzo ezberdinak dira.

### Aurrekariak 
Kontrol-egituren aurrekari nabarmenena *goto* agindua izan daiteke (ingelesetik datozen “go” eta “to” hitzen elkarketatik sortua) eta programaren fluxua aurrez ezarritako toki batera birbideratzeko erabiltzen da. Hala ere, agindu hau arriskutsua izendatua izan da hainbat zientzialari informatikoengatik, Dijkstra esaterako, programaren exekuzio sekuentziala eteten du eta.

### Exekuzio sekuentziala 
Idatzitako sententziak bata bestearen ondoren exekutatzen direnean,  exekuzio sekuentziala egiten dela deritzo.

### Kontrol-transferentzia 
Hainbat programazio-hizkuntzetan, Javan edo C lengoaietan esaterako, programatzaileak erabaki dezake exekutatuko den hurrengo sententzia kodeko hurrengoa ez izatea. Hori kontrol-transferentzia bezala ezagutzen da. Aurrekoa praktikan jartzeko, hainbat agindu ezberdin erabil ditzakegu. Adibide gisa dugu aurrez aipatutako *goto* edota *break* aginduak. begizta batetik irteteko erabiltzen da, hau da, begiztari bukaera emateko.

### Aukerazko kontrol-egiturak 
Egitura hauek baldintza baten arabera exekuzio-fluxua birbideratuko dute.

#### *If* hautaketa sinplea 
Egitura honek baldintza bat betetzen den edo ez begiratuko du. Betetzen den kasuetan, irudian agertzen den moduan, lehen sententzia-blokea exekutatuko du. Betetzen ez denean, ordea, bigarren sententzia-blokea izango da exekutatuko dena.
```c
if (Baldintza) {
    (1. sententzia-blokea)
} else {
    (2. sententzia-blokea)
}
```
Baina, *n* baldintza ezberdin ere kudeatu daitezke *if* bat erabilita. Jarraian, adibide bat jarriko dugu hori hobeto ikusteko. Lehenengo baldintza adierazteko aurrekoan bezala, *if* bat erabiliko dugu. Hala ere, hurrengo baldintzak adierazteko *else if* komandoa erabiliko dugu. Bigarren honekin, nahi beste baldintza sartu ahal izango ditugu. Horren funtzionamendua honako hau izango da.

1. baldintza betez gero, 1. sententzia-blokea exekutatuko da. Hori horrela ez bada, 2. baldintza begiratuko da. Egia bada, 2. sententzia egia bada 2. sententzia-blokea exekutatuko da, eta hurrengo baldintzekin konparatuz joango da, baldintza bete arte edo *n*. baldintzara iritsi arte. Horietako bat bera ere betetzen ez bada, *else* sententzia-blokea exekutatuko da.
```c
if (1. baldintza) {
    (1. sententzia-blokea)
} else if (2. baldintza) {
    (2. sententzia-blokea)
.....
} else if (n. baldintza) {
    (n. sententzia-blokea)
} else {
    (Else sententzia-blokea)
}
```
*If*-aren erabilera hain da xamurra, gehiegi erabiltzera bultzatzen baitdu. Gaur egun *if* sententziaren aurkako kanpaina bat existitzen da “Anti-if campaign” deritzona, *if*-aren erabilera mugatu baten alde ekiten duena.

#### *Switch-Case* (*Select-Case* programazio-lengoaia askotan) 
Sententzia honek akzio bat exekutatzen du askoren artean, adierazpen baten balioaren arabera.

Adierazpen bera balio ezberdinekin alderatzea nahi denean, *if then* sekuentzia, *else* sekuentziaren ordez erabil daiteke. *Switch-case* batek funtzio bera dauka:
* Adierazpena ebaluatu egiten da, eta horren emaitza zenbaki bat izango da.

* Ondoren, *case* guztiak alderatuko dira, zenbaki bereko beste balio baten bila.
* Adierazpenaren baliokide bat aurkitzean, dagokion sententzia-blokea exekutatuko da.
* Behin blokea exekutatuta, hurrengo *case*-ko sententzia exekutatzen jarraituko du. Hau ekiditeko *break* agindua jarri behar da amaieran (bigarren kasuan ikus daitekeen bezala).

* Adierazpenaren balioa ez bada *case*  delakoetan aurkitzen, *default* aukeran dagoen sekuentzia-blokea exekutatuko da.
```c
switch (adierazpena) {
    case (1. balioa):
        (1. sententzia-blokea)
    case (2. balioa):
        (2. sententzia-blokea)
        break;
    case (n. balioa):
        (n. sententzia-blokea)
    default:
        (Else sententzia-blokea)
}
```

### Kontrol-egitura iteratiboak 
Egitura iteratibo edo errepikapenezko egituretan, sententzia-blokea exekutatzeko, baldintza bat bete behar da. Baldintza hori betetzen den bitartean, sententzia-blokea errepikatuko da. Baina baldintza hori behin betetzen ez den aldiunean, egitura hori atzean geratu eta hurrengo egitura exekutatuko da.

#### *While* begizta 
Baldintza egia den bitartean, hurrengo sententziak exekutatuko dira. Bi motatakoak daude: Aade batetik, baldintza aurrez egiaztatzen dutenak, eta bestalde, begiztaren zikloa amaitzean egiaztatzen dutenak.
```c
while (Baldintza) {
    (Sententzia-blokea)
}
```

```c
do {
    (Sententzia-blokea)
} while (Baldintza);
```

#### *For* begizta 
*For* sententziak begizta bat sortzen du, eta sententzia-bloke bat *n* aldiz errepikatzea ahalbidetzen du.
* Hasieran, eta behin bakarrik, begiztak aldagai bat sortu eta hasieratuko du (`int i = 10`, hurrengo kasuan).

* Ondoren, begiztako baldintza (`i > 0`) begiratuko da. Hau ez denean betetzen, begiztatik irtengo da. Betetzen bada, beste ziklo bat hasiko da.
* Ziklo bakoitzean begiztako ekintza burutuko da (`i--`, aldagaia gutxitu, kasu honetan).

```c
for (int i = 10; i > 0; i--) {
    (Sententzia-blokea)
}
```

### Habiaratutako egiturak 
Oinarrizko kontrol-egiturak bata bestearen barruan erabili daitezke:

#### *For* egitura *If-Then-Else* egitura baten barnean 
```c
if (A > B) {
    for (int x = 0; x  0) {
    for (int i = 10; i > 0; i--) {
        (Sententzia-blokea)
    }
    x = x - 1
}
```

## Erreferentziak 
## Bibliografia 
* http://di002.edv.uniovi.es/~dani/asignaturas/transparencias-leccion4.PDF
* http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf
* http://www.alegsa.com.ar/Dic/estructura_de_control.php
* https://web.archive.org/web/20180716171336/http://www.fortran.com/fortran/come_from.html

## Kanpo estekak