1/10

POTPROGRAMI - Podsetnik 01. Šta su potprogrami? Potprogrami su delovi programa, zasebne celine, blokovi programskih redova, koji imaju svoje ime, listu parametara, oznaku tipa povratne vrednosti (ako je reč o funkcijama), i naravno, oznaku za početak i kraj. Potprogrami se izvršavaju tako što se pozivaju iz glavnog programa ili drugih potprograma ili iz sebe samih (tada je reč o rekurziji, o čemu će biti više reči na jednom od narednih susreta). 02. Kako potprogrami funkcionišu? Poziv potprograma iz glavnog progama (Main) ćemo ilustrovati vrlo jednostavnim primerom. Napomena: U narednom kodu, brojevi ispred programskih redova NISU sastavni deo programa, već samo služe za jednostavnije objašnjenje.

Kreće se od reda 01, pošto je to oznaka početka glavnog programa. Glavni program se završava redom br. 06. Izvršava se red 02 i kao rezultat tog reda se na monitoru ispisuje poruka Nalazim se u Main-u. Nakon ispisa, program prelazi na red br. 03, gde se nalazi poziv potprograma Pozdravi (to što se posle naziva potprograma nalaze otvorena i zatvorena zagrada bez sadržaja između, znači da potprogram nema parametre, o čemu će biti više reči kasnije). Dakle, pozvan je potprogram Pozdravi. On počinje u redu br. 08 i završava redom br. 10. Kada dođe do reda br. 03, program "skače" na red 08. Telo potprograma je u ovom slučaju sastavljeno samo od jednog reda, čiji je broj 09. Taj red ispisuje poruku Dobar dan, nalazim se u Sub-u koji se zove 'Pozdravi'. Posle tog reda nailazi na red 10 koji nosi oznaku kraja potprograma. To je ujedno naređenje programu da se vrati na mesto odakle je pozvan, a to je kraj reda 03, još tačnije, pozicija posle zatvorene zagrade u redu 03. Pošto posle zatvorene zagrade nema ničega (komentar se ne računa kao programski kod), prelazi se na naredni red, red br. 04, koji ispisuje poruku Ponovo sam u Main-u. Posle ispisa sledi čekanje na pritisak na taster ENTER. Izgled ekrana je dat na narednoj slici:

01 Sub Main()02 Console.WriteLine("Nalazim se u Main-u")03 Call Pozdravi() 'Poziv podprograma04 Console.WriteLine("Ponovo sam u Main-u")05 Console.ReadLine()06 End Sub0708 Sub Pozdravi()09 Console.WriteLine("Dobar dan, nalazim se u Sub-u koji se zove 'Pozdravi'")10 End Sub

Podprogram Pozdravi

Glavni program

1

2

2/10

Rečeno je da se potprogram može pozvati i iz nekog drugog potprograma. Ilustrujmo to primerom: 01 Sub Main() 02 Console.WriteLine("Nalazim se u Main-u") 03 Call Pozdravi() 'Poziv potprograma koji nema argumente 04 Console.WriteLine("Ponovo sam u Main-u") 05 Call DrugiPotprogram() 06 Console.WriteLine("Kraj programa") 07 Console.ReadLine() 08 End Sub 09 10 Sub Pozdravi() 11 Console.WriteLine("Dobar dan, nalazim se u Sub-u koji se zove 'Pozdravi'") 12 End Sub 13 14 Sub DrugiPotprogram() 15 Console.WriteLine("Ovo je Drugi potprogram") 16 Call Pozdravi() 17 End Sub Izgled ekrana:

Objašnjenje: U redu br. 03 se najpre poziva potprogram Pozdravi(), a potom u redu 05 potprogram koji se zove DrugiPotprogram(). U okviru tog potprograma (redovi 14-17) se ispisuje na monitoru poruka Ovo je Drugi potprogram (red 15), a potom se u redu 16 poziva potprogram Pozdravi(). Program "skače" na red 10, izvršava telo potprograma Pozdravi(), posle čega se vraća na kraj reda 16. Potom prelazi na red 17, koji označava kraj potprograma DrugiPotprogram, što je ujedno naređenje programu da se vrati na mesto odakle je potprogram DrugiPotprogram pozvan, a to je kraj reda 05. Redovi koji će se posle ovog još izvršiti su 06-08.

01 Sub Main()02 Console.WriteLine("Nalazim se u Main-u")03 Call Pozdravi() 'Poziv podprograma koji nema argumente04 Console.WriteLine("Ponovo sam u Main-u")05 Call DrugiPodprogram()06 Console.WriteLine("Kraj programa")07 Console.ReadLine()08 End Sub0910 Sub Pozdravi()11 Console.WriteLine("Dobar dan, nalazim se u Sub-u koji se zove 'Pozdravi'")12 End Sub1314 Sub DrugiPodprogram()15 Console.WriteLine("Ovo je Drugi podprogram")16 Call Pozdravi()17 End Sub

Podprogram DrugiPodprogram

Podprogram Pozdravi

Glavni program

1

2

3

4

5

6

3/10

03. Koji su osnovni tipovi potprograma? Kako funkcioniše Function? Potprogrami se razlikuju po tome da li imaju povratnu vrednost ili ne. Ako potprogram nema povratnu vrednost, reč je o Sub potprogramu, a ako potprogram ima povratnu vrednost, onda se radi o potprogramu tipa Function. U prethodna dva primera smo koristili potprograme tipa Sub. Sledi ilustracija potprograma tipa Function. 01 Sub Main() 02 Dim a, b As Integer 03 04 a = 5 05 b = IzracunajKvadrat(a) 'Poziv potprograma tipa Function. Potprogram vraca vrednost koja se dodeljuje promenljivoj b 06 Console.WriteLine("Vrednost promenljive b posle poziva IzracunajKvadrat je " & b) 07 Console.ReadLine() 08 End Sub 09 10 Function IzracunajKvadrat(ByVal Broj As Integer) As Integer 11 Console.WriteLine("Nalazim se u funkciji 'IzracunajKvadrat'")

12 Return (Broj ^ 2) 13 End Function Napomene: kao što je u prethodnim susretima već objašnjeno, u redu br. 05, računar će promenljivoj koja se nalazi sa leve strane znaka jednakosti dodeliti onu vrednost koja se nalazi sa desne strane znaka jednakosti. Sa desne strane znaka = se nalazi POZIV FUNKCIJE IzracunajKvadrat. Argument koji se šalje u funkciju je promenljiva a, tačnije, njena vrednost (detaljnije o ovome u objašnjenju razlike između ByVal i ByRef). Drugim rečima red 05 računar vidi kao 05 b = IzracunajKvadrat(5) Izvršenje programa se "seli" u red 10, gde se promenljivoj Broj (a to je PARAMETAR funkcije IzracunajKvadrat) dodeljuje vrednost 5. Drugim rečima, vrednost koju smo u redu 05 poslali funkciji IzracunajKvadrat (a to je vrednost ARGUMENTA a) se u redu 10 dodeljuje PARAMETRU Broj. PARAMETRI su promenljive koje se deklarišu u ZAGLAVLJU potprograma i vidljive su samo u potprogramu kojem pripadaju. U ostalim delovima programa NISU vidljive. Argumenti koji se šalju u potprogram NISU VIDLJIVI u potprogramu, zato treba da predaju svoju vrednost PARAMETRU. O vidljivosti (engl. scope) i životnom veku (engl. lifespan) promenljivih će biti više reči na narednim susretima. Pokušajte da ispišete vrednost argumenta a u potprogramu IzracunajKvadrat, odnosno, pokušajte ispis vrednosti parametra Broj u glavnom programu. Šta se desilo? Ključnu reč ByVal za sada nećemo objasniti. As Integer posle zatvorene zagrade označava tip vrednosti koju funkcija vraća, što ćemo uskoro detaljnije objasniti. Dakle, u redu br. 10 promenljiva (parametar) Broj je dobila vrednost 5, program prelazi na red 11, ispisuje poruku Nalazim se u funkciji 'IzracunajKvadrat'. Sledi red br. 12, čiji je sadržaj: Return (Broj ^2). Umesto promenljive Broj program, naravno, vidi broj 5, usled čega sadržaj između zagrada postaje 25, odnosno, red br. 12 računar vidi kao 12 Return (25) Return je naredba za povratak na mesto poziva funkcije, a to je red 05. Za razliku od povratka iz potprograma Sub, kada se odvijanje programa nastavlja sa izvršavanjem prvog reda koji sledi posle poziva Sub-a (podsetite se prethodnih primera sa Sub-ovima), u slučaju funkcija, POZIV FUNKCIJE SE ZAMENJUJE POVRATNOM VREDNOŠĆU, odnosno, kada se program iz reda 12 vrati na red 05, dešava se sledeće:

U redu br. 6 program ispisuje poruku, u redu 07 čeka da se pritisne ENTER, a sa radom prestaje u redu 08. Izgled ekrana je prikazan na narednoj slici.

05 b = IzracunajKvadrat(5)Zamenjuje se povratnom vrednošcu funkcije IzracunajKvadrat, tj. brojem 25

05 b = 25

Argument

Parametar

4/10

04. Iz čega se sastoje potprogrami? Do sada ste i sami zaključili: Potprogram tipa Sub počinje ključnom rečju Sub, a završava sa End Sub. Potprogram tipa Function počinje sa ključnom rečju Function, a završava se sa End Function. Posle ključih reči Sub, odnosno, Function, sledi naziv potprograma. Posle naziva potprograma, ukoliko postoji, navodi se lista parametara. Kod potprograma tipa Function, posle liste parametara navodi se tip povratne vrednosti. Kao što je rečeno, kod Sub-ova nema povratne vrednosti. 01 Sub Main() 02 Dim c, c As Integer 03 Dim Kamata As Single 04 05 c = 5 06 d = 8 07 08 Call IspisiZbir(c, d) 09 Kamata = ZateznaKamata(10000, 100, 0.5) 10 Console.WriteLine("Zatezna kamata je " & Kamata) 11 12 Console.ReadLine() 13 End Sub 14 15 Sub IspisiZbir(ByVal a As Integer, ByVal b As Integer) 16 Dim Zbir As Integer 17 Zbir = a + b 18 Console.WriteLine("Zbir brojeva " & a & " i " & b & " je " & Zbir) 19 End Sub 20 21 Function ZateznaKamata(ByVal Glavnica As Single, ByVal TroskoviObrade As Single, ByVal KamatnaStopa As Single) As Single 22 Return (Glavnica * (1 + KamatnaStopa) + TroskoviObrade) 23 End Function Prethodni program ima sledeće delove: glavni program (01-13), potprogram tipa Sub koji se zove IspisiZbir (15-19) i potprogram tipa Function imena ZateznaKamata (21-22). Red 15 je ZAGLAVLJE SUB-A IspisiZbir, a red 21 je zaglavlje Function-a ZateznaKamata. Zaglavlje Sub-a sadrži oznaku da je reč o Sub-u, ime Sub-a (IspisiZbir) i listu parametara. Parametri Sub-a IspisiZbir su a i b, obe su promenljive tipa Integer. Sub sadrži još jednu promenljivu, to je promenljiva Zbir. Ona nije parametar, jer nije deklarisana u zaglavlju. Zaglavlje Function-a sadrži oznaku da je reč o funkciji, naziv funkcije (ZateznaKamata) i listu parametara. Parametri funkcije su promenljive Glavnica, TroskoviObrade i KamatnaStopa, sve tri tipa Single. Posle zatvorene zagrade se nalaze reči As Single. To je oznaka tipa povratne vrednosti funkcije. Drugim rečima, vrednost koju će funkcija vratiti mora da bude tipa single, tj. kada se promenljive navedene u zagradi posle ključne reči Return zamene svojim vrednostima, rezultat računanja treba da je vrednost koja se može smestiti u onu promenljivu, koja prima povratnu vrednost funkcije, a to je promenljiva Kamata u redu br. 09. Primetite da je promenljiva Kamata deklarisana kao Single (red 03), i da je tip povratne vrednosti funkcije ZateznaKamata (red 21, posle zatvorene zagrade) takođe Single. Pokušajte sledeće: promenite 22 Return (Glavnica * (1 + KamatnaStopa) + TroskoviObrade) u 22 Return ("Cao") Šta će se desiti? U čemu je problem: U zaglavlju funkcije je definisano da funkcija vraća tip Single, a "Cao" nije vrednost tipa Single. Dalje, ako bismo izvršili izmene u zaglavlju funkcije tako da ona vraća tip String, problem bi još uvek bio prisutan, jer promenljiva Kamata koja prima povratnu vrednost u redu br. 09, nije tipa String. Konverzije vrednosti iz jednog tipa u drugi su moguće, ali to, za sada, nećemo razmatrati.

10000, 100 i 0.5 su argumenti

a i b su parametri

Sub-a

c i d su argumenti

Tip povratne vrednosti je Single

Parametri funkcije su promenljive Glavnica,

TroskoviObrade i KamatnaStopa Ime Sub-a je

IspisiZbir

Ime Funkcije je ZateznaKamata

5/10

05. Još jedanput, šta su argumenti, a šta parametri? Argumenti su promenljive (odnosno, njihove vrednosti) koje šaljemo u potprogram, dakle, argumenti se navode prilikom POZIVA potprograma. Parametri su promenjlive koje su deklarisane u zaglavlju potprograma. Parametri primaju vrednosti argumenata prosleđenih prilikom poziva potprograma. 06. Kako se poziva potprogram? Sub se poziva navođenjem imena potprograma i argumenata u zagradi posle imena Sub-a. Poziv Sub-a je jedini sadržaj programskog reda, jer Sub nema povratnu vrednost, što se vidi na primerima u redu 03 kod pitanja br. 01, odnosno, u redovima 03 i 05 kod pitanja br. 2. Ispred naziva Sub može da stoji ključna reč Call, ali nije obavezno. U prikazanim primerima smo čitljivosti radi koristili Call. Function se takođe poziva navođenjem imena potprograma (bez Call!) i liste argumenata, ali pošto Function ima povratnu vrednost, poziv potprograma tipa Function se nalazi DESNE STRANE ZNAKA = (sa leve strane je promenljiva koja prima povratnu vrednost), kao u redu 09 pitanja br. 4: 09 Kamata = ZateznaKamata(10000, 100, 0.5) Međutim, poziv Function-a može da bude i argument nekog drugog potprograma (Sub-a ili Function-a). Na primer: 01 Sub Main() 02 03 Dim Dug, Troskovi As Single 04 Dim Broj As Integer 05 06 Dug = 10000 07 Troskovi = 200 08 Broj = 50 09 10 Call IspisiZbir(ZateznaKamata(Dug, Troskovi, 0.4), TrostrukaVrednost(Broj)) 11 12 Console.ReadLine() 13 14 End Sub 15 '-----------------------------------------------------------------------------------------

16 Sub IspisiZbir(ByVal a As Single, ByVal b As Single) 17 Dim Zbir As Single 18 Zbir = a + b 19 Console.WriteLine("Zbir brojeva " & a & " i " & b & " je " & Zbir) 20 End Sub 21 '-----------------------------------------------------------------------------------------

22 Function ZateznaKamata(ByVal Glavnica As Single, ByVal TroskoviObrade As Single, ByVal KamatnaStopa As Single) As Single 23 Return (Glavnica * (1 + KamatnaStopa) + TroskoviObrade) 24 End Function 25 '-----------------------------------------------------------------------------------------

26 Function TrostrukaVrednost(ByVal Vrednost As Integer) As Integer 27 Return (3 * Vrednost) 28 End Function

6/10

Gornji program ima jedan glavni program i tri potprograma, dva tipa Function i jedan Sub. Obratite pažnju na red br. 10. U njemu se poziva Sub IspisiZbir. Taj Sub ima dva parametra (linija br. 16), oba tipa Single. Zato, u pozivu Sub-a se navode dva argumenta: prvi je povratna vrednost funkcije ZateznaKamata, a drugi argument je povratna vrednost funkcije TrostrukaVrednost. Kako red br. 10 funkcioniše? Najpre, promenljive Dug i Troskovi se zamenjuju vrednostima 10000 i 200, respektivno. Potom se poziva funkcija ZateznaKamata i prosleđuju joj se vrednosti 10000, 200 i 0,4 (obratite pažnju, treći argument nije dat u formi promenljive, već konstantnog broja, što je takođe ispravno). Funkcija ZateznaKamata se izvršava i vraća vrednost 14200, koja postaje prvi argument poziva Sub-a. Sada red 10 izgleda:

Preostaje još da na sličan način poziv funkcije TrostrukaVrednost u zamenimo sa njenom povratnom vrednošću. Pošto joj se prosleđuje vrednost promenljive Broj, tj. 50, povratna vrednost je 150, odnosno, red br. 10 sada izgleda:

Preostaje samo još da se izvrši Sub IspisiZbir. Izgled ekrana je sledeći: Red br. 10

10 Call IspisiZbir(ZateznaKamata(Dug, Troskovi, 0.4), TrostrukaVrednost(Broj)) smo mogli napisati u nekoliko redova, na primer: 10a arg1 = ZateznaKamata(Dug, Troskovi, 0.4) 10b arg2 = TrostrukaVrednost(Broj) 10c Call IspisiZbir(arg1, arg2) Izlaz na ekranu bi bio identičan (naravno, pod pretpostavkom da smo prethodno valjano deklarisani promenljive arg1 i arg2). Izmenjeno rešenje ima dva reda i dve promenljive više, manje je efikasno, ali je čitljivije (dopuštamo da se ne slože svi sa ovom konstatacijom).

7/10

Ukoliko je poziv funkcije argument u iste funkcije, reč je o rekurziji. Na primer, TrostrukaVrednost(TrostrukaVrednost(87)). O rekurziji će biti više reči na nekom od narednih susreta. 07. Šta znači ByRef a šta ByVal šta ispred parametara potprograma? Ako je parametar tipa ByRef, kažemo da potprogramu prosleđujemo argument PO REFERENCI (ili: potprogram prima argumente po referenci), a ako je parametar tipa ByVal, argument mu se prosleđuje PO VREDNOSTI. Razlika se ogleda u tome da li promene vrednosti parametara u telu potprograma reperkusiraju (identičnom) promenom vrednosti argumenata u glavnom programu (ili nekom potprogramu odakle je poziv izvršen). U prethodnim primerima smo argumente prosleđivali po vrednosti, jer smo u zaglavlju svih potprograma pre naziva parametara koristili ključnu reč ByVal. Proučite sledeći program: 01 Sub Main() 02 Dim a As Integer 03 a = 10 04 05 Console.WriteLine("Poslacu u Sub vrednost " & a) 06 Console.WriteLine("-------------------------------------------") 07 Udvostruci(a) 08 Console.WriteLine("Nakon povratka iz Sub-a, vrednost promenjlive a je " & a) 09 10 Console.ReadLine() 11 End Sub 12'-----------------------------------------------------------------------------------------

13 Sub Udvostruci(ByVal Parametar As Integer) 14 Console.WriteLine("Sub je primio vrednost " & Parametar) 15 Parametar *= 2 16 Console.WriteLine("Sada je vrednost parametra " & Parametar) 17 Console.WriteLine("-------------------------------------------") 18 End Sub Program se izvršava sledećim redosledom redova: 01-02-03-05-06-07-13-14-15-16-17-18-08-09-10-11. Izlaz na ekranu je:

Vidimo da je vrednost promenljive a nakon završetka potprograma Udvostruci ostala nepromenjena i iznosi 10. Promenimo sada u redu br. 13 ključnu reč ByVal u ByRef, odnosno, neka red 13 Sub Udvostruci(ByVal Parametar As Integer) postane 13 Sub Udvostruci(ByRef Parametar As Integer) Pokrenite program. Izlaz na ekranu je sledeći:

Možemo primetiti da je vrednost promenljive a posle završetka potprograma Udvostruči postala 20.

8/10

"Odgovorni" za to su osenčeni redovi: 13 Sub Udvostruci(ByRef Parametar As Integer) 14 Console.WriteLine("Sub je primio vrednost " & Parametar) 15 Parametar *= 2 16 Console.WriteLine("Sada je vrednost parametra " & Parametar) 17 Console.WriteLine("-------------------------------------------") 18 End Sub U redu br. 13 je parametar (promenljiva Parametar) deklarisan ključnom rečju ByRef. Ova ključna reč je prouzrokovala sledeću logiku: sve što se bude dešavalo sa promenljivom Parametar, dešavaće se i promenljivoj koja joj je predala svoju vrednost prilikom poziva potprograma Udvostruci (iz reda br. 7 se vidi da je to promenljiva a). 07 Udvostruci(a) Kada dođe do izvršenja reda br. 15, tj. 15 Parametar *= 2 možemo zamisliti (uslovno) da se istovremeno, u pozadini, nevidljivo, odigrava i sledeće: 15 a *= 2 zbog čega je promenljiva a promenila svoju vrednost sa 10 na 20. 08. Šta su opcionalni argumenti? Opcionalni argumenti se deklarišu ključnom rečju Optional. Njihova namena je dodeljivanje podrazumevane (default) vrednosti argumentu ispred kojeg stoje, u slučaju da prilikom poziva potprograma (bilo Sub-a, bilo Function-a) nije naveden argument čiju vrednost parametar u zaglavlju potprograma "očekuje". Ilustrujmo sledećim programom: 01 Sub Main() 02 03 Dim Kamata As Single 04 05 Kamata = ZateznaKamata(10000, 100, 0.5) 06 07 Console.WriteLine("Zatezna kamata je " & Kamata) 08 09 Kamata = ZateznaKamata(10000, 100) 10 11 Console.WriteLine("Zatezna kamata je " & Kamata) 12 Console.ReadLine()

13 End Sub 14'----------------------------------------------------------------------------------------- 15 Function ZateznaKamata(ByVal Glavnica As Single, ByVal TroskoviObrade As Single, Optional ByVal KamatnaStopa As Single = 0.2) As Single 16 Return (Glavnica * (1 + KamatnaStopa) + TroskoviObrade) 17 End Function Obratite pažnju na treći parametar, promenljivu KamatnaStopa, funkcije ZateznaKamata. Deklarisan je na način kao što smo i do sada deklarisali parametre, s tom razlikom što je ispred deklaracije ključna reč Optional, a posle oznake tipa (As Single) stoji oznaka =0.2. Ovo se tumači na sledeći način: ako se funkciji proslede samo dva argumenta, tada se vrednost prvog dodeljuje parametru Glavnica, vrednost drugog argumenta se dodeljuje parametru TroskoviObrade, a treći parametar, pošto mu nije prosleđena vrednost u pozivu funkcije, automatski dobija podrazumevanu vrednost, koja je u ovom slučaju 0,2. Redosled izvršavanja redova gornjeg programa je sledeći: 01, 03, 05 15, 16, 17 07, 09 15, 16, 17 11, 12, 13

9/10

U redu br. 05 se funkciji ZateznaKamata šalju tri argumenta, pa parametri u zaglavlju funkcije primaju redom sledeće vrednosti: 10000, 100, 0.5. Dakle, pošto je program funkciji prosledio tri argumenta, parametar KamatnaStopa nije poprimila default vrednost 0,2, već vrednost trećeg argumenta u pozivu funkcije (red 5), tj. vrednost 0,5. Međutim, u redu br. 09, funkciji se šalju samo dva argumenta, pa treći parametar (parametar KamatnaStopa) ostaje "uskraćena" za vrednost argumenta i zato poprima podrazumevanu vrednost. Izlaz na ekranu je sledeći: Pokušajte sledeće: promenite redosled "običnih" i opcionalnih parametara i shodno tome promenite i redosled argumenata prilikom poziva potprograma. Šta se desilo? 09. Kako se još može napustiti potprogram? Potprogrami se mogu napustiti na nekoliko načina, prva dva smo prikazali u prethodnim primerima: 1. Kada se u toku izvršenja potprograma dođe do ključne reči End Sub ili End Function. 2. Ključna reč Return zaustavlja izvršavanje funkcije, povratnu vrednost i kontrolu predaje glavnom programu. 3. Ključnom rečuju Exit Sub, odnosno, Exit Function. 10. Kako proslediti niz potprogramu, odnosno, vratiti niz iz funkcije?

Primer 1 - Prosleđivanje niza po referenci Sub-u Sub Main() Dim a(5), i As Integer Randomize() For i = 0 To a.Length - 1 'Generisaje i ispis niza a(i) = CInt(Int((100 * Rnd()) + 1)) Console.WriteLine(a(i)) Next Povecaj(a) 'Prosledjivanje niza po referenci Sub-u Povecaj Console.WriteLine("Uvecani elementi niza") For i = 0 To a.Length - 1 ' Ispis modifikovanog niza Console.WriteLine(a(i)) Next Console.ReadLine() End Sub '------------------------------------------------------------------------------

Sub Povecaj(ByRef niz() As Integer) Dim j As Integer For j = 0 To niz.Length - 1 niz(j) += 10 Next

End Sub

10/10

Primer 2 - prosleđivanje niza po vrednosti Function-u + niz je povratna vrednost funkcije Sub Main() Dim a(5), b(5), i As Integer Randomize() For i = 0 To a.Length - 1 'Generisaje i ispis niza a(i) = CInt(Int((100 * Rnd()) + 1)) Console.WriteLine(a(i)) Next b = Povecaj(a) 'Prosledjivanje niza po vrednosti 'funkciji Povecaj 'i dodeljivaje izmenjenog niza novom nizu Console.WriteLine("Uvecani elementi niza") For i = 0 To b.Length - 1 ' Ispis modifikovanog niza Console.WriteLine(b(i)) Next Console.ReadLine() End Sub '-----------------------------------------------------------------------------

Function Povecaj(ByVal niz() As Integer) As Integer() Dim j As Integer For j = 0 To niz.Length - 1 niz(j) += 10 Next Return (niz) 'Vracanje niza glavnom programu End Function