СМЕНА ПРЕ ПОДНЕ

ТРАЈАЊЕ ЧАСА 45 МИНУТА

ТРАЈАЊЕ ЧАСА 35 МИНУТА

ТРАЈАЊЕ ЧАСА 30 МИНУТА

ЧАС

Почетак

Крај

ЧАС

Почетак

Крај

ЧАС

Почетак

Крај

1.

07:30

08:15

1.

07:30

08:05

1.

07:30

08:00

2.

08:20

09:05

2.

08:10

08:45

2.

08:05

08:35

3.

09:20

10:05

3.

09:00

09:35

3.

08:50

09:20

4.

10:10

10:55

4.

09:40

10:15

4.

09:25

09:55

5.

11:05

11:50

5.

10:25

11:00

5.

10:05

10:35

6.

11:55

12:35

6.

11:05

11:40

6.

10:40

11:10

7.

12:40

13:15

7.

11:45

12:20

7.

11:15

11:45

 

 

СМЕНА ПОСЛЕ ПОДНЕ

ТРАЈАЊЕ ЧАСА 45 МИНУТА

ТРАЈАЊЕ ЧАСА 35 МИНУТА

ТРАЈАЊЕ ЧАСА 30 МИНУТА

ЧАС

Почетак

Крај

ЧАС

Почетак

Крај

ЧАС

Почетак

Крај

1.

13:30

14:15

1.

13:30

14:05

1.

13:30

14:00

2.

14:20

15:05

2.

14:10

14:45

2.

14:05

14:35

3.

15:20

16:05

3.

15:00

15:35

3.

14:50

15:20

4.

16:10

16:55

4.

15:40

16:15

4.

15:25

15:55

5.

17:05

17:50

5.

16:25

17:00

5.

16:05

16:35

6.

17:55

18:35

6.

17:05

17:40

6.

16:40

17:10

7.

18:40

19:15

7.

17:45

18:20

7.

17:15

17:45

Објектно оријентисано програмирање (Object Oriented Programming, OOP) је релативно нови приступ у реализацији софтвера, настао као одговор на софтверску кризу, а који у основи има настојање да се реалан свет на природан начин моделује програмским кодом.

Објектно оријентисано програмирање заснива се на четири основна концепта:

  • апстрактни типови података
  • енкапсулација
  • наслеђивање
  • полиморфизам

 

Апстрактни типови података су један од основних концепата Објектно Оријентисаног Програмирања (ООП). Тај концепт практично значи да програмер, као корисник језика, може да дефинише неки свој тип који ће бити потпуно равноправан са свим другим, у језик уграђеним типовима. То је концепт који подржава идеју да се објекти и ентитети реалног света на што природнији и лакши начин моделују и представе у софтверском коду.

У програмском језику C++ апстрактни типови података се реализују преко класа (class). Класа је описана својим атрибутима (особинама, тј. пољима) и операцијама (акцијама, тј. функцијама).

Даље у овом тексту даћемо неколико примера дефиниције и коришћења класа. Почећемо са врло једноставним примерима, а затим ћемо их постепено "закомпликовати". Већина ових примера су урађени, или ће бити рађени на часовима вежби из Програмирања.

Такође, следећи линкови вам могу бити од користи:

http://sh.wikipedia.org/wiki/C%2B%2B

http://www.cplusplus.com/doc/tutorial/classes/

Погледајте и ове фајлове: klase.pdf , OOP.ppt

Питање за наставника ...

 


пример 1: једноставна класа

Ово је врло једноставан пример класе која има четири члана податка и једну методу (функцију чланицу). Сви чланови су јавни (декларисани у public делу класе).

модул ucenik

ucenik.h

#ifndef _ucenik.h
#define _ucenik.h

class TUcenik
{
public:
char Ime[100];
int GR; //godina rodjenja
int Godina; // koju godinu slusa
char Odeljenje[20];
void PredstaviSe(); // metoda, funkcija koja pripada klasi
};

#endif

ucenik.cpp

#include <iostream>
#include "ucenik.h"

void TUcenik::PredstaviSe()
{
cout<<"Ja sam "<<Ime
<<" rodjen "<<GR
<<". godine, trenutno sam "
<<Godina<<". godina, odeljenje "
<<Odeljenje<<endl;
}

main функција

#include <conio>
#include <iostream>
#include "ucenik.h"

main()
{
TUcenik u;
strcpy(u.Ime, "Petar Petrovic");
u.GR=1991;
u.Godina=4;
strcpy(u.Odeljenje, "IV-2");
u.PredstaviSe();

getch();
}

 


пример 2: енкапсулација

У овом примеру, који је проширење претходног, демонстрираћемо концепт енкапсулације. Енкапсулацијом (учаурењем, затварањем) се постиже да не буду сви чланови класе доступни за директан приступ, него да корисник (програмер који користи класу) мора да користи одговарајуће методе. Тиме се постиже да класа има контролу над вредностима које ће бити уписане у њене чланове податке.

Обратите пажњу на имплементацију метода set_GR и set_Godina.

Питање за наставника ...

модул ucenik

ucenik.h

class TUcenik
{
private:
char Ime[100];
int GR; //godina rodjenja
int Godina; // koju godinu slusa
char Odeljenje[20];
public:
void set_Ime(const char* const);
void set_GR(const int);
void set_Godina(const int);
void set_Odeljenje(const char* const);
void PredstaviSe(); // metoda, funkcija koja pripada klasi
};

ucenik.cpp

#include <iostream>
#include <string.h>
#include <DOS.H>
#include "ucenik.h"

void TUcenik::set_Ime(const char* const theIme)
{
strcpy(Ime, theIme);
}

void TUcenik::set_GR(const int theGR)
{
date d; // date je struktura deklarisana u DOS.H, pogledajte help
getdate(&d);   // uzimanje sistemskog datuma, pogledajte help

if (((d.da_year-theGR)>=15) &&  ((d.da_year-theGR)<=20))
GR=theGR;
else
cout<<"Greska prilikom unosa Godine rodjenja. Ucenici moraju da imaju najmanje 15 godina, a najvise 20"<<endl;
}

void TUcenik::set_Godina(const int theGodina)
{
if (theGodina>=1 && theGodina<=4)
Godina=theGodina;
else
cout<<"Greska prilikom unosa Godine. Isparavna vrednost je od 1 do 4" <<endl;
}

void TUcenik::set_Odeljenje(const char* const theOdeljenje)
{
strcpy(Odeljenje, theOdeljenje);
}

void TUcenik::PredstaviSe()
{
cout<<"Ja sam "<<Ime
<<" rodjen "<<GR
<<". godine, trenutno sam "
<<Godina<<". godina, odeljenje "
<<Odeljenje<<endl;
}

main функција

#include <conio>
#include <iostream>
#include "ucenik.h"

main()
{
TUcenik u;
u.set_Ime("Petar Petrovic");
u.set_GR(1955); // namerno pogresno, starija osoba
u.set_GR(2003); // namerno pogresno, mladja osoba
u.set_GR(1993); // ispravno
u.set_Godina(10); // namerno pogresno
u.set_Godina(4);  // ispravno
u.set_Odeljenje("IV-2");
u.PredstaviSe();

getch();
}


пример 3: конструктори и деструктори (constructor, destructor)

Конструктори и деструктори су специјалне методе (функције чланице) класе који се имплицитно позивају на почетку (конструктор) и на крају (деструктор) животног века објекта неке класе. Имају потпуно исто име као и класа (деструктор има знак ~ испред имена) и не смеју да враћају никакав тип, чак ни void. Декларисање конструктора или деструктора може да се изостави, али у том случају сам преводилац ће генерисати тзв. default constructor и/или default destructor.

Намена конструктора је да "конструише" објекат, тј. да изврши све што је неопходно да би се објекат неке класе, на почетку његовог "живота", довео у "радно" стање. То може бити, на пример, иницијализација неких унутрашњих чланова података, заузимање меморије за неке потребе објекта и слично. Конструктор се може и преклопити (overload), што практично значи да класа може да има више конструктора, о чему ћемо у неком од следећих примера.

Намена деструктора је управо супротна намени конструктора. Он мора да "почисти" за објектом, односно да изврши све што је потребно урадити када објекат престаје да "живи". На пример, да ослободи меморију коју је конструктор заузео на почетку и слично.

У следећем, релативно једноставном али ипак нешто сложенијем примеру од претходних, ћемо показати како функционишу конструктори и деструктори, а биће показан и један нови однос између објеката две класе, у коме објекат једне класе уме да "користи" објекат друге класе.

Питање за наставника ...

Погледајте и анализирајте пажљиво овај пример.

модул особа

osoba.h

#ifndef _osoba.h
#define _osoba.h

//////////////////////
// deklaracija klase
//////////////////////
class TOsoba
{
// sve sto nije deklarisano pod public:
// smatra se po "default"-u private: 
char* Ime;
char* Prezime;
public:  // javne metode
TOsoba(const char* const, const char* const); // konstruktor
~TOsoba(); // destruktor
void PredstaviSe();
};

#endif

osoba.cpp

#include <iostream>
#include <string>


#include "osoba.h"

///////////////////////////
// implementacija metoda klase
////////////////////////

// konstruktor
TOsoba::TOsoba(const char* const theIme, const char* const thePrezime)
{
Ime = new char[100];
Prezime = new char[100];
strcpy(Ime, theIme);
strcpy(Prezime, thePrezime);
}

// destruktor
TOsoba::~TOsoba()
{
cout<<"Ubila se osoba "<<Ime<<" "<<Prezime<<endl;
delete[] Ime;
delete[] Prezime;
}

void TOsoba::PredstaviSe()
{
cout << "Ja sam osoba " << Ime << " " << Prezime << endl;
}
///////////////////////////////////////
// kraj implementacije klase
//////////////////////////////////////

модул полицајац

policajac.h

#ifndef _policajac.h
#define _policajac.h

#include "osoba.h"

class TPolicajac
{
char* Ime;
char* Znacka;
public:
TPolicajac(const char* const, const char* const);
~TPolicajac();
void Legitimisi(TOsoba*);
};

#endif

policajac.cpp

#include "policajac.h"

TPolicajac::TPolicajac(const char* const theIme, const char* const theZnacka)
{
Ime = new char[100];
Znacka = new char[100];
strcpy(Ime, theIme);
strcpy(Znacka, theZnacka);
}

TPolicajac::~TPolicajac()
{
cout<<"Ubio se policajac "<<Ime<<" "<<Znacka<<endl;
delete[] Ime;
delete[] Znacka;
}

void TPolicajac::Legitimisi(TOsoba* o)
{
cout << "Ja sam policajac " << Ime <<" (" << Znacka << "). ";
cout << "Predstavi se!" << endl;
o->PredstaviSe();
cout << endl;
}

main функција

#include <conio>
#include <iostream>

// moji headeri uvek treba da idu posle standardnih
#include "osoba.h"
#include "policajac.h"

main()
{
// staticko koriscenje klase
TOsoba p("Pera", "Peric"),
m("Mile", "Miletic");  // deklaracija i poziv konstruktora

TPolicajac r("Bambusic", "332344");

cout<<"STATICKI OBJEKTI:"<<endl;
r.Legitimisi(&p);
r.Legitimisi(&m);


// dinamicko koriscenje klase
// deklaracija objekta, zauzimanje memorije za objekat (new) i poziv konstruktora
TOsoba *pp = new TOsoba("Marko", "Markovic"),
*pm = new TOsoba("Kosta", "Kostic");

TPolicajac *pr = new TPolicajac("Bambalic", "534583");

cout<<"DINAMICKI OBJEKTI"<<endl;
pr->Legitimisi(pp);
pr->Legitimisi(pm);

cout<<"brisanje dinamickih objekata, implicitni poziv destruktora"<<endl;
delete pp;
delete pm;
delete pr;

getch();
}

 


пример 4: преклопљени оператори, вишеструки конструктори

модул komplex

komplex.h

#ifndef _komplex.h

#define _komplex.h

class TComplex
{
double real;
double imaginar;
public:
TComplex(); // konstruktor
TComplex(double r, double i); // konstruktor
void set_r(double r);
double get_r() const; // inspektor
void set_i(double i);
double get_i() const;// inspektor

TComplex& operator=(TComplex c);
TComplex operator+(TComplex c);
TComplex operator-(TComplex c);
TComplex operator*(TComplex c);
TComplex operator/(TComplex c);
TComplex& operator++();
TComplex& operator--();
};

#endif

komplex.cpp

#include "komplex.h"


TComplex::TComplex(): real(0), imaginar(0)
{
}

TComplex::TComplex(double r, double i): real(r), imaginar(i)
{
}

void TComplex::set_r(double r)
{
real=r;
}

double TComplex::get_r() const
{
return real;
}

void TComplex::set_i(double i)
{
imaginar=i;
}

double TComplex::get_i() const
{
return imaginar;
}

TComplex& TComplex::operator=(TComplex c)
{
real=c.get_r();
imaginar=c.get_i();
return *this;
}

TComplex TComplex::operator+(TComplex c)
{
TComplex rezultat;
rezultat.set_r(real+c.get_r());
rezultat.set_i(imaginar+c.get_i());
return rezultat;
}

TComplex TComplex::operator-(TComplex c)
{
TComplex rezultat;
rezultat.set_r(real-c.get_r());
rezultat.set_i(imaginar-c.get_i());
return rezultat;
}

TComplex TComplex::operator*(TComplex c)
{
TComplex rezultat;
rezultat.set_r(real*c.get_r());
rezultat.set_i(imaginar*c.get_i());
return rezultat;
}

TComplex TComplex::operator/(TComplex c)
{
TComplex rezultat;
rezultat.set_r(real/c.get_r());
rezultat.set_i(imaginar/c.get_i());
return rezultat;
}

TComplex& TComplex::operator++()
{
real++;
imaginar++;
return *this;
}

TComplex& TComplex::operator--()
{
real--;
imaginar--;
return *this;
}

main функција

#include <conio>
#include <iostream>
#include "komplex.h"

main()
{
TComplex c, c1(1,1), c2(3,4);
cout<<"c  real: "<<c.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<
cout<<"c1  real: "<<c1.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<
cout<<"c2  real: "<<c2.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<

cout<<endl;

c=c1+c2;
cout<<"c=c1+c2  real: "<<c.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<
c=c1-c2;
cout<<"c=c1-c2  real: "<<c.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<
c=c1*c2;
cout<<"c=c1*c2  real: "<<c.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<
c=c1/c2;
cout<<"c=c1/c2  real: "<<c.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<
c++;
cout<<"c++  real: "<<c.get_r()<< "<span="" data-mce-bogus="1" class="mceItemHidden mceItemNbsp">  imag: "<

getch();
}

Питање за наставника ...

 

пример 5: наслеђивање

Наслеђивање је концепт ООП-а који (уз полиморфизам) омогућава тзв. code reusability, односно поновно коришћење кода. То је концепт који у многоме повећава продуктивност програмера.

Наслеђивање је релација (однос) између класа. На пример, ако класа Б наслеђује класу А то значи:

  • објекти класе Б су једна врста објеката класе А
  • објекти класе Б имају све особине класе А и још могу да имају и неке додатне своје особине

Наслеђивање се у језику C++ реализује "извођењем класа". Извођење није исто што и наслеђивање, већ је шири појам. То значи да није свако извођење истовремено и наслеђивање.

Питање за наставника ...

пример:

class A
{
public:
void f();
};

class B: public A
{
public:
void g();
};

У горњем примеру јавно смо извели класу Б из класе А (class B: public A) што је једино извођење које је истовремено и наслеђивање. Постоје и тзв protected и private извођења, која нису наслеђивање зато јер у том случају однос између класа А и Б није такав да је Б "једна врста" А, него је класа Б класа која "садржи" класу А. Овим врстама извођења се нећемо бавити, јер се користе релативно ретко.

У примеру који смо дали, класа А има једну методу f() а класа Б која је наследила А има наслеђену методу f() и још додатну своју методу g().

Класе наследнице наслеђују и "виде" све делове родитељске класе који нису у private секцији (значи public и protected). Конструктори и деструктори (види овде) се НЕ наслеђују. Приликом креирања објекта класе наследнице, прво се извршавају конструктори њене родитељске класе па тек онда конструктор те класе. Код деструктора је супротно: прво се активира деструктор наследнице, па затим деструктор родитеља.

Још један, мало већи пример наслеђивања можете да преузмете овде.

Питање за наставника ...

Проверите своје знање из области структура података стек и ред, као и из Увода у ООП.

Тестови НИСУ за оцену и број поена које освојите НЕЋЕ на њу утицати, али на оцену ЋЕ утицати ПОЗИТИВНО ако тестове урадите!

Стек, ред тест: https://goo.gl/forms/xxa5qkdH7HuF6vAu1

Увод у ООП тест: https://goo.gl/forms/GlW5KemWk3JaU1KR2

 

Испитна питања можете да преузмете и као pdf документе:

II година

III година

IV година

II година

  1. Хардвер и софтвер, програмски језици, синтакса и семантика програмског језика.

  2. Компајлер, линкер, развојно окружење.

  3. Дефиниција и задатак алгоритма. Графички запис.

  4. Анализа проблема. Етапе решавања задатка. Провера исправности.

  5. Алгоритми. Дијаграм тока.

  6. Структура програмског језика. Структура програма.

  7. Кључне речи, идентификатори, константе и променљиве.

  8. Основни типови података. Унос и приказ података.

  9. Оператори језика. Оператори доделе вредности.

  10. Оператори језика. Аритметички оператори.

  11. Оператори језика. Релацијски оператори.

  12. Оператори језика. Логички оператори.

  13. Оператори језика. Бит оператори.

  14. Оператори језика. Додатни оператори доделе вредности.

  15. Оператори језика. Оператори инкрементирања и декрементирања.

  16. Стандардне функције.

  17. Ток извршавања. if наредба.

  18. Ток извршавања. case наредба.

  19. Ток извршавања. Циклуси.

  20. Ток извршавања. for петља.

  21. Ток извршавања. while и do while петља.

  22. Дефиниција и декларација низа.

  23. Иницијализација низа.

  24. Приступ елементима низа, претраживање.

  25. Сортирање низа, минимални и максимални елемент.

 

III година

  1. Функције. Декларација (прототип) функције.

  2. Функције. Формални и реални параметри.

  3. Функције. Дефиниција функције. Пример.

  4. Функције. Пренос параметара преко вредности.

  5. Функције. Пренос параметара преко референце.

  6. Функције. Default параметри.

  7. Функције. Локалне и глобалне променљиве.

  8. Функције. Рекурзивне функције.

  9. Поинтери. Декларација.

  10. Поинтери. Приступ преко поинтера.

  11. Поинтери. Поинтери и низови.

  12. Поинтери. Поинтери на функције.

  13. Матрице. Декларација. Приступ елементу матрице.

  14. Матрице. Иницијализација матрице.

  15. Матрице. Квадратне матрице.

  16. Матрице. Проласци кроз матрицу.

  17. Стрингови. Декларација.

  18. Стрингови. Приступ преко индекса и поинтера.

  19. Стрингови. Основне функције за рад са стринговима.

  20. Модуларно програмирање. Креирање модула.

  21. Низови. Секвенцијално претраживање.

  22. Низови. Бинарно претраживање.

  23. Низови. Сортирање. Bubble sort алгоритам.

  24. Структуре. Декларација.

  25. Структуре. Структуре и поинтери.

  26. Динамичка додела меморије.

  27. Динамички низови.

  28. Поинтерска листа. Креирање листе.

  29. Поинтерска листа. Пролазак кроз листу.

  30. Поинтерска листа. Убацивање и избацивање чворова.

  31. Поинтерска листа. Двоструко спрегнута поинтерска листа.

  32. Бинарно стабло. Убацивање чворова.

  33. Бинарно стабло. Пролазак кроз бинарно стабло.

  34. Датотеке. Приступ датотеци.

  35. Датотеке. Снимање података у датотеку.

  36. Датотеке. Учитавање података из датотеке.

 

IV година

  1. Структура података – ред (queue). Основне операције.

  2. Структура података – стек (stack). Основне операције.

  3. Структура података – ред (queue). Имплементација преко поинтерске листе.

  4. Структура података – стек (stack). Имплементација преко поинтерске листе.

  5. ООП. Основни концепти.

  6. ООП. Класе.

  7. ООП. Методе и чланови подаци.

  8. ООП. Енкапсулација. Private, protected и public делови класе.

  9. ООП. Конструктори и деструктори.

  10. ООП. Преклапање оператора.

  11. ООП. Наслеђивање.

  12. ООП. Полиморфизам.

  13. Обрада изузетака.

  14. Базе података. Најпознатији актуелни RDBM системи. Табеле и везе међу њима.

  15. Базе података. Релациони модел.

  16. Базе података. Табеле. Примарни кључ.

  17. Базе података. Табеле. Спољни кључ.

  18. Базе података. Табеле. Референцијални интегритет.

  19. Базе података. SQL. SELECT наредба

  20. Базе података. SQL. INSERT наредба

  21. Базе података. SQL. UPDATE наредба

  22. Базе података. SQL. DELETE наредба

  23. Базе података. Client-Server архитектура. Улога RDBM система у C/S архитектури

  24. Базе података. Успостављање везе са одређеним извором података. Connection string.

  25. Базе података. Клијентски (презентациони) слој и његова улога.

 

Увод

Ова страница ће вам бити додатни извор информација везаних за ову наставну тему. Овде ћемо постављати примере, објашњења, линкове и задатке који ће вам помоћи да лакше разумете функције и све остало везано за њих.

Ако имате питања везана за ову област можете их поставити ОВДЕ.

Додатни извори и литература

Као прво, препоручујем да скинете pdf фајл Белешке са часова вежби једне студенткиње Математичког факултета у Београду који вам може бити од велике помоћи. Наравно, не тражи се од вас да све што је тамо написано знате и разумете, али у тим белешкама је јако лепо, кратко и разумљиво дато шта су функције, како се оне дефинишу и користе, а такође има лепих и јасних примера.

Погледајте и овај линк са Википедије.

 

Рекурзивне функције

У програмирању, рекурзија је када нека функција у свом телу позива саму себе. Такву функцију зовемо рекурзивна функција.

Постоји читава класа проблема која се на „природан“ начин решава рекурзијом, а постоје и проблеми који се, осим рекурзијом, на други начин и не могу решити, на пример пролаз кроз бинарно стабло, што ћемо учити нешто касније.

На жалост, иако су рекурзивне функције најчешће врло кратке и сажете, многи имају проблем да схвате како све то ради. Разлог је то што се за рекурзивно решавање проблема мора применити и рекурзивни начин размишљања, што није увек лако.

Најчешћи пример од кога се креће са објашњавањем рекурзије је писање функције за изра­чунавање факторијела. Да се подсетимо, факторијел у математици се означава знаком узвика (!)  а његова формула је:

faktorijel


Делује компликовано али је врло једноставно у примеру: 5! = 5*4*3*2*1

Важно правило је да је 1! = 1. Запамтите ово!

Ево како би изгледала функција написана у C-у:

int fakt(int n) { if(n==1) return 1; else return n*fakt(n-1); }

Врло просто, само четири линије кода, али да ли разумете како ово ради?

Ако бисмо позвали ову функцију са аргументом 5, онда би се она извршила на следећи начин:

fakt(5)=5 · fakt(4)

=5 · (4 · fakt(3))             // (јер је fakt(4) = 4 · fakt(3))

=5 · (4 · (3 · fakt(2)))       // (јер је fakt(3) = 3 · fakt(2))

=5 · (4 · (3 · (2 · fakt(1)))) // (јер је fakt(2) = 2 · fakt(1))

=5 · (4 · (3 · (2 · 1)))       // (јер је fakt(1) = 1)

=5 · (4 · (3 · (2 · 1)))       // сада се множење ових вредности врши редом

= 5 · (4 · (3 · 2))             // којим се ф-је завршавају тј. уназад

= 5 · (4 · 6)

= 5 · 24

= 120

Неформална правила за писање рекурзивних функција

За писање рекурзивних функција, може вам помоћи следеће неформално упутство, односно правила. Ово нису формални принципи него више „искуства из праксе“ која могу да помогну у коришћењу рекурзије:

  1. одредити услов прекида рекурзије
  2. одредити „мали део посла“ који рекурзивна функција „зна“ да ради
  3. одредити шта је то што се пребацује на остале рекурзивне позиве функције, да они обаве

Услов прекида рекурзије – то је тачка у извршавању рекурзивне функције у којој се престаје са поновним „позивањем саме себе“. Врло је важно да свака ре­ку­рзи­вна функција (која има неку сврху) има ову тачку прекида, јер ће у су­про­тном доћи до бесконачних позива који на крају доводе до „пуцања“ самог про­грама у коме је оваква функција. У горњем примеру то је линија if(n==1) return 1; која каже, ако је n==1, само врати 1, a не позивај више себе, односно неће се извршити else блок у коме је тај рекурзивни позив. Добра пракса је да се одмах на почетку замисли где је ова тачка прекида, односно који услов треба да је испуњен па да се рекурзија прекине.

„Мали део посла“, односно шта један позив функције ради – ово може бити очи­гле­дно, али може бити и мање видљиво, зависно од проблема. У нашем слу­чају то је просто враћање резултата множења n-а са „нечим“. То „нешто“ је у ствари позив те исте функције (односно повратна вредност тог позива), али то нас за сада не интересује. Линија кода је return n*fact(n-1); . Само ово што је подвучено је у ствари тај „мали део посла“. Значи return n*. Другим речима: врати n помножено са ...

Рекурзивни позив – овде долазимо до суштине рекурзије, односно ово је место где функција позива саму себе. У примеру је то линија return n*fact(n-1). Подвучен је рекурзивни позив. Пошто је 5! у ствари 5*4! овај позив fact(n-1) је, за n=5, управо израчунавање 4!. Замислите се мало над примером. Још нешто можемо издвојити као правило: следећем рекурзивном позиву функције никад неће бити дати потпуно исти параметри које је добила функција у којој се дешава овај позив. У нашем случају, у првом позиву, функција је добила број 5, али је поново позвала саму себе са бројем 4 (односно n-1, где је n=5). Разлог за ово правило је тај што ако би функција поново добила исте пара­метре, онда би се и понашала на исти начин стално и изнова, па рекурзија никад не би стала. То би нас опет довело до „пуцања“ програма.

Уместо закључка

Ако сте из свега овога разумели рекурзију – одлично! То значи да сте врло паметни и екстра талентовани за програмирање, на чему вам честитам :).

Ако нисте разумели – онда сте исти као и ја, ваш наставник, на чему вам не честитам! :) Мени је требало пууууно времена да ово схватим.

Али сам ипак успео, па сам сигуран да ћете и ви, када на вежбама и каснијим преда­вањима прођемо кроз још неке примере и објашњења. Пробајте мало и да „гуглате„ рекурзију на интернету, наћи ћете море корисних линкова.

Приближава се први тест из програмирања за трећу годину. Да вас подсетим, тест ћемо радити у петак 14. октобра 2016.

Можда није лоша идеја да проверите како стојите са знањем? :) Покушајте да решите овај online тест. Морате да упишете исправну email адресу како бисте добили повратне информације када тест прегледам (сваки тест који пошаљете ћу прегледати). Овај тест НИЈЕ за оцену и неће имати НИКАКАВ утицај на њу, урадите га сами па колико умете. Што не умете, оставите празно. Можете урадити и послати тест више пута.

Ово је линк ка online тесту.

А можете га попунити и директно овде на нашем сајту:

Поткатегорије

0101

Програмирање

Овај предмет се учи у другој, трећој и четвртој години образовног профила Електротехничар рачунара.

Општи циљ предмета је оспособљавање ученика за програмирање основних и напредних алгоритамских корака на вишем програмском језику (учи се програмски језик C) и писање програма различитих нивоа сложености, коришћењем савремених софтверских алата и окружења за развој апликација.

Југослав СтарчевићПрограмирање III година

У трећој години (друга година учења предмета) бавимо се следећим темама:

Функције и структура програма, поинтери, матрице, стрингови, технике претраживања и сортирања низова, структуре, динамичка меморија и динамичке структуре података (низови, листе, бинарна стабла), фајлови (датотеке).

У овој години предмет предаје наставник Југослав Старчевић

Поставите питање наставнику ОВДЕ.

jugoslavПрограмирање IV година

У четвртој години (трећа година учења предмета) бавимо се следећим темама:

Структуре података (стек и ред), Објектно оријентисано програмирање (увод и основни концепти), Windows програмирање (увод, основни концепти, основни концепти база података).

У овој години предмет предаје наставник Југослав Старчевић

Поставите питање наставнику ОВДЕ