#include "stdafx.h"
#include "stdio.h"

int* getval()
{
	// създаваме локална променлива
	int x=1;
	// Връщаме адреса й - това е проблема!
	// Такава грешка може да се направи например
	// когато правим някакви временни изчисления.
	return &x;
}

// Функция, която "не прави нищо"
void dummyFunc()
{
	int x=2;
}

int main()
{
	int *p;
	p = getval();
	printf ("*p = %d\n", *p);
	dummyFunc();
	printf ("*p = %d\n", *p);
	return 0;
}

Изпълнението на горният код „изненадващо“ е:

*p = 1
*p = 2

Интересното е, че в горния пример компилаторът много добре се ориентира и връща warning:

warning C4172: returning address of local variable or temporary

При въпросната задача студентът много добре беше замаскирал действието и компилаторът не връщаше никакви предупреждения. Отне ми цяла вечер :)

Първата стъпка е да прибавим класа чрез #include. Вектор се дефинира по следния начин:

	#include <vector>
	//...
	std::vector<тип> v;

Синтаксисът изисква указване на типа елементи във вектора. Често е удобно да използваме typedef при дефиниране на вектори. Например:

	typedef std::vector<int> int_vec;
	int_vec v1, v2;

Така например създадохме вектор с елементи от тип int. Използването му по-нататък е много сходно с това на масивите. Ето например как създаваме вектор от 10 елемента, и запълваме елементите му с числата от 1 до 10:

	std::vector<int> v(10);
	for(int i=0; i<10; i++) v[i] = i+1;

Виждате, че в класът вектор е предефиниран операторът []. Аналогично действа член-функцията at(int):

	v.at(1000) = 5;

Ако елемент с такъв индекс не съществува, то ще бъде върнат обект от тип std::out_of_range. Ще разгледаме подробно как може да бъде използван в тема за обработка на грешки. Съществена разлика между [int] и .at(int) се явява ако сте насочили указател към вектор. При използване на [] то е възможно векторът да се премести на нов адрес (например при разширение, което ще покажем по-долу) и така указателят ви да сочи на грешна позиция. При функцията at този проблем не съществува, тъй като тя работи с фиксиран размер на вектора. Поради тази причина бъдете особено внимателни при използването на указатели към вектор.

Дефиниран е и операторът =:

	std::vector<int> v2(10);
	v2 = v;

Две член функции begin и end връщат адреса на началото и края на вектора. Използват се ефективно при употребата на interator. Следният пример демонстрира обхождането на вектор и отпечатването му на екрана:

	vector<int>::iterator it;
	std::cout << "v contains:";
	for (it=v.begin(); it<v.end();it++ ){
		std::cout << " " << *it;
	}

Принципно можете да пъстигнете абсолютно същия ефект чрез използването на .at или [] и обхождане на вектора чрез указатели. Въпреки това свикването за използване на iterator се насърчава, тъй като ще е значително по-лесно да го използвате при стандартни алгоритми като сортиране например, тъй като член-функция за тази цел не се предлага, а я има реализирана като шаблонна функция.

Дотук не показахме нищо значително ново в сравнение с обикновените масиви. Нека да разгледаме следния случай – представете си, че имаме масив, в който записваме динамично данни. В един момент може да се окаже, че масива се е запълнил и нямаме достатъчно място. Векторите решават този проблем:

	#include "stdafx.h"
	#include <vector>
	#include <iostream>
	using namespace std;

	void main(){
		// Дефинираме празен вектор
		vector<int> v;
		// Функцията size() показва броя елементи на вектора
		cout << "initial: " << v.size() << endl;
		// Чрез push_back можем да добавим елемент
		v.push_back(12);
		cout << "after I add one element: " << v.size() << endl;
		// Добавяме още 10 елемента
		for (int i=0; i<10; i++) v.push_back(i);
		cout << "after I add 10 more: " << v.size() << endl;

		// Отпечатваме съдържанието на вектора
		cout << "the array contents are:";
		for (i=0; i<v.size(); i++) cout << " " << v[i];
		cout << endl;

	}

Виждате, че функцията push_back добавя елемент в края на вектора. Тук демонстрирахме и създаването на празен вектор (в предишните примери резервирахме памет за поне десет елемента), както и член-функцията size. Често се използват още две функции – capacity и max_size. Проверете резултатът от следния пример

	#include "stdafx.h"
	#include <vector>
	#include <iostream>
	using namespace std;

	void main(){
		vector<int> v;

  		for (int i=0; i<100; i++) v.push_back(i);

		cout << "size: " << (int) v.size() << endl;
		cout << "capacity: " << (int) v.capacity() << endl;
		cout << "max_size: " << (int) v.max_size() << endl;
	}

Ще забележите, че size връща текущия брой елементи записани във вектора, capacity показва памет за колко елемента е резервирана (т.е. векторът може по подразбиране да задели повече памет отколкото използваме!), а max_size определя максималният в момента свободен блок памет, който може да бъде заделен за нашият вектор. Ако искаме да резервираме допълнително памет (да увеличим capacity), то можем да използваме функцията reserve:

	v.reserve(200);
	cout << "now capacity is: " << (int) v.capacity() << endl;

Ако подадем по-малка стойност на reserve отколкото е текущия capacity, то функцията няма да направи нищо. С resize обаче можем да „изрязваме“ елементи от вектор:

	v.resize(12);
	cout << "size: " << (int) v.size() << endl;
	cout << "capacity: " << (int) v.capacity() << endl;
	cout << "max_size: " << (int) v.max_size() << endl;

Изпълнете примера и отпечатайте съдържанието на вектора. Ще видите, че capacity се е запазило, но size е станал 12 и всички елементи след този с индекс 11 са изтрити. Нека сега да извикаме resize чрез втория му конструктор:

	v.resize(20, 5);

По този начин добавихме 8 елемента със стойност числото 5 в края на вектора. Това е просто по-лесен начин за добавяне на множество еднакви елементи. Като бързина в сравнение с push_back няма почти никаква разлика.

Вече споменахме функцията at(int). Други две функции, които можем да използваме са front() и back(), чрез които достъпваме съответно първия и последния елемент на вектор. Друга полезна функция е empty(). Тя връща 0 ако в масива има елементи и true ако векторът е празен. Използва се като еквивалент на size()==0.

Много ценна възможност на векторите е да ги използваме за реализацията на структурата стек. Вече се запознахте с функцията push_back, която практически добавя елемент в края на стек. В класа vector са се погрижили и за функция за премахване на елемент от стек:

	v.pop_back();

Така просто изтриваме последния елемент на вектора. Имайте в предвид, че тя ще намали size(), но не и capacity().

Накрая една изключително силна възможност на векторите, е тяхната функционалност на структура от тип списък, а именно: вмъкване и изтриване на елементи във вектора. За целта е нужно използването на iterator:

	#include "stdafx.h"
	#include <iostream>
	#include <vector>
	using namespace std;

	void showvector(vector<int> &v){
		if (v.empty()) cout << "empty vector" << endl;
		else{
			vector<int>::iterator it;
			for (it=v.begin(); it<v.end();it++ ){
				cout << " " << *it;
			}
		}
		cout << endl;
	}

	int main (){
		// създава вектор от три елемента
		// всеки от които със стойност 5
		vector<int> v(3,5);
		// добавяме още три елемента
		v.push_back(10);
		v.push_back(11);
		v.push_back(12);
		// показва елементите на вектора
		showvector(v);

		vector<int>::iterator it;
		// накочваме инетатора към 5ти елемент
		it = v.begin()+4;
		// добавяме числото 33 като пети елемент
		v.insert(it, 33);
		showvector(v);

		// създаваме втори вектор
		vector<int> v2(0);
		v2.push_back(999);
		v2.push_back(999);

		// насочваме итератора към трети елемент
		it = v.begin()+2;
		// вмъкваме вектор v2 преди трети елемент на v
		v.insert(it, v2.begin(), v2.end());
		showvector(v);

		// изтриваме 6ти елемент
		it = v.begin() + 5;
		v.erase(it);
		showvector(v);

		// изтриваме елементите от 3ти до 7ми включително
		it = v.begin();
		v.erase(it+2, it + 7);
		showvector(v);

		// разменяме съдържанието на двата вектора
		cout << "the vectors are:" << endl;
		showvector(v);
		showvector(v2);
		cout << "swapped" << endl;
		v.swap(v2);
		showvector(v);
		showvector(v2);

		// изтриваме съдържанието на вектор
		v.clear();
		showvector(v);

		return 0;
	}

	template <class <име-на-класа>>;
	<декларация на функция>

Следният пример демонстрира как може да напишем една функция „max“ връщаща по-голямото от две числа, като може да й подадем различни типове данни:

	#include "stdafx.h"
	#include <iostream>
	using namespace std;

	template <class T>
	T max (T a, T b) {
		T result = (a>b)?a:b;
		return (result);
	}

	void main (){
		int a=3, b=4;
		int c = max<int>(a,b);
		cout << "max(" << a << ",";
		cout << b << ") = " << c << endl;

		double d=4.6, e=2.18;
		double f = max<double>(d,e);
		cout << "max(" << d << ",";
		cout << e << ") = " << f << endl;

		// Може да сравнява и символи по ASCII код
		char g='a', h='z';
		char i = max<char>(g,h);
		cout << "max(" << g << ",";
		cout << h << ") = " << i << endl;
	}

* Забележка: В примера типа данни в ъгловите скоби може да се пропусне при извикването на функцията, защото променливите които подаваме са от един и същ тип, както и очакваните входни параметри. Ако предаваме променливи от различен тип, то е задължително да укажем в какъв тип ще преобразуваме.

Възможно е да създадете шаблон, който работи с повече типове:

	template
	A GetMin (B x, C y) { ... }

Ето как можем да използваме шаблони върху класове и техните член-функции:

	#include "stdafx.h"
	#include <iostream>
	using namespace std;

	template <class T>
	class myClass {
		T a, b;
	public:
		myClass(T a, T b){
			this->a=a;
			this->b=b;
		}

		T getmax();
	};

	template <class T>
	T myClass<T>::getmax (){
		return ((a>b)?a:b);
	}

	void main () {
		int x = 5;
		int y = 6;
		myClass <int> obj(x, y);
		cout << obj.getmax() << endl;

		double a = 8.12;
		int b = 4;
		// Ще преобразуваме данните в double
		myClass <double> obj2(a, b);
		cout << obj2.getmax() << endl;
		// А сега ще ги преобразуваме в int
		myClass <int> obj3(a, b);
		cout << obj3.getmax() << endl;
	}

Виждате, че използвайки шаблони ние можем да правим нашите функции и класове много по-универсални.

	<тип-резултат> <име-на-клас>::operator<#>(<аргументи>)
	{
		//изпълнявана операция
	}

Типът на връщания резултат най-често е същият като типа на класа, за който е дефиниран операторът. Операторът, който се предефинира, замества # в конструкцията. Когато една операторна член-функция предефинира бинарен оператор, функцията ще приема само един параметър. Този параметър ще получава обекта, който е от дясната страна на оператора. Обектът от лявата страна е този, който генерира обръщението към операторната функция и точно той се предавa неявно на функцията посредством указателя this.

Пример: Следната програма предефинира операторите +, – и = за клас координатна система:

	#include "stdafx.h"
	#include <iostream>
	using namespace std;

	class coord {
	private:
		int x, y;
	public:
		coord(){
			x=0;
			y=0;
		}
		coord(int x, int y){
			this->x=x;
			this->y=y;
		}
		int get_x(){
			return (this->x);
		}
		int get_y(){
			return (this->y);
		}
		void show(){
			cout << "x = " << get_x() << endl;
			cout << "y = " << get_y() << endl;
		}
		// Бинарни оператори + и -
		coord operator+(coord &);
		coord operator-(coord &);
		// Оператор за присвояване
		coord operator=(coord);
		// Унарни оператори
		coord operator++(); // Префиксен
		coord operator++(int); // Постфиксен
		coord operator--(); // Префиксен
		coord operator--(int); // Постфиксен
	};

	coord coord::operator+(coord &obj){
		coord temp;

		temp.x = this->x+obj.x;
		temp.y = this->y+obj.y;

		return temp;
	}

	coord coord::operator-(coord &obj){
		coord temp;

		temp.x = this->x-obj.x;
		temp.y = this->y-obj.y;

		return temp;
	}

	coord coord::operator=(coord obj){
		this->x = obj.x;
		this->y = obj.y;

		return *this;
	}
	coord coord::operator++(){
		this->x++;
		this->y++;
		return *this;
	}

	coord coord::operator++(int i){
		this->x++;
		this->y++;
		return *this;
	}

	coord coord::operator--(){
		this->x--;
		this->y--;
		return *this;
	}

	coord coord::operator--(int i){
		this->x--;
		this->y--;
		return *this;
	}

	int main(){
		coord o1(5,5), o2(2,-2), o3;
		cout << "O1: " << endl;
		o1.show();
		cout << endl;
		cout << "O2: " << endl;
		o2.show();
		cout << endl;

		cout << "o3 = o1 + o2 =>" << endl;
		o3 = o1 + o2;
		o3.show();
		cout << endl;

		cout << "o3 = o1 - o2 =>" << endl;
		o3 = o1 - o2;
		o3.show();
		cout << endl;

		cout << "o3 = o1 =>" << endl;
		o3 = o1;
		o3.show();
		cout << endl;

		o3++;
		cout << "o3++ =>" << endl;
		o3.show();
		cout << endl;

		++o3;
		cout << "++o3 =>" << endl;
		o3.show();
		cout << endl;

		o3--;
		cout << "o3-- =>" << endl;
		o3.show();
		cout << endl;

		--o3;
		cout << "--o3 =>" << endl;
		o3.show();
		cout << endl;
		return 0;
	}

Операторната функция operator=() връща *this, т.е. тя връща обекта, на който се присвоява стойност. Връщайки като резултат *this, предефинираният оператор за присвояване позволява на обектите да бъдат използвани в поредица от присвоявания. Например:

		о3 = о2 = о1;

При предефиниране на операциите + и – използвахме псевдоними да предаване на стойността. В други случаи може да се наложи да ги предавате по стойност (както направихме с оператора =).

При унарните оператори ако оператора се намира пред операнда (напр. ++o3), то се извиква функцията operator#(). Ако оператора е след операнда (напр. o3++), то се извиква функцията operator#(int i). В този случай на „i“ винаги ще се предава стойност 0.

Задача: Препишете горният пример, така че функциите бинарните и унарните оператори да са приятелски функции.

	#include "header1.h"
	#include "header2.h"

Нека обаче в тези файлове се съдържат класове с повтарящи се имена:

	// header1.h
	class myClass {
		...
	};
	...

	// header2.h
	class myClass {
		...
	};
	...

В такъв случай моментално в нашата програма ще се получи конфликт, понеже ще се опитаме да дефинираме myClass два пъти. Този проблем се решава, като използваме namespace конструкцията:

	// header1.h
	namespace header1 {
		class myClass {
			...
		};
	}

	// header2.h
	namespace header2 {
		class myClass {
			...
		};
	}

Когато искаме да използваме така създадените header файлове ние имаме два метода за работа с класовете в тях. Първият начин е да се извикват директно, чрез указване на namespace:

	main(){
		...
		header1::myClass a;
		header2::myClass *d = new header1::myClass;
		...
	}

Друг начин е да използваме ключовата дума “using” за един от класовете:

	main(){
		...
		using namespace header1;
		myClass a; // a ще е от класа в header1
		header2::myClass *d = new header2::myClass;
		...
	}

Имайте в предвид, че ако укажете “using namespace header1″ и “using namespace header2″ отново ще се появи споменатият преди това конфликт. Затова при използване на namespace се препоръчва да се използва операторът “::”. Ако дефинирате namespace, който няма име, то той по подразбиране ще бъде включен чрез ключовата дума “using” от компилаторът.

Интересна и често използвана при писане на библиотеки възможност са вложени namespace:

	namespace root
	{
		class A{
		public:
			int var1;
		};

		namespace sub
		{
  			class A{
			public:
				int var2;
			};
		}
	}

	int main () {
		root::A a;
		a.var1 = 5;

		root::sub::A b;
		b.var2 = 6;

		return 0;
	}

Най-често използвания и най-популярен namespace е “std”. Принципно “C++ Standards Committee” са пренаписали напълно стандартната библиотека на C++, като са сложили най-често използваните стандартизирани обекти в този namespace.

Друго много важно обновяване на езика е въвеждането на нов стил header файлове. Досега не сме ги разглеждали, понеже целяхме да имаме максимална съвместимост за програми писани на С и стари компилатори. В кода на програмата всъщност няма особена разлика – просто не се добавя “.h” в името на файла при include:

	Стар стил:
	#include "iostream.h"
	#include "fstream.h"
	#include "string.h"
	#include "math.h"
	#include "stdlib.h"

	Нов стил:
	#include <iostream>
	#include <fstream>
	#include <string>
	#include <math>
	#include <cstdlib>

Въпреки, че имат известни разлики в имплементацията (например fstream.h добавя iostream.h автоматично, а fstream не; string.h използва С-стил низове, а string използва обектни низове; r тн) главната функционалност и най-често използваните функции остават същите. Препоръчително е при писането на програми за нови компилатори да използвате новата конвенция. Нещата, които трябва да запомните са:
1. Никога не “миксирайте”, като вкарвате библиотеки от стар и нов стил едновременно.
2. Ако компилаторът поддържа новите библиотеки, то е добре да използвате тях, тъй като се счита, че функционалността и надеждността при тях е подобрена.
3. Не е изключено в близко бъдеще новите компилатори да не поддържат старите библиотеки.
4. Ако искате да използвате namespace std, то трябва да добавите поне една от новите библиотеки.

По принцип всички функции в новите стандартни библиотеки използват namespace std. Следният пример демонстрира това, като в допълнение показва още една новост за миксиране на глобални и локални променливи с едно и също име:

	#include "stdafx.h"
	#include
	// Глобална променлива
	int var = 5;

	void main(){
		// Локална променлива
		int var = 10;
		// Отпечатваме локалната променлива
		std::cout << var << std::endl;
		// Отпечатваме глобалната променлива
		std::cout << ::var << std::endl;
		// Добавяме namespace std
		using namespace std;
		// Вече може да използваме cout директно
		cout << "Hello world" << endl;
	}

Забележете, че ако не сме добавили “using namespace std” при новия стил функции, то програмата няма да разпознае функциите ако не ги извикаме чрез “std::”.

Пример: Следната програма създава общ базов клас, наречен area, който съдържа двата размера на една фигура. Той също така декларира чисто виртуална функция getarea(), която е предефинирана от производните класове, и връща лицето на типа фигура, дефинирана от производния клас.

	#include "stdafx.h"
	#include "iostream.h"

	class area {
		double dim1, dim2;
		public:
		void setarea(double d1, double d2)
		{
			dim1 = d1;
			dim2 = d2;
		}
		void getdim(double &d1, double &d2)
		{
			d1 = dim1;
			d2 = dim2;
		}
		virtual double getarea() = 0;
	};

	class rectangle : public area {
		public:
		double getarea()
		{
			double a, b;
			getdim(a, b);
			return a*b;
		}
	};

	class triangle : public area {
		public:
		double getarea()
		{
			double a, ha;
			getdim(a, ha);
			return (a*ha)/2;
		}
	};

	int main()
	{
		rectangle r;
		int a, b;
		cout << "Vavedete daljinata na stranata a: ";
		cin >> a;
		cout << "Vavedete daljinata na stranata b: ";
		cin >> b;
		r.setarea(a, b);

		triangle t;
		cout << "Vavedete stranata AB na triagalnik: ";
		cin >> a;
		cout << "Vavedete visochinata kam tazi strana: ";
		cin >> b;
		t.setarea(a, b);

		area *p;

		p = &r;
		cout << "Pravoagalnikat ima lice: ";
		// Извикваме виртуалната функция от клас area
		cout << p->getarea() << endl;

		p = &t;
		cout << "Liceto na triagalnika e: ";
		// Отново извикваме виртуалната функция от клас area
		// но тя вече сочи съм getarea() от triangle
		cout << p->getarea();
		cout << endl;
		return 0;
	}

Нека например класа vehicle има два производни класа: motorvehicle (добавя допълнителна информация за типа двигател на превозното срество) и passengervehicle (добавя информация за максималния брой пътници в превозното средство). Ако създадем клас car, който наследява едновременно motorvehicle и passengervehicle, то ние ще получим дублиране на член-променливи, тъй като класа car ще наследи двукратно член-променливите декларирани в класа vehicle.

Многократното наследяване може да се избегне чрез наследяване на базовия клас като виртуален. Това предотвратява присъствието на 2(или повече) копия на базовия клас във всеки следващ индиректен производен клас. Декларацията в този случай ще има вида:

	class vehicle { ... };
	class motorvehicle : virtual public vehicle { ... };
	class passengervehicle : virtual public vehicle { ... };
	class car : public motorized, public road_use { ... };

Ето как ще изглежда примерната програма:

	#include "stdafx.h"
	#include "iostream.h"

	class vehicle {
		int num_wheels;
		int weight;
		public:
		vehicle(int w, int r)
		{
			num_wheels = w; weight = r;
		}
		void showv(){
			cout << "Wheels:" << num_wheels << endl;
			cout << "Weight:" << weight << endl;
		}
	};

	enum motor {gas, electric, diesel};

	class motorvehicle : virtual public vehicle {
		enum motor mtr;
		public:
		motorvehicle(enum motor m, int w, int r) : vehicle(w, r) {
			mtr = m;
		}

		void showm() {
			cout << "Motor: ";
			switch(mtr) {
				case gas : cout << "Gas";
					break;
				case electric : cout << "Electric";
					break;
				case diesel : cout << "Diesel";
					break;
			}
			cout << endl;
		}
	};

	class passangervehicle : virtual public vehicle {
		int passengers;
		public:
		passangervehicle(int p, int w, int r) : vehicle(w, r){
			passengers = p;
		}

		void showp() {
			cout << "Passengers:" << passengers << '\n';
		}
	};

	enum steering {power, rack_pinion, manual};

	class car : public motorvehicle, public passangervehicle {
		enum steering strng;
		public:
		car(enum steering s, enum motor m, int p, int w, int r) :
			motorvehicle(m, w, r), passangervehicle(p, w, r), vehicle(w, r)
		{
			strng = s;
		}

		void show() {
			showv();
			showp();
			showm();
			cout << "Steering: ";
			switch(strng) {
				case power : cout << "Power";
					break;
				case rack_pinion : cout << "Rack and pinion";
					break;
				case manual : cout << "Manual";
					break;
			}
			cout << endl;
		}
	};

	int main() {
		car c(power, gas, 5, 4, 1200);
		c.show();
		return 0;
	}

Задача: Към горният пример добавете клас „truck“, който е производен само на класа „motorvehicle“ и добавя като функционалност член променлива load (максимален товар) и функция, която го отпечатва на екрана.

Дефиницирнето на указатели към фунции се получава по следният начин:

	<тип връщан резултат> (*<име>) (<входни параметри>);

Пример: Дефинираме две функции max и min, които предаваме чрез указател на друга функция show, която ги изпълнява:

	#include "stdafx.h"
	#include "iostream.h"

	void max(int a, int b){
		cout << "the bigger number is: ";
		cout << ((a>b)?a:b);
		cout << endl;
	}

	void min(int a, int b){
		cout << "the lower number is: ";
		cout << ((a<b)?a:b);
		cout << endl;
	}

	// show приема като трети параметър указател към
	// функция, която е от тип void и е с входни параметри
	// две числа от тип int
	void show(int x, int y, void(*pFunc)(int, int)){
		pFunc(x, y);
	}

	void main()
	{
		// Създаваме указател
		void(*ptr2func)(int, int);
		// Насочваме указателя към функцията max
		ptr2func = max;
		show(2 , 3 , ptr2func);
		// Сега насочваме указателя към min
		ptr2func = min;
		show(2 , 3 , ptr2func);
	}

От примера веднага става ясно, че синтаксисът не е много удобен за работа. Тук на помощ идва typedef, чрез който можем да зададем ново име на типа. Указателя от горният пример може да бъде създаден като тип по следния начин:

	typedef void(*COMPARE)(int, int);
	// Сега можем да създаваме обекти от тип COMPARE
	COMPARE ptr2func;

Задача: Създайте функции plus, minus, multiply и divide, които приемат две числа от тип double и връщат като резултат съответно тяхния сбор, разлика, умножение и деление. Създайте указатели към тези функции и ги изпратете последователно като параметър на функция show, която отпечатва резултатът.

	class <производен-клас>:<тип-достъп> <име-базов-клас> {
		//...
	};

Типът достъп е една от трите ключови думи: public, private или protected. Разликата между тях е:
- Ако наследяването е тип public, то на производния клас се допуска достъп до членовете на неговия собствен клас, на неговия базов клас и на функции, външни за класовете.
- Ако наследяването е тип protected, то се допуска достъп до членовете на неговия собствен клас, на неговия базов клас, но не се допуска достъп на функции външни за класа.
- Ако наследяването е тип private, то производният клас няма достъп до private елементите на базовия клас и външни функции.

Ако е необходимо да се предаде аргумент на конструктора на базовия клас, то всички необходими аргументи за базовия и за производния клас се предават на конструктора на производния клас. Като се използва разширената форма на декларация на конструктора на производния клас, могат да се предадат съответните аргументи и към базовия клас:

	<производен конструктор>(списък аргументи):<базов-клас>(списък аргументи) {
		//тяло на конструктора на производния клас
	}

Пример: Дефинираме базов клас vehicle и два производни класа – car и truck:

	#include "stdafx.h"
	#include "iostream.h"

	// Базов клас превозно средство
	class vehicle {
		int num_wheels;
		int weight;

		public:
		// Конструктор
		vehicle(int w, int r)
		{
			num_wheels = w;
			weight = r;
		}
		// Функция, която отпечатва броя гуми
		// и тежестта на превозното средство
		void showv(){
			cout << "Wheels: ";
			cout << num_wheels;
			cout << endl;
			cout << "Weight: ";
			cout << weight;
			cout << endl;
		}
	};

	// Клас кола наследява клас превозно средство
	class car : public vehicle {
		// Добавя се нова променлива
		int passengers;

		public:
		// Конструктора се предефинира, така че
		// да приема три аргумента. Два от тях се
		// предават като аргументи на конструктора
		// на базовия клас
		car(int p, int w, int r) : vehicle(w, r)
		{
			passengers = p;
		}

		// В нова функция show извикваме вече
		// съществуващата в базовия клас функция
		// showv и добавяме функционалност
		void show()
		{
			showv();
			cout << "Passengers: ";
			cout << passengers;
			cout << endl;
		}
	};

	// Аналогично създаваме втори производен клас
	class truck : public vehicle {
		int loadlimit;

		public:

		truck(int l, int w, int r) : vehicle(w, r)
		{
			loadlimit = l;
		}

		void show(){
			showv();
			cout << "Loadlimit: ";
			cout << loadlimit;
			cout << endl;
		}
	};

	int main()
	{
		car c(5, 4, 1200);
		truck t(30000, 12, 3000);
		cout << "Car: " << endl;
		c.show();
		cout << endl << "Truck " << endl;
	 	t.show();
		return 0;
	}

Задача: Съставете базов клас триъгълник с четири елемента дължина на съответните страни и конструктори, който инициализират и валидират входните данни. Направете функция на базовия клас за намиране на лицето на триъгълника по хереоновата хормула. Създайте:
- Производен клас „равнобедрен триъгълник“ и предефинирайте конструктора.
- Производен клас „равностранен триъгълник“ и предефинирайте конструктора. Напишете втора функция за изчисляване на лицето на триъгълник, която използва директно формулата за лице на равностранен триъгълник: a*a*sqrt(3)/4.

Задача: Дефинирайте два класа – програмист и мениджър. Всеки от класовете да съдържа public елементи име, години и трудов стаж. Като private елементи двата класа да имат елементи заплата и масив от 12 елемента от тип int, в който да се записват броя работни часове за месеците през годината. Напишете:
- Конструктори и деструктори на класовете.
- Приятелска функция за двата класа, която показва кой повече е работил през годината и съответно кой взима по-голяма заплата.

За да се справите с този проблем трябва да дефинирате такива големи масиви/обекти в динамичната памет:

	double *d = new double[1000000];

Операторът new записва обектите в динамичната памет, която е с обем почти цялата RAM памет на компютъра. В допълнение ако дори тази RAM не е достатъчна, то операционната система ще ви позволи да пишете и на хард диска в swap file/partition. За да работите с масива от примера например ще се наложи да си припомните урока за адресна аритметика. Единствения недостатък в случая, е че трябва да се грижим явно да „унищожаваме“ елементите чрез оператора delete.

Задача: Създайте масив от 1 милион елемента от тип long и го запълнете с числата от едно до един милион. След това запишете съдържанието на масива във файл, като използвате интервал като разделител за числата. Добавете нов ред след всяко десето число.

1. Независима приятелска функция: Тези функции се декларират във всеки от класовете като приятелски. Те не са член-функции на класа и затова те нямат достъп до елементите му. Поради тази причина е необходимо подаването на обект по явен начин като параметър на функцията (съответно извикването ще се извършва чрез името на функцията и списък от фактически параметри).

Пример: Дефинираме два класа представляващи марки автомобили с обща функция за определяне на по-бързият автомобил:

	#include "stdafx.h"
	#include "iostream.h"

	// Предварителна декларация
	class bmw;
	class porsche;

	class bmw{
	private:
		unsigned maxspeed;
	public:
		// Приятелска функция
		friend int cmpspeed(bmw *, porsche *);

		bmw(char *, unsigned speed);
		char *model;
	};

	bmw::bmw(char *c, unsigned speed){
		model = c;
		maxspeed = speed;
	}

	class porsche{
	private:
		unsigned maxspeed;
	public:
		friend int cmpspeed(bmw *, porsche*);
		porsche(char *, unsigned speed);
		char *model;
	};

	porsche::porsche(char *c, unsigned speed){
		model = c;
		maxspeed = speed;
	}

	// Дефиниция на приятелската функция
	int cmpspeed(bmw *a, porsche *b){
		// Тя има достъп от елементите maxspeed
		// въпреки че те са private!
		return (a->maxspeed - b->maxspeed);
	}

	void main(){
		bmw *x6 = new bmw("X6 xDrive 35i", 239);
		porsche *cayenne = new porsche("Cayenne S", 270);
		if (cmpspeed(x6, cayenne) < 0){
			cout << cayenne->model;
			cout << " is faster!" << endl;
		}
		else{
			if (cmpspeed(x6, cayenne) > 0){
				cout << x6->model;
				cout << " is faster!" << endl;
			}
			else{
				cout << x6->model;
				cout << " and ";
				cout << cayenne->model;
				cout << " are at equal speeds";
			}
		}
	}

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

Пример: Отново условието от горният пример, но този път функцията cmpspeed е член-функция на класа bmw. Промените в кода са удебелени:

	#include "stdafx.h"
	#include "iostream.h"

	class porsche;

	class bmw{
	private:
		unsigned maxspeed;
	public:
		bmw(char *, unsigned speed);
		char *model;
		// За BMW вече cmpspeed е член-функция
		int cmpspeed(porsche *);
	};

	class porsche{
	private:
		unsigned maxspeed;
	public:
		// Извикваме функцията като приятелска
		friend int bmw::cmpspeed(porsche*);
		porsche(char *, unsigned speed);
		char *model;
	};

	bmw::bmw(char *c, unsigned speed){
		model = c;
		maxspeed = speed;
	}

	// Дефиниция на самата функция
	int bmw::cmpspeed(porsche *b){
		return (maxspeed - b->maxspeed);
	}

	porsche::porsche(char *c, unsigned speed){
		model = c;
		maxspeed = speed;
	}

	void main(){
		bmw *x6 = new bmw("X6 xDrive 35i", 239);
		porsche *cayenne = new porsche("Cayenne S", 270);
		if (x6->cmpspeed(cayenne) < 0){
			cout << cayenne->model;
			cout << " is faster!" << endl;
		}
		else{
			if (x6->cmpspeed(cayenne) > 0){
				cout << x6->model;
				cout << " is faster!" << endl;
			}
			else{
				cout << x6->model;
				cout << " and ";
				cout << cayenne->model;
				cout << " are at equal speeds";
			}
		}
	}

Задача: Дефинирайте класове успоредник, квадрат и правоъгълник и напишете член-функции за изчисляване на лицата и периметрите на фигурите. Напишете:
- Приятелска за трите класа функция, която отпечатва на екрана фигурата с най-голямо лице и самото лице.
- Член-функция на класа успоредник, която е приятелска за другите два класа и връща числата 0, 1 или 2 в зависимост от това коя от фигурите е с най-голям периметър.

Декларацията на класа има следния синтаксис:

	class  <име-на-клас>{
		// Декларации на член-променливи
		// Декларации на член-функции
	};

Дефиницията на член-функция има следния синтаксис:

	<връщан-резултат> <име-на-клас>::<функция>(вх. парам.)
	{
		// Tяло на функцията
	}

За да се създаде обект, се използва името на класа като спецификатор за типа. Следният ред декларира обект obj:

	<име-на-клас> obj;

Достъпът до публичните елементи на класа се осъществява с операторът точка (.). Например ако класът myclass на обекта obj има член-функция func() и член-променлива int k, то ние можем да ги използваме директно или чрез указатели по следния начин:

	#include "stdafx.h"
	#include "iostream.h"

	class myclass{
	public:
		void func();
		int k;
	};

	void myclass::func(){
		cout << k << endl;
	}

	void main(){
		myclass obj;
		obj.k = 5;
		obj.func();

		myclass *p;
		p = &obj;
		p->k = 12;
		p->func();
	}

Вече забелязахте, че видимите обекти се дефинират чрез „public:“. Възможно е да дефинирате и скрити обекти, които не могат да се достъпват директно:

	#include "stdafx.h"
	#include "iostream.h"

	// Заедно с дефиницията на класа
	// създаваме обект obj от тип myclass
	class myclass{
	public:
		void func();
	private:
		int k;
	} obj;

	void myclass::func(){
		k = 5;
		cout << k << endl;;
	}

	void main()
	{
		// obj.k = 3; ще даде грешка:
		// error C2248: 'k' : cannot access private
		//        member declared in class 'myclass'

		// Чрез публичната функция обаче
		// имаме индиректен достъп до "k"
		obj.func();
	}

Конструктурът на един клас се извиква всеки път, когато се създава обект от този клас. Всякаква инициализация на данни, която е нужно да се извършим за даден обект, може да се изпълни автоматично от функцията конструктор. Той има същото име като името на класа, към който принадлежи, и не притежава тип на връщан резултат. Общият вид на конструктора е:

	<име-на-клас>::<име-на-клас>(<аргументи>){
		//Тяло на конструктор
	}

Може да създаваме повече от един конструктори, но те трябва да се различават по техните аргументи.

Деструкторът се извиква автоматично при разрушаването на обект от класа. Деструктора може да извежда съобщение за разрушаване на обекта или да освобождава заделената за обекта динамична памет. Деструкторът има същото име като класа, но предшествано от символа ~. Деструкторът не може да връща резултат и не може да има аргументи:

	~<име-на-клас>::<име-на-клас>(){
		//Тяло на деструктор
	}

Пример: Създава клас правоъгълник с публични елементи двете страни и функция за пресмятане на лицето. Дефинират се два конструктора на класа и един деструктор:

	#include "stdafx.h"
	#include "iostream.h"

	class rectangle{
	public:
		// Два конструктора
		rectangle();
		rectangle(unsigned, unsigned);
		// Функциите могат да се описват и директно
		~rectangle(){
			cout << "Object destructed" << endl;
		}

		int area();
		unsigned sidea;
		unsigned sideb;
	};

	// Първият конструктор се извиква, без параметри
	// Ще поискаме потребителя да въведе страните
	rectangle::rectangle(){
		cout << "Enter side a: ";
		cin >> sidea;
		cout << "Enter side b: ";
		cin >> sideb;
	}

	// При втория конструктор ние сами сме указали
	// дължините на страните на правоъгълника
	rectangle::rectangle(unsigned a, unsigned b){
		sidea = a;
		sideb = b;
	}

	// Функцията, която връща лицето
	int rectangle::area(){
		return ((sidea) * (sideb));
	}

	void main(){
		// Създаваме нов обект и го инициализираме
		// чрез неговия конструктор
		rectangle *test = new rectangle();
		// Отпечатваме лицето на правоъгълника
		cout << "The area of the rectangle is: ";
		cout << test->area() << endl;
		// Извикваме деструктора и
		// освобождаваме паметта заета от обекта
		delete test;
		cout << endl << endl;

		// Тук създаваме директно правоъгълник
		// със зададени страни чрез втория конструктор
		rectangle *test2 = new rectangle(5,3);
		cout << "The area of the second rectangle is: ";
		cout << test2->area() << endl;
		delete test2;
	}

Както видяхте един клас може да има множество от конструктори, които се отличават по своите параметри. Това се нарича „предефиниране“ на функции. По абсолютно аналогичен начин е възможно да предефинирате член-функции на класа.

Задача: Създайте клас триъгълник с два конструктора. Първият е без параметри и изисква въвеждане на дължините на страните от потребителя (изисква се проверка на валидност на въведените данни, т.е. дали тези страни могат да са страни на триъгълник). Вторият конструктор създава триъгълник по директно зададени дължини на страни (но отново проверява за валидност на данните). Напишете функции за изчисляване на периметър и лице на така създадения триъгълник.

	<указател> = new <тип>;

Типа данни на указателя трябва да съвпада с типа данни на обекта, който създаваме. По този начин създаваме нова променлива, която е достъпна чрез указателя. Унищожаването на така създаден обект се осъществява, чрез операторът delete:

	delete <указател>;

Пример: Въвеждане на данни в едномерен масив и извеждане на данните му на екрана:

	// Брой обекти, които ще създадем
	int numobjects;

	cout<<"How many objects do you want: ";
	cin >> numobjects;

	int *a = new int[numobjects];

	int i;
	for(i=0; i<numobjects; i++){
		cout << "Enter element " << i << ":";
		cin>>a[i];
	}

	for(i=0; i<numobjects; i++){
		cout << setw(10) << a[i];
	}

	cout<<endl;

	// Унищожаваме масива от обекти
	delete [] a;

Пример: Програма, чрез която създаваме едносвързан линеен списък, с възможност да го отпечатваме на екрана:

	#include "stdafx.h"
	#include "iostream.h"

	struct list{
		int k;
		struct list *next;
	} *firstelement, *lastelement;

	void add(){
		if (firstelement == 0){
			firstelement = new struct list;
			cout << "Enter value: ";
			cin >> firstelement->k;
			firstelement->next = 0;
			lastelement = firstelement;
			return;
		}
		struct list *newelement = new struct list;
		cout << "Enter value: ";
		cin >> newelement->k;
		newelement->next = 0;

		lastelement->next = newelement;
		lastelement = newelement;
		return;
	}

	void show(){
		cout << "List of elements" << endl;
		struct list *p = firstelement;
		while (p != 0){
			cout << p->k << " -> ";
			p = p->next;
		}
		cout << "*" << endl << endl;
	}

	void main()
	{
		firstelement = 0;
		int action;
		do{
			cout << "1. Add element" << endl;
			cout << "2. Show list" << endl;
			cout << "3. Exit" << endl;
			cout << "Choose option: ";
			cin >> action;
			cout << endl;
			switch (action){
				case 1: add(); break;
				case 2: show(); break;
				case 3: break;
				default: cout << "Invalid option" << endl;
			}
		}while (action != 3);
	}

Задача: Преправете функцията add() така, че да не може да се въвеждат елементи в списъка от по-горния пример с повтарящи се стойности на k.

Задача: Реализирайте функция delete(int z), която изтрива елементът от списъка в по-горния пример, който съдържа стойност k = z

Задача: Реализирайте функция за сортиране на списъка.

Задача: Да се напише програма, която съставя списък от факултетните номера, имената и оценката на студент и предоставя функционалност за:
- Извежда данните за всички въведени студенти.
- Изтриване на студент по подаден факултетен номер.
- Сортиране на списъка спрямо оценка или спрямо име на студент и съответно извеждането на сортирания списък на екрана.
- Показва средният успех на студентите.

1. Константи: Досега, когато ни се налагаше да въвеждаме константи използвахме предпроцесора. Това не винаги е удобно, а освен това може да доведе до неочаквани грешки. Затова в С++ са въведени константи:

	const <тип> <име на променлива> = <стойност>;

Както се досещате те са много удобни при дефиниране на размерност на масиви, заделяне на памет и в всякакви подобни операции, където използваме една и съща постоянна величина на множество места в програмата. Важно е да се каже, че е задължително константите да се инициализират в момента на декларирането си.

За дефиниране на указатели към константи има една особеност – трябва указателят да се дефинира като указател към константен тип:

	const int x;
	const int *px;
	px = &x;

Така дефинираният указател ще „сочи“ адреса на променливата, но няма да може да променя нейната стойност.

Възможно и много често използвано е да се създадат константни указатели към не-константна променлива. По този начин указателят няма да може да променя стойността в оригиналните данни:

	int x, y=2;
	const int *p;
	p = &y;
	p = &x;
	x = 5;
	*p = 10; // тук получаваме грешка

Може да създаваме и указатели с константен адрес, които могат да променят стойността на променливата:

	int x, y;
	int *const p = &x;
	*p = 5;
	p = &y; // грешка

Накрая ще демонстрираме константен указател с константен адрес:

	int x, y;
	const int *const p = &x;
	*p = 5; // грешка
	p = &y; // грешка

2. Псевдоними: Известни са още като „съотнасящи“ типове (на английски reference types). Използват се за дефиниране на второ име на вече съществуващ обект:

	<тип> &<име на променлива> = <друга променлива>;

Например:

	int x = 5;
	int &refx = x;

След като са дефинирани можем да използваме псевдонимите все едно използваме оригиналните променливи. Изключително удобни са, когато искаме да предадем променливи като параметри на функция, която трябва да промени оригиналните параметри след изпълнението си (но не искаме да използваме синтаксиса на указатели). Следният пример демонстрира това:

	#include "stdafx.h"
	#include "iostream.h"

	void func(int &a, int &b){
		a--;
		b++;
	}

	int main(int argc, char* argv[])
	{
		int a=5, b=6;
		func(a, b);

		// Ще се отпечата "a=4, b=7"
		cout << "a=" << a << ", b=" << b;
		return 0;
	}

Освен това трябва да се отбележи, че когато инициализираме указател към псевдоним, то ние все едно дефинираме указател към „оригиналния“ обект.

Възможно е както вече демонстрираното предаване на превдоним като входен параметър на функция, така и функция връщаща резултат псевдоним.

3. Булев тип: Състои се от два елемента – стойностите true (истина) и false (лъжа). Дефинира се чрез ключовата дума bool:

	bool x, y=true;
	x = false;

Можем да използваме булевите променливи по същият начин както в С използвахме стойностите 0 и 1. Следният пример показва как може да използваме булева променлива като индикатор дали поредица от операции е завършила успешно:

	bool completed = false;
	... // правим изчисления и евентуално променяме "completed"
	if (completed) cout << "finished";
	else cout << "some error occured";

- Обектно-ориентирано програмиране
- Създаване и използване на абстрактни типове данни
- Подобрения на някои съществуващи конструкции

На практика вие можете да използвате всичко научено дотук от езика за програмиране С при С++ (най-малкото примерите от предишните статии са писани за компилаторът на Microsoft – Visual C++ 6.0). Затова няма да преразглеждаме вече научени езикови конструкции, а ще даваме примери за част от нововъведенията.

Ще започнем както обикновено с най-необходимите операции – Вход и изход: В библиотеката iostream.h можем да намерим два нови оператора за вход и изход – cin и cout. Тъй като вече знаете принципа на входно-изходните операции, ще демонстрираме използването им директно с пример:

    #include "stdafx.h"
    #include "iostream.h"
    int main(int argc, char* argv[])
    {
        int x;
        cout << "vavedete chisloto x: ";
        cin >> x;
        cout << "vavedohte: " << x << '\n';
        cout << "x + 2 = " << x+2 <<'\n';
        return 0;
    }

Ясно се вижда, че имаме изключително удобство при конкатенация на различни видове променливи. След като изпълните този пример може да забележите, че cin например има защита за входните данни, която решава редица проблеми, които виждахме в scanf. Следващият пример демонстрира използването на функции и указатели. В него записваме две числа и после ги отпечатваме на екрана:

    #include "stdafx.h"
    #include "iostream.h"

    void read (int*, int*);
    int max(int, int);
    void printmax(int);

    int main(int argc, char* argv[]){
        int x, y;
        read(&x, &y);
        int maxval = max(x, y);
        printmax(maxval);
        return 0;
    }

    void read(int *x, int *y){
        cout << "Please enter two numeric values: ";
        cin >> *x >> *y;
    }

    int max(int x, int y){
        if (x >y) return x;
        else return y;
    }

    void printmax(int maxval){
        cout << maxval << " is the largest value\n";
    }

Ето и един друг пример, в който използваме функцията get(), която принадлежи на входния поток cin, която взима символ и го записва в подадена променлива. Програмата демонстрира как може да прочетем поредица от символи от клавиатурата до натискане на CR и да ги преброим. Символите за нов ред и табулация не влизат в преброяването:

	char ch;
	int charCnt=0;
	while (cin.get(ch)) {
		if (ch == '\n') break;
		switch (ch){
			case '\t':
			case ' ': break;
			default: ++charCnt;
				 break;
		}
	}
	cout << "You typed " << charCnt << " characters" << "\n";
	return 0;

Има редица полезни функции, които ни помагат за форматирането на изходните данни. Те се намират в библиотеката iomanip.h и се наричат „манипулатори“:
- setw(int): указва с каква дължина ще бъде следващото извеждане на данни на екрана. Например:

	// Извежда 6 интервала последвани от текст abcd
	cout << setw(10) << "abcd";

- setprecision(int): Указва с колко цифри ще бъдат изведени последвалите числа с плаваща запетая. Например:

	double x = 12.5673;
	// Извежда "12.56"
	cout << setprecision(4) << x;

- setiosflags(формат): Дава възможност за задаване на редица форматирания на въведения текст. Следният пример демонстрира редица от тях:

	double number = 1234.45678;
	int number2 = 1234;
	// Отпечатва нов ред (вместо '\n')
	cout << endl;
	cout << '$';
	// Дефинира знака за запълване на празното място
	cout << setfill('*');
	cout << setw(12);
	// Чрез следните два реда се указва, че числото
	// ще бъде изведено с точност два знака след
	// десетичната запетая
	cout << setiosflags(ios::fixed | ios:: showpoint);
	cout << setprecision(2);
	// Получава се "$*****1234.46"
	cout << number << endl;

	// Подравняване вляво
	cout << setfill('*');
	cout << setw(10);
	cout << resetiosflags(ios::adjustfield);
	cout << setiosflags(ios::left);
	cout << "test" << endl;

	// Подравняване вдясно
	cout << setw(10);
	cout << resetiosflags(ios::adjustfield);
	cout << setiosflags(ios::right);
	cout << "test" << endl;

	// Отпечатва числото в тип HEX
	cout << setfill(' ');
	cout << resetiosflags(ios::basefield);
	cout << setiosflags(ios::hex);
	cout << number2 << endl;

	// Отпечатва числото в тип OCT
	cout << setfill(' ');
	cout << resetiosflags(ios::basefield);
	cout << setiosflags(ios::oct);
	cout << number2 << endl;

	// Отпечатва числото в тип HEX
	cout << setfill(' ');
	cout << resetiosflags(ios::basefield);
	cout << setiosflags(ios::dec);
	cout << number2 << endl;

Задача: Напишете програмата, която чете последователно числа от клавиатурата (до въвеждането на числото 0) и показва дали последното въведено число е четно или нечетно. Използвайте cin и cout за вход и изход.

Задача: Упражнете използването на cin и cout, като преработите други вече написани на C примери.

1. Скриптови програми: Последователно изпълнение на предварително зададена поредица от операции.

2. Процедурно програмиране: Възможност за „разклоняване“ на програмата, така че тя да извършва различни последователности от операции (процедури или както споменахме в т.1 – скриптове), в зависимост от въведени данни от потребителят. След изпълнение на дадена процедура програмата се „връща“ на мястото, където процедурата е извикана.

3. Модулно-процедурно програмиране: Предоставя възможност за обединяване на различни процедури в т.нар. „модули“. По този начин разделяме програмата на различни логически части, които се свързват почежду си чрез т.нар. „procedure calls“.

Обектно-ориентираното програмиране е подход, при който данните и алгоритмите за работа с тях се комбинират в цялостен “обект”, който може да бъде използван в множество програми. Основните концепции на ООП са обекти, класове, наследственост, полиморфизъм и динамично заделяне на памет.

Разпространена е тенденцията, че в разработката на софтуер ние се стремим да използваме колкото се може повече готови разработени функционалности и по този начин да „сглабяме“ програми, а не да ги пишем наново. Така ние всъщност използваме готови обекти и работим с тях чрез „интерфейс“. Предоставянето на достъп до обекта само чрез неговия интерфейс от съобщения се нарича капсулация. Това е подход, при който ние показваме само функциите и данните от даден обект, които трябва да бъдат видими при работа с него. Всичкият останал код се „капсулира“, т.е. скрива и защитава.

Класовете описват конструкцията на обектите и методите на работа с него. Класът сам по себе си не е обект, а просто шаблон, който показва как ще изглежда даден обект. Ние можем да създаваме множество обекти по шаблона на един клас. Схемата за достъп прилича много на тази при вече познатите структури. Може да се каже, че класовете всъщност са естествено продължение на идеята за структурния тип.

Наследяването е друга основна черта на обектно ориентираното програмиране. Тя е именно споменатата вече възможност да не пренаписваме код, а да го използваме наготово. Чрез наследяването ние взимаме кода на вече написан клас и единствено разширяваме или променяме неговата функционалност. Така ние моделираме и изграждаме системи от обекти.

Полиморфизмът ни дава възможност да разглеждаме един обект в различни форми. В C++ полиморфизмът се реализира чрез виртуалните функции.

Задача: Даден е едномерен масив от тип int. Запълнете масива с произволни числа и реализирайте функция, която намира най-голямото възможно число, образувано от елементите на масива.

Задача: В текстов файл са записани имена, телефони и e-mail адреси в следния формат:

Ivan, 0888555666, ivan@abv.bg
Petko, 0899555666, petko@yahoo.com
…

Напишете програма, която прочита файла и:
- Изважда имената и телефоните и ги записва в нов файл phonebook.txt, като всяко име и телефон са на отделен ред.
- Изважда всички e-mail адреси и ги записва във файл maillist.txt, като всеки адрес е на нов ред.

Ще разгледаме две от функциите за разпределение на паметта от високо ниво – malloc, calloc и free.

1. malloc: Резервира блок памет и връща указател към блока:

	int *p = (int *)malloc(unsigned bytes);

Чрез bytes указваме точно колко байта памет искаме да резервираме. Ако няма достатъчно памет в указателя p ще се запише NULL. Имайте в предвид, че ако се опитате да записвате информация чрез такъв указател програмата ще завърше с фатална грешка, затова винаги проверявайте резултатът от malloc!

2. calloc: Резервира блок памет и нулира всичките му байтове:

	int *p = (int *)calloc(unsigned number, unsigned elnumber);

Number e броя елементи, за които се заделя памет, а elnumber е типа данни на тези елементи. Например:

	// Заделя и нулира памет за 10 елемента от тип float
	int *p = (int *)calloc(10, sizeof(float));

3. free: Овобождава блока памет заделен чрез malloc или calloc:

	free(int *p);

Пример: Реализираме стек с използване на указатели, като предварително заделяме памет за него:

	#include "stdafx.h"
	#include "stdio.h"
	#include "stdlib.h"
	#define STACKSIZE 5

	// Ukazatel kam chisloto i
	int *pi;

	// Nachalo na steka
	int *pimin;

	// vkarvane na element v steka
	void push(){
		if (pi == pimin + STACKSIZE){
			printf("Stack is full! Please pop some elements\n\n");
			return;
		}
		else{
			int num;
			printf("Enter number to push in stack: ");
			scanf("%d", &num);
			*pi = num;
			pi++;
			return;
		}
	}

	// premahvane na element ot steka
	void pop(){
		if (pi == pimin){
			printf("Stack is empty!\n\n");
			return;
		}
		else{
			pi--;
			printf("Last element in stack: %d\n\n", *pi);
			return;
		}
	}

	int main(int argc, char* argv[])
	{
		// Zadeliame pamet za STACKSIZE na broi elementa s razmer int
		pimin = (int *)calloc(STACKSIZE, sizeof(int));
		pi = pimin;

		int action;
		do{
			printf("1. Push number to stack\n");
			printf("2. Pop number to stack\n");
			printf("3. Exit\n\n");
			printf("Choose action: ");
			scanf("%d", &action);
			switch(action){
				case 1:  push();
					break;
				case 2:  pop();
					break;
				case 3:  break;
				default: printf("invalid option\n\n\n");
					break;
			}
		} while(action != 3);

		free(pimin);
		return 0;
	}

Задача: Приложете техниката описана в статията Проблеми свързани с използването на scanf в горния пример.

1. open: Отваря файл с режим на достъп четене (0), запис (1) или четене+запис:

	int fd = open(char *path, int flags, mode_t mode);

Променливата fd се напича дескриптор на файла. Ако отварянето на файла не е възможно, то дескриптора ще получи стойност -1. Входния параметър name е символен низ, който описва пътя до файла в операционната система. Флаговете (flags) са следните:
O_RDONLY – само за четене.
O_WRONLY – само за запис.
O_CREAT – Създава файла ако той не съществува.
O_TRUNC – Изтрива съдържанието на файла.
…

Входния параметър mode определя режима на достъп. Той е валиден за UNIX операционни системи и се игнорира в DOS/WINDOWS:
S_IRUSR — Read for owner.
S_IWUSR — Write for owner.
S_IRGRP — Read for group.
S_IROTH — Read for other.
…

Следният пример демонстрира отваряне на файл:

	int fd;
	if ((fd = open("test.txt", O_RDONLY, 0)) < 0) printf("Open failed");

2. close: Затваря файл, отворен чрез open за четене и запис и освобождава дескриптора. Следният пример отваря и затваря файл:

	int fd = open("test.txt", 0);
	if (fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC,
                  S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH    )) < 0)
				              printf("Open failed");
	else close(fd);

Функцията close връща 0 при успешно изпълнение и -1 при грешка. Също както fclose се осигурява правилното записване на файла с всички актуализирани данни.

3. creat: Отваря нов файл за запис. Ако файла вече съществува, то изтрива всичката информация в него. Има следния синтаксис:

	int fd = creat(char *name, int mode);

Аналогията с open е очевидна. Тази функция е на практика излязла от употреба, защото е еквивалентна на open(„name“, O_WRONLY, 0)

4. unlink: Абсолютно аналогична на remove функция. Като входен параметър приема името на файла като символен низ и връща -1 при грешка.

5. read: Функцията за четене на информация от файл:

	read(int fd, char *buffer, int num);

Fd е файловия дескриптор. Buffer e указател към символен низ, в който се записват данните. Num е броя байтове на блока, който ще бъде прочетен (трябва да е равен или по-малък от размерността на буфера). Функцията връща 0 при успех и -1 при грешка.

6. write: Функцията за запис на информация във файл:

	write(int fd, char *buffer, int num);

Входните данни са аналогични както при read. Резултатът отново е 0 при успех и -1 при грешка.

7. lseek: Променя текущата позиция във файла:

	fseek(int fd, long offset, int mode);

Fd е файловият дескриптор, offset показва броя байтове, а mode указва типа на адресното преместване (0 – от началото, 1 – от текущата позиция или 2 – от края на файла „назад“).

Следната програма е еквивалентна на програмата cp под UNIX (копира файлове):

	/*fileio.c
	* Tom Kelliher
	*
	* This program demonstrates how to do low-level file I/O in C.  This
	* program implements a simple version of Unix's cp command.  Two
	* filename are expected on the command line.  The first file is the
	* name of the file to be copied, the second is the file to be created.
	*/

	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>

	/* Prototypes. */
	void pdie(const char *);
	void die(const char *);

	#define BUFFER_SIZE 1024   /* Size of the read/write buffer. */

	int main(int argc, char* argv[])
	{
		int rfd;   /* Read file descriptor. */
		int wfd;   /* Write file descriptor. */
		char buffer[BUFFER_SIZE];   /* Read/Write buffer. */
		char *bp;   /* Pointer into write buffer. */
		int bufferChars;   /* Number of bytes remaining to be written. */
		int writtenChars;  /* Number of bytes written on last write. */

		if (argc != 3)
		{
			printf("Two filenames expected.\n");
			exit(1);
		}

		/* Open file to be copied. */
		if ((rfd = open(argv[1], O_RDONLY, 0)) < 0)
			pdie("Open failed");

		/* Open file to be created. */
		if ((wfd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC,
			S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0)
						pdie("Open failed");

		while (1)
		{
			/* Normal case --- some number of bytes read. */
			if ((bufferChars = read(rfd, buffer, BUFFER_SIZE)) > 0)
			{
				bp = buffer;   /* Pointer to next byte to write. */

				/*
				Since we can't guarantee that all the bytes will be written
				in a single write(), this code must be written such that
				several write()'s can possibly be called.
				*/
				while (bufferChars > 0)
				{
					if ((writtenChars = write(wfd, bp, bufferChars)) < 0)
					pdie("Write failed");

					bufferChars -= writtenChars;   /* Update. */
					bp += writtenChars;
				}
			}
			else if (bufferChars == 0)   /* EOF reached. */
				break;
			else   /* bufferChars < 0 --- read failure. */
				pdie("Read failed");
		}

		close(rfd);
		close(wfd);
		return 0;
	}

	// pdie --- Print error message, call perror, and die.
	void pdie(const char *mesg) {
		perror(mesg);
		exit(1);
	}

	// die --- Print error message and die.
	void die(const char *mesg) {
		fputs(mesg, stderr);
		fputc('\n', stderr);
		exit(1);
	}

Задача: Препишете този пример, така че да работи с компилатора на Visual Studio 6 (Console Application).