ПРОГРАМИРАНЕ И ИЗПОЛЗВАНЕ НА КОМПЮТРИ – II ЧАСТ Доц. д-р Юлиана Георгиева

1. ПРОГРАМИРАНЕ И ИЗПОЛЗВАНЕ НА КОМПЮТРИ– II ЧАСТ Доц. д-р Юлиана Георгиева Катедра “Програмиране и компютърни технологии” Факултет Компютърни Системи и Управление

2. Литература • Ив. Момчев, К. Чакъров, Програмиране III (C и C++), ПБ на ТУ, София, 2000 • В. Георгиев, Юл. Георгиева. М. Горанова, и др., Ръководство по Програмиране и използване на компютри II (C++), СИЕЛА, София, 2001 • Бьорн Строустроп, Програмният език С++, том 1,2, ИнфоДар 2003. • Кай Хорстман, Принципи на програмирането на С++, • Софтех, 2000. • Скот Майерс, Ефективен С++, Зест Прес 2003. • Д. Богданов, Обектно-ориентирано програмиране С++, Техника, София, 1988

3. Литература • Хърбърт Шилдт, Практически самоучител, най-успешният и доказан метод за научаване на С++, Софтпрес, София, 2001 • Дейвид Брадли, Програмиране на Асемблер за ПК IBMPC, Техника, София, 1989 • А. Егоров, Р. Стоянова, Програмиране на асемблерен език за 32-битови микропроцесори Intel, част I, Paraflow, София, 1997 • Липман Ст. Езикът С++ в примери, Колхида трейд, София, 1993

4. Литература • WWW адреси • Introduction to Object-Oriented Programming Using C++ • http://www.desy.de/gna/html/cc/ • C++ Programming • http://en.wikibooks.org/wiki/Programming:C_plus_plus • PC Assembly Language • http://www.drpaulcarter.com/pcasm/pcasm-book.pdf.gz

5. Някои особености на С++ • Нови възможности за вход/изход - предимства • cout – Поток за вмъкване (изход) - stdout • cin–Поток за извличане (вход) - stdin cout << израз_от_произволен_тип; Потокът coutполучава стойността на израза Променлива получава стойност от входния поток cin cin >>променлива_от_произволен_тип;

6. Някои особености на С++ • Нови възможности за вход/изход - предимства Библиотеченфайл за cout и cin #include <iostream.h> void main() { int n=25; unsigned q=6300; float x=12.3456789; char c=’a’,*ch=”C++”; cout <<”n=”<<n<<”,q=”<<q<<”\n”; cout<<”x=”<<x<<”\n”; cout<<”c=”<<c<<”,ch=”<<ch<<”\n”; } n=25,q=6300 x=12.3457 c=a,ch=C++

7. Някои особености на С++ • Нови възможности за вход/изход - предимства Пример за попълване и четене на масив от символи #include <iostream.h> void main() { char t[80]; int i=0; cout<<”Въведи символи с точка на края.\n”; do { cin>>t[i]; } while(t[i++]!=’.’); cout<<”\n\nПрочетени символи\n”; i=0; do { cout<<t[i]; } while(t[i++]!=’.’); }

8. Някои особености на С++ • Форматиране на вход/изхода Форматиращи флагове • Освен автоматичното форматиране (показано в по-горните примери) е възможно явно форматиране на обмена със стандартните входно/изходни устройства. Дефинирани са флагове (битове) от клас ios, чието състояние определя формата. Установяването им в 0 или 1 се извършва с предварително дефинирани функции.

9. Някои особености на С++

10. Някои особености на С++

11. Някои особености на С++ • Форматиране на вход/изхода • Установяване на форматиращите флагове (прототипи на функции): Установява флаг long setf(long flags); Премахва установен флаг long unsetf(long flags); Установява група от флагове long flags(long mask); Извикване на функция поток.setf(параметри);

12. Някои особености на С++ • Форматиране на вход/изхода Пример: #include <iostream.h> void main() { cout.setf(ios::hex | ios::showbase);//установява флагове cout<<100<<'\n';//извежда: 0х64 cout.unsetf(ios::showbase);//премахва установен флаг cout<<100<<'\n';//извежда: 64 cout.setf(ios::uppercase | ios::scientific); //установява флагове cout<<100.12;//извежда: 1.001200Е+02 cout.unsetf(ios::uppercase);//премахва установен флаг cout<<"\n"<<100.12;//извежда: 1.001200е+02 }

13. Някои особености на С++ • Форматиране на вход/изхода • Установяване на флаговете с функции int width (int w); int precision (int p); char fill (char ch); void main() { cout.precision(4); cout.width(10); cout << 10.12345<<“\n”; cout.fill(‘*’); cout << 10.12345<<“\n”; } bbbbb10.12 *****10.12

14. Форматиране на вход/изхода Манипулатори • Дефинициите на манипулаторите се намират във файла iomanip.h, който трябва да се включи. Манипулатори без параметри

15. Форматиране на вход/изхода Манипулатори Манипулатори с параметри

16. Форматиране на вход/изхода Манипулатори Манипулатори с параметри - пример #include <iostream.h> #include <iomanip.h> void main() { cout<<hex<<100<<endl; cout<<setfill('*')<<setw(10); cout<<resetiosflags(ios::hex)<<2345<<endl; cout<<setiosflags(ios::scientific)<<22.33<<endl; cout<<setprecision(2)<<setw(16)<<12.34567<<endl; } 64 ******2345 2.233000е+01 ********1.23е+01

17. for( int i=0;; ) . . . Някои особености на С++ • Деклариране на променливи на произволно място в текста • Параметри на функции по подразбиране • При декларирането на функция могат да се зададат начални стойности на всички или на част от параметрите. • Тези стойности се използват, ако при извикването на функцията съответните параметри са пропуснати. • Тези параметри се задават при декларирането, а не при дефинирането на функцията и са винаги последни в списъка от параметри.

18. #include <iostream.h> voidf(int, int =12); //втори параметър е по подразбиране void main() { int n=10,p=20; f(n,p);//нормално извикване f(n);//извикване с един параметър }//f(); - грешно извикване void f(int a,int b) { cout<<”a=”<<a<<”,b=”>><<b<<”\n”; } Някои особености на С++ • Параметри на функции по подразбиране • Динамична памет – заделяне и освобождаване int *ad; //указател към динамична зона ad=newint[50];//заделяне на динамична памет от 100 байта deletead;//освобождаване на заделената памет

19. Класове и обекти • КЛАС: Тип, дефиниран от потребителя, състоящ се от членове данни(променливи) и членове функции (методи) • ОБЕКТ: Дефинира се като променливa от даден клас. • Дефиниране на КЛАС: Член ДАННИ (Променливи) Член ФУНКЦИИ (Методи) • Декларация на клас • Дефиниции на член-функции Общ вид за дефиниране на клас 1. Декларация на клас classиме_на клас{ //Декларации на променливи (член-данни) //Декларации на методи (член функции) }; //Дефиниции на член-функции 2. Дефиниции на член-функции

20. Оператор за област на действие Класове и обекти тип_резултат име_клас :: име_на_функция (списък параметри) { //тяло на функция } Общ вид на дефиниция на член - функция

21. #include <iostream.h> classpoint { //деклариране на член данни private://за капсулиране на данни intx,y; //деклариране на член функции public: void init(int,int); void deplace(int,int); voidout(); }; //Дефиниции на член функции voidpoint ::init(intabs,intord) //::е оператор за действие { x=abs; y=ord; } void point :: deplace(int dx,int dy) { x+=dx; y+=dy; } void point :: out() { cout<<”Точка с координати:”<<x<<” “<<y<<”\n”; } Класове и обекти Пример за дефиниране на клас

22. Класове и обекти • Декларацията на класа не заема памет. • Член-функциите имат пряк достъп до всички компоненти на класа. Деклариране на ОБЕКТИ (екземпляри) име_на_клас име_на_обект;//общ вид point a, b;//деклариране на обектите а и b a и b имат собствени копия на член-данните на класа и се заделя памет

23. Класове и обекти Видимост на компоненти • public - достъпни за външни функции чрез обект на класа, аза член-функции на класа и наследници имат пряк достъп. • private- пряк достъп имат член-функциите на класа; недостъпни са за външни функции. • protected – ще се разглеждат при класовенаследници

24. Класове и обекти • Достъп до publicкомпоненти за външни функции – чрез обект или указател към обект • Достъп до privateкомпоненти – чрез функция (метод) като член - функция (интерфейсна) • Потребителски интерфейс – данни и функции - достъпни за потребителя point a,*pa; . . . a.init(5,6); //достъп чрез обекта а a.out(); pa=&a; //указатели към обект pa->init(5,6);//достъп чрез указател pa

25. #include <iostream.h> 1/2 classcat { unsigned int age; //по подразбиране private член-данни unsigned int weight; public: //Членове-функции за достъп (интерфейсни) unsigned int get_age(); void set_age(unsigned int agen); unsigned int get_weight(); void sеt_weight(unsigned int weightn); //Членове-функции void meow(); }; //Дефиниции на членове-функции void cat::meow() { cout<<”Meow!\n”; } Класове и обекти Пример с използване на интерфейсни функции

26. //Дефиниции на интерфейсни членове-функции 2/2 unsigned int cat::get_age() { return age; } void cat::set_age(unsigned int agen) { age=agen; } unsigned int cat::get_weight() { return weight; } void cat::set_weight(unsigned int weightn) { weight=weightn; } //Тестова програма voidmain() { catpegi; pegi.set_age(5); //достъп до age pegi.set_weight(6); //достъп до weight pegi.meow(); cout<<”pegiе котка на “; cout<<pegi.get_age()<<” години\n“ ”и тежи “<< pegi.get_weight()<<” кг\n”; } Класове и обекти Пример с използване на интерфейсни функции Meow! pegi е котка на 5 години и тежи 6 кг

27. Конструктори и деструктори • Конструктор – член-функция, която се извиква автоматично при създаване на обект (т.е. инициализира обекта). • Създаването на обекти е свързано с отделяне на памет, запомняне на текущо състояние, задаване на начални стойности и др. дейности, които се наричат инициализация на обекта. Общ вид за дефиниране на конструктор име_на клас::име_на_клас(списък_формални_параметри) { // Тяло на конструктор }

28. Конструктори и деструктори • Kонструкторът е член-функция, която притежава повечето характеристики на другите член-функции, но има и редица особености, като: • Конструкторът носи винаги името на класа. • Конструкторът е член-функция, която не връща резултат ( не се записва void). Типът на резултата е указателят this и явно не се указва. • Изпълнява се автоматично при създаване на обекти. • Не може да се извиква явно (обръщение от вида p.point(1,4) е недопустимо). • Конструкторът може да има нула, един, два или повече параметъра. • В един клас може явно да не е дефиниран конструктор. • Класът може да има повече от един конструктора.

29. Конструктори и деструктори • Деструктор - член-функция, която се извиква автоматично при разрушаване на обекта. • Деструкторът носи винаги името на класа, предхождано от символ ~. • Деструкторът е член-функция, която не връща резултат ( не се записва void). • Деструкторът няма параметри. • Деструктурът в класа е един единствен. Общ вид за дефиниране на деструктор ~име_на_клас::име_на_клас( ) { //Тяло на деструктор }

30. Пример с използване на конструктор и деструктор #include <iostream.h> classtest { intnum; public: test(int); //Конструктор с един параметър; не връща резултат ~test(); //Деструктор; няма параметри; не връща резултат }; tets::test(int n) { num=n; cout<<”Конструктор num=”<<num<<”\n”; } test::~tset() { cout<<”Деструктор num=”<<num<<”\n”; } void f(int); void main() { testa(1); //Създаване на обект с конструктор for(int i=1;i<=2;i++) f(i); } voidf(intp) { testx(2*p); } //Създаване на обект с конструктор Конструктори и деструктори Конструктор num=1 Конструктор num=2 Деструктор num=2 Конструктор num=4 Деструктор num=4 Деструктор num=1

31. Конструктори и деструктори Конструктори и Деструктори по подразбиране. • Съществуват конструктори и деструктори по подразбиране, т.е. вградени във всеки клас. • Конструкторът по подразбиране присвоява някакви (не желаните) начални стойности. • Деструкторът по подразбиране е достатъчен, освен в случаите, когато не е необходимо освобождаване на динамична памет.

32. classrect { int l,w; public: rect(); rect(int i); rect(int i, int j); ~rect(); }; rect::rect() { l=w=0; } rect::rect() или rect::rect():l(5),w(6) { } {l=5; w=6; } rect::rect() { cout<<“l=“; cin>>l; cout<<“w=“; cin>>w; } rect::rect() { }//за временен обект rect::rect(int i) //извикване с: rect a(5); { l=w=i; }//rect a; е грешка rect::rect(int i,int j) //извикване с: rect a(3,4); { l=i; w=j; }//rect a(3),b; са грешки Четири начина за дефиниране на конструктор без параметри – извикват се при създаване на обект rect a; Класове и обекти Видове конструктори Не са грешки при подразбиращи се параметри в декларациите: rect(int i=0); rect(int i=0,int j=0);

33. Пример илюстриращ необходимостта от деструктор #include <iostream.h> 1/2 #include <stdlib.h> classtest { intnbr; //брой елементи в динамичния масив int*v;//указател към началото на масива public: test(int);//конструктор ~test();//деструктор void out(); }; test::test(int n) { v=newint[nbr=n];//резервира динамична памет за масива if(v == NULL) exit(1); for(int i=0;i<n;i++) v[i]=i; } test::~test() { delete v; }//освобождава динамичната памет Класове и обекти

34. void test::out() 2/2 { for(int i=0;i<nbr;i++) cout<<v[i]<<” ”; cout<<”\n”; } void main() { test tab(10); //създава се масив с 10 елемента tab.out();//извеждат се: 0 1 2 3 4 5 6 7 8 9 } Класове и обекти Примерилюстриращ необходимостта от деструктор - изпълнение

35. Вградени член-функции (inline) • При извикването им се вграждат от компилатора съответните инструкции на машинен език. • Те съдържат малък брой прости оператори (без оператори за цикъл). • Повишава се ефективността на програмата при кратки функции. 1 начин за използване – с ключова дума inline class test { int x,y; public: inline test(); . . . }; inline test::test() { x=0; y=0; } Декларация на вградена ( inline ) функция Дефиницията на вградена ( inline )функция

36. Вградени член-функции (inline) 2 начин за използване – без ключова дума inline class test { int x,y; public: test() { x=0; y=0; } . . . }; Дефиницията на вградената функция се поставя в декларацията на класа

37. Вградени член-функции (inline) Пример за вградени функции #include <iostream.h> 1/2 class cat { int age; public: cat(int age_n); //конструктор ~cat(); //деструктор int get_age ( ) { return age; } //inline функция void set_age(int age_new) {age=age_new; } //inlineфункция inline void meow(); };

38. Вградени член-функции (inline) Пример за вградени функции cat::cat(int age_n) { age=age_n; } //Дефиниция на конструктор2/2 cat::~cat() { } //Дефиниция на деструктор inlinevoidcat::meow() //Дефиниция на член-функция { cout<<”Meow!\n”; } void main() { cat Bimbo(5); //cat Bimbo; –>грешка cout<<”Bimboе котка на “; cout<<Bimbo.get_age()<<”години и казва “; Bimbo.meow(); Bimbo.set_age(7); cout<<”Bimbo е вече на “<<Bimbo.get_age()<<” години.\n”; } Bimbo е котка на 5 години и казва Meow! Bimbo е вече на 7 години.

39. Указател this • Всяка член-функция има неявен (скрит) параметър this. • Този указател позволява пряк достъп до обекта, за който се извиква член-функцията име_на_обект.име_на_функция(параметри); • Той се използва неявно за пряк достъп до член-променливите на класа. • В член-функция с thisсе работи както с всеки друг указател.

40. Указател this • Как компилаторът на C++ обработва член-функция и обръщение към член-функция на клас. Извършват се следните преобразувания: • Всяка член-функция на даден клас се транслира в обикновена функция с уникално име и един допълнителен параметър – указателят this. void point::out() { cout<<”Точка с координати:”<<x<<” “<<y<<”\n”; } void point::out_p(point *this) { cout<<”Точка с координати:”<<x<<” “<<y<<”\n”; }

41. Указател this • Всяко обръщение към член-функция се транслира в съответствие с преобразуванието. • Указателят this може да се използва явно в кода на съответната член-функция. . . . point p; p.out(); . . . point p; p.out_p(&p); void point::out() { cout<<”Точка с координати:”<<this ->x<<” “<<this ->y<<”\n”; }

42. classrect { int l,w; public: rect(); ~rect(); void set_l(int ln) { this -> l = ln; } //член-функция за достъп int get_l() const { return this -> l; } //член-функция за достъп void set_w(int wn) { w = wn; } int get_w() const { return w; } }; rect :: rect () : l(10), w(5) { } rect :: ~rect() { } void main() { rect r; cout <<“Правоъгълник с дължина “<< r.get_l()<<“ см\n”; cout << “и широчина “ << r.get_w()<<“ см\n”; } Указател this • Пример Член- функцията не променя данните Правоъгълник с дължина 10 см и широчина 5 см

43. Предефинирани (презаредими) член-функции • Това са функции, които имат едно и също име, но различно съдържание и действие. • При извикване на такава функция, управлението се предава на тази от едноименнитефункции, чиито формални параметри отговарят на фактическите при извикването.

44. Предефинирани (презаредими) член-функции #include <iostream.h> 1/2 class point { intx,y; public: point(); //конструктор1 без параметри point(int);//конструктор2 с 1 параметър point(int,int); //конструктор3 с 2 параметъра voidout(); //член-функция без параметри voidout(char *); //член-функция с 1 параметър }; Декларации на 3 конструктора Декларации на 2 едноименни функции

45. point::point() { x=0; y=0; } //дефиниция на конструктор1 2/2 point::point(intabs) { x=y=abs; } //дефиниция на конструктор2 point::point(int abs,int ord) //дефиниция на конструктор3 { x=abs; y=ord; } voidpoint::out() //дефиниция на outбез параметри { cout<<”координати:”<<x<<” “<<y<<”\n”; } void point::out(char *mes) //дефиниция на out с параметър { cout<<mes; out(); } voidmain() { pointa; a.out(); pointb(5); b.out(“b-“); pointc(3,12); c.out(“Моите “); } Предефинирани (презаредими) член-функции координати:0 0 b-координати:5 5 Моите координати:3 12