Goto
<s>GoTo je kontrolna struktura, odnosno direktiva, naredba, "komanda" (engl. statement) koja postoji u mnogim programskim jezicima.</s><s>Izvršava jednosmjerni prenos kontrole toka (programski skok) do odredjene lokacije u izvornom kôdu programa.</s><s>Lokacija se uglavnom identificira imenovanom labelom, ili rednim brojem linije.</s><s>U današnje vrijeme ova naredba se u programiranju uglavnom izbjegava, te postoji kritički odnos prema uporebi ove naredbe u strukturiranim programskim jezicima.</s>

<s>Naziv</s>

<s>Programski jezici koji imaju goto, na različite načine i s različitim kombinacijama velikih i malih slova (kapitalizacija) su imenovali ovu direktivu, npr:</s>

<s>GOTO (samo kapitalna slova) - FORTRAN, BASIC;</s>

<s>GO TO (kapitalno, razdvojene riječi) - Neke stare verzije Basica u Time-sharing sistemima;</s>

<s>goto (samo verzalna slova) - C, C++, C#;</s>

<s>goto, Goto, GoTo ... (nebitna kapitalizacija) - Pascal i drugi programski jezici koji ne razlučuju kapitalizaciju identifikatora i rezerviranih riječi (engl. keyword).</s>

<s>Upotreba</s>

<s>Sintaksa goto kontrolne strukture u svim jezicima je uglavnom ista:</s>

<s>goto <Destination></s>

<s>gdje destinacija može biti označena linijskim brojem (BASIC, FORTRAN 77) ili labelom, posebnom imenovanom "konstantom" (Pascal, C/C++).</s><s>Direktiva goto se obično upotrebljava unutar If-Then-Else blokova, na sledeći način:</s>

<s>if <Expression> then
  goto <LabelName1>
else
  goto <LabelName2></s>

<s>Programski jezik Pascal zahtijeva deklaraciju labele, kao i bilo koje druge varijable, konstante ili tipa podataka, dok se destinacija obilježava imenom labele iza koje slijedi dvotočka:</s>

<s>label
  DstX;</s>

<s>goto DstX;</s>

<s>{ ... }</s>

<s>DstX:
  { ... }</s>

<s>Upotreba naredbe goto naročito je bila česta u starijim programskim jezicima sekvencijalnoga karaktera, umjesto pozivanja podprograma (funkcija ili procedura), kako se to inače radi u proceduralnim i funkcijskim jezicima.</s><s>Za razliku od poziva funkcije, koji vraća kontrolu toka programa natrag nakon izvršenja, naredba goto prenosi kontrolu toka samo u jednom smjeru.</s><s>Zbog toga nije pogodna za strukturirano programiranje i pisanje pregledna, uredna programskoga koda, što je dovelo do kritika protiv upotrebe naredbe još 60-ih godina 20. stoljeća.</s>

<s>Neki programski jezici ne podržavaju ovu naredbu, kao npr. Java, iako je u Javi goto rezervirana riječ (engl. keyword), što znači da se ne može koristiti za imenovanje identifikatora.</s><s>Proceduralni programski jezici Pascal i C/C++ podržavaju goto, ali ne dopuštaju skakanje izvan dosega funkcije ili procedure.</s><s>PHP nije imao goto sve do verzije 5.3.</s>

<s>Primjeri</s>

<s>Pascal</s>

<s>{$id: ALGMD-20100530}
unit Harmful;</s>

<s>interface(*********************************************************************)</s>

<s>function ProdOfInts(Op1, Op2: LongInt): LongInt;
function PowerOfInt(Base: LongInt; Exp: LongInt): LongInt;</s>

<s>implementation(****************************************************************)</s>

<s>var
  Result: LongInt;</s>

<s>function ProdOfInts(Op1, Op2: LongInt): LongInt;
label
  0, 1;
begin
0:
  Result := 0;
1:
  Result := Result + Op1;
  Op2 := Op2 - 1;</s>

<s>if Op2 <> 0 then
    goto 1
  else if Op2 = 0 then
    ProdOfInts := Result;
end;</s>

<s>function PowerOfInt(Base: LongInt; Exp: LongInt): LongInt;
begin
  Result := 1;</s>

<s>while Exp <> 0 do
  begin
    Exp := Exp - 1;
    Result := ProdOfInts(Base, Result);
  end;</s>

<s>PowerOfInt := Result;
end;</s>

<s>begin(********************************************************************)end.</s>

<s>Windows CMD</s>

<s>@echo off</s>

<s>setlocal
set project=Harmful
set options=-Sg -WN -Xs -XX</s>

<s>call :main
endlocal
goto :eof</s>

<s>:main
fpc %project%.pp %options%</s>

<s>if exist %project%.pp* (
	goto :eof
) else (
	call :error
)</s>

<s>goto :eof</s>

<s>:error
echo:
echo Compilation error.
pause</s>

<s>:eof</s>

<s>Varijacije</s>

<s>Razgranati Goto</s>

<s>Osim jednostavne direktive goto, još u starijim, nestrukturiranim verzijama Fortrana i Basica postojala je i složenija kontrolna struktura - izračunati goto ili razgranati goto.</s><s>Za razliku od obične goto instrukcije, razgranati goto omogućuje više od jedne destinacije za programski skok, u ovisnosti o vrijednosti kondicionalne varijable ili izraza (ekspresije) unutar razgranate strukture.</s><s>U Fortranu sintaksa izgleda ovako:</s>

<s>goto (l1, l2, ... ln) <expr></s>

<s>Na primjer:</s>

<s>GOTO (20, 30, 40) i</s>

<s>U ovom primjeru programski skok će se izvršiti na osnovi vrijednosti cjelobrojne (integer) varijable i. Za svako i = n, GOTO skače do one destinacije u listi (navedene u zagradi), za koju vrijedi da je njezin redni broj u listi jednak vrijednosti varijable i. Dakle:</s>

<s>? (i = 1) -> goto 20
 ? (i = 2) -> goto 30
 ? (i = 3) -> goto 40</s>

<s>Za bilo koju drugu vrijednost i različitu od 1, 2, 3, ne će se izvršiti nijedan od skokova.</s>

<s>Basic je imao sličnu razgranatu strukturu s istom funkcionalnošću, ON ...</s><s>GOTO, odnosno GO TO ...</s><s>OF ... (u ovisnosti o verziji Basica).</s><s>Primjer upotrebe:</s>

<s>50 ON i GOTO 100, 200, 300, 400</s>

<s>Starija, manje poznata varijanta:</s>

<s>50 GO TO N OF 100, 200, 300, 400</s>

<s>U modernijim, strukturiranim programskim jezicima, umjesto ove razgranate strukture koristi se različito nazvana instrukcija višestrukoga izbora: switch (C/C++), case (Pascal), select case (Fortran 90, QBasic, Visual Basic).</s>

<s>Slične naredbe</s>

<s>GoSub</s>

<s>GOSUB ili GO SUB je naredba u Basicu za pozivanje podprograma.</s><s>Za razliku od GOTO naredbe u Basicu, koja vrši jednosmjeran transfer kontole toka, GOSUB omogućuje povratak na mjesto pozivanja, nakon izvršenja podprograma, pomoću ključne riječi RETURN.</s>

<s>GOSUB <expr> <...> RETURN</s>

<s>Kako je GOSUB ...</s><s>RETURN konstrukcija u Basicu riješena na posve nestrukturiran način, iza koda glavnoga programa i prije početka pisanja podprograma mora se navesti ključna riječ STOP, da bi se osiguralo da program nakon izvršenja glavnoga dijela ne nastavi izvršavanje svih navedenih podprograma onim redom kojim su upisani.</s>

<s>Primjer:</s>

<s>10 REM *** Rješavanje kvadratne jednačbe ***
20 PRINT "Koliki su koeficijenti a, b, c? "
30 INPUT A, B, C
40 GOSUB 500
45 IF (B^2 - 4*A*C) < 0 THEN 10
50 PRINT "Korijeni ove jednačbe su: "
60 PRINT "x1 = "; X1 "x2 = "; X2
70 STOP
500 REM *** Podprogram za determinantu ***
510 IF (B^2 - 4*A*C) < 0 THEN 600
520 X1 = (-B + (B^2 - 4*A*C)^(1/2)) / (2*A)
530 X2 = (-B + (B^2 - 4*A*C)^(1/2)) / (2*A)
540 GOTO 610
600 PRINT "Determinanta je manja od nule. "
610 RETURN
620 END</s>

<s>On ...</s><s>GoSub</s>

<s>Slično kao razgranati GOTO, i GOSUB ima svoju razgranatu varijantu.</s><s>GOSUB instrukcija koja odlučuje o programskom skoku na osnovi evaluacije izraza, ima sledeći oblik:</s>

<s>ON <expr> GOSUB <d1, d2, d3, ... dn></s>

<s>Manje popularna varijanta u nekim starijim BASIC interpreterima / Time-sharing sistemima:</s>

<s>GO SUB <expr> OF <d1, d2, d3, ... dn></s>

<s>Npr:
50 GOSUB X OF 110, 210, 320, 1400</s>

<s>Izvršenje:</s>

<s>x = 1 : GOTO 110;
 x = 2 : GOTO 210;
 x = 3 : GOTO 320;
 x = 4 : GOTO 1400;
 x < 1 : GOSUB se ne izvršava;
 x > 4 : GOSUB se ne izvršava, jer su zadane samo 4 destinacije;</s>

<s>Break & Continue</s>

<s>U programskom jeziku C, osim goto postoje i naredbe za skok iz petlje.</s><s>Naredba break prekida izvršavanje petlje unutar koje je pozvana vraćajući tok programa na lokaciju prije pojavljivanja petlje, dok continue ponovno testira brojač (ako je u pitanju for iteracija) ili uslov iteracije (kod while petlji).</s><s>Primjeri korištenja break i continue skokova preuzeti su iz knjige Programski jezik C autora Dennisa Ritchieja i Briana Kernighana.</s>

<s>Break</s>

<s>/* trim: remove trailing blanks, tabs, newlines */
int trim(char s[])
{
	int n;</s>

<s>for (n = strlen(s)-1; n >= 0; n--)
		if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
			break;</s>

<s>s[n+1] = '\0';
	return n;
}</s>

<s>Continue</s>

<s>for (i = 0; i < n; i++)
	if (a[i] < 0) /* skip negative elements */
		continue;</s>

<s>/* do positive elements */</s>

<s>Izvori</s>

<s>Računarstvo
Programiranje
Programske paradigme</s>

