CITB308 Структури от данни

1. Език за програмиране С++ и ООП

Проста С++ програма

#include <stdlib>
#include <iostream>
int main()
{ int x, y;
  std::cout << "Please enter two numbers: "; 
  std::cin >> x >> y;       // input stream 
  int sum = x + y;
  std::cout << "Their sum is " << sum << std::endl;
  return EXIT_SUCCESS;
}

Елементи

• заглавни файлове (header files)
• тяло на функцията (function body)
• стандартен изходен поток (standard output stream) std::cout
• стандартен входен поток (standard input stream) std::cin
• using namespace std;

enum Color { RED, GREEN, BLUE };  // default values are 0, 1, 2
enum Week { MONDAY = 1, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};  
                                  // values are 1, 2, 3, .., 7
enum Mood { HAPPY = 3, SAD = 1, ANXIOUS = 4, SLEEPY = 2 };
Color skyColor = BLUE;
Mood myMood = SLEEPY;
Week day = TUESDAY;

char ch = 'Q';  
char* p = &ch;   // p holds the address of ch 
cout << *p;      // outputs the character 'Q'    
ch = 'Z';        // ch now holds 'Z'  
cout << *p;      // outputs the character 'Z'  

double f[3];    // array of 3 doubles f[0], f[1], f[2]
double* p[10];  // array of 10 double pointers p[0]..p[9]
f[2] = 2.5;
p[4] = &f[2];   // p[4] points to f[2]
cout << *p[4];  // outputs 2.5
int a[] = { 10, 11, 12, 13 }; // initialization
int b[20] = { 0 }; // initialize all elements with value 0

	
	Passenger pass = { "John Smith", LOW_FAT, true, "293145" };
	pass.name = "Pocahontas";    // change name
	pass.mealPref = VEGETARIAN;  // change meal preference

char* buffer = new char[500];
//...
delete buffer; // ERROR: delete only the fist element buffer[0] 

char* buffer = new char[500];
//...
delete [] buffer; // delete all elements 

const double PI = 3.14159265;
const int CUT_OFF[] = {90, 80, 70, 60};
const int N_DAYS = 7;
const int N_HOURS = 24*N_DAYS;
int counter[N_HOURS];

typedef char* BufferPtr;   // type BufferPtr is a pointer to char
typedef double Coordinate; // type Coordinate is a double
//...
BufferPtr p;       // p is a pointer to a char
Coordinate x, y;   // x and y are of type double

Изрази (expressions)

Избиране на член (member selection) и индекс

• class_name означава име на клас или структура;
• member означава име на член (или поле) на този клас или структура;
• pointer означава указател към клас или структура;
• array означава масив или указател към първия елемент на масив;
• exp означава израз (rvalue).

• var означава променлива или нещо, на което може да се присвои стойност (lvalue).

int a[] = { 0, 1, 2, 3 };
int i = 2;           
int j = i++;         // j = 2 and then i = 3
int k = --i;         // i = 2 and then k = 2
cout << a[k++];      // a[2] (=2) is output; then k = 3

int i = 10; 
int j = 5;
int k = 1;
i -= 4;     // i = i - 4; result 6
j *= -2;    // j = j * (-2); result -10
k <<= 1;    // k = k << 1; result 2

int a = 10, b, c, d;  
// right associativity  
d = c = b = a;     // is equivalent to d = (c = (b = a)); 
// left associativity  
d - c + b - a;     // is equivalent to ((d - c) + b) - a;  
// precedence 
d > c && -b <= a   // is equivalent to (d > c) && ((-b) <= a)  

void print(int x)
{ cout << x; } 

	
	void print(const Passenger &pass)
	{ 
		cout << pass.name << " " << pass.mealPref;
  		if (pass.isFreqFlyer) cout << pass.freqFlyerNo;
	}

	
	ostream& operator<<(ostream &out, const Passenger &pass)
	{ 
		out << pass.name << " " << pass.mealPref;
  		if (pass.isFreqFlyer) out << pass.freqFlyerNo;
  		return out;
	}
	//...
	Passenger pass1 = // details omitted
	Passenger pass2 = // details omitted
	cout << pass1 << pass2 << endl;

Класове

	enum MealType { NO_PREF, REGULAR, LOW_FAT, VEGETARIAN };
	class Passenger {
  	private:
    		string name;         // "John Smith"
    		MealType mealPref;   // LOW_FAT 
    		bool isFreqFlyer;    // true
    		string freqFlyerNo;  // "293145"
  	public:
    		Passenger();
    		bool isFreqFlyer() const
    		{ return isFreqFlyer; }     
    		void makeFreqFlyer(const string &newFreqFlyerNo)
    		{ 
			isFreqFlyer = true;
      			freqFlyerNo = newFreqFlyerNo;
    		}
	};

class Matrix;              // Matrix definition comes later
class Vector {             // a 3-element vector
private:
  double coord[3];
public:
  // ...
  friend class Matrix;     // allow Matrix access to coord
};
class Matrix {             // a 3x3 array
private:
  double a[3][3];
public:
  // ...
  Vector multiplyBy(const Vector& v) {  // multiply (a * v)
    Vector w(0, 0, 0);
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        w.coord[i] += a[i][j] * v.coord[j]; // access private data
    return w;
  }
};

class Complex {
private:
    class Node {
    // ... 
    };
    //... 
};

vector<int> scores(100);  
vector<char> buffer(500); 
vector<Passenger> passList(20);
vector<int> newScores = scores;

Цели и принципи на ООП

Цели на обектно-ориентирания дизайн

• Резистентност (robustness): възможност за работа с входни данни, които не са изрично дефинирани при написване на софтуера
  
• Адаптивност (adaptability): софтуерът трябва да се развива с течение на времето в отговор на променящите се условия
• Многократното използване (reusability):  кодът трябва да позволява многократна употреба като компонент на различни системи в различни приложения

Принципи на обектно-ориентирания дизайн

• Абстрактност (abstraction): извличане на най-основните части на сложна система и описване на тези части на прост и точен език
• Капсулиране (encapsulation): различните компоненти на софтуерната система не трябва да показват вътрешните детайли на съответните им имплементации
• Модулност (modularity): отнася се за организиране на структура, в която различните компоненти на софтуерната система са разделени на отделни функционални единици

Наследяване и полиморфизъм

class Person {       // base class  
private:
   string name;      // name
   string ssn;       // social security number
public: 
   //...
   void print();     // print data
   string getName(); // retrieve name
}; 
class Student : public Person {     // derived class
private:
   string major;    // major subject
   int gradYear;    // graduate year
public:
   //...
   void print();                      // print data
   void changeMajor(string newMajor); // change major
 };

Person person(...);       // define a person 
Student student(...);     // define a student
cout << student.getName();// invokes Person::getName()
person.print();           // invokes Person::print();
student.print();          // invokes Student::print();
person.changeMajor("Math"); // ERROR!
student.changeMajor("Math"); // OK
void Person::print()    // definition of Person print
{ cout << name << " " << ssn; }
void Student::print()   // definition of Student print
{ Person::print();      // first print Person data
  cout << major << gradYear;
} 

class Base {
   private:
       int priv;
   protected:
       int prot;
   public:
       int publ;
};
class Derived: public Base { 
   void someMemberFunction() 
   { cout << priv;    // ERROR: private member
     cout << prot;    // OK
     cout << publ;    // OK
   }
};
class Unrelated {
  Base X;
  void anotherMemberFunction() 
  {  cout << X.priv;   // ERROR: private member
     cout << X.prot;   // ERROR: protected member
     cout << X.publ;   // OK
  }
};

Person::Person(const string &nm, const string &ss)  
: name(nm), ssn(ss) {}           // initializer list
Student::Student(const string &nm, const string &ss,
                 const string &maj, int year)
: Person(nm, ss),      // initialize Person data members
  major(maj),          // initialize member
  gradYear(year) {}    // initialize gradYear
Person::~Person()      // Person destructor
{ ... }
Student::~Student()    // Student destructor
{ ... }
Student* s = new Student(...);
//...
delete s;   // calls ~Student() then ~Person()

Шаблони (template)

• Минимум на две цели числа:
  

  int min(int a, int b)  
  { return (a < b ? a : b); } 
  

• Минимум на две десетични дроби:
  

  double min(double a, double b)  
  { return (a < b ? a : b); } 
  

• Обща функция за произволен тип T се нарича функция-шаблон (function template):
  

  template<typename T>      // parameter list
  T min(T a, T b)           // returns the minimum of a and b
  { return (a < b ? a : b); } 
  

• Функцията-шаблон се извиква за изчисляване на минимума на обекти от различни типове.
  
• Може да използва всеки тип, при условие, че операция по-малко (<) е дефинирана (предефинирана) за този тип.
  
• Компилаторът разглежда типовете на аргументите на функцията за да определи коя форма на функцията да приложи - да определи тип за параметъра на шаблона.
  

  cout << min(3, 4);      // invokes min<int>(3,4)
  cout << min(6.9, 3.5);  // invokes min<double>(6.9, 3.5)
  cout << min('t', 'g');  // invokes min<char>('t', 'g')
  

template <typename Object>
class BasicVector {
   Object* a;                  // array storing an element
   int capacity;               // length of array a
public:
   BasicVector(int cap = 10)   // constructor
   {  capacity = cap;
      a = new Object[capacity];// allocate array storage
   }
   Object& elemAtRank(int r)   // access element at index r
   {  return a[r];  }
// ...
};

BasicVector<int> iv(5);     // vector of 5 integers
BasicVector<double> dv(20); // vector of 20 doubles
BasicVector<string> sv;     // vector of 10 strings
//...
iv.elemAtRank(3) = 8;       // iv[3] = 8;
dv.elemAtRank(14) = 2.5;    // dv[14] = 2.5
sv.elemAtRank(7) = "hello"; // sv[7] = "hello"

Обработка на изключения

class MathException {  // generic math exception
private:
  string errMsg;       // error message
public:
  MathException(const string& err) { errMsg = err; }
};
class ZeroDivisionException : public MathException {
public:
  ZeroDivisionException(const string& err) 
: MathException(err) {}
};
class NegativeRootException : public MathException {
public:
  NegativeRootException(const string& err) 
: MathException(err) {}
};

try {
// ...
if (divisor == 0) throw ZeroDivisionException("Division by zero");
//...
}
catch (ZeroDivisionException& zde) 
{ // handle division by zero
}
catch (MathException& me) 
{ // handle any math exception other than division by zero
}

Спецификация на изключенията

void calculator() throw(ZeroDivisionException, NegativeRootException)
{
  //... 
}

void funct1();         // can throw any exception
void funct2() throw(); // can throw no exception

Общ клас за изключения

class RuntimeException {  // generic run-time exception
private:
  string errorMsg;
public:
  RuntimeException(const string& err) { errorMsg = err; }
  string getMessage() const { return errorMsg; }
};
inline std::ostream& operator<<(std::ostream& out, const RuntimeException& e)
  { return out << e.getMessage(); }