Обектно-ориентирано програмиране

Цели и принципи

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

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

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

Наследяване в C++

Наследяването позволява проектирането на общи класове, които могат да бъдат специализирани за други (по-частни) класове, със повторно използване на кода на общия клас от специализираните класове.
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 Protection

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()
    [person.cpp]

Статично свързване
Person* pp[100];  
pp[0] = new Person(...); 
pp[1] = new Student(...);

cout << pp[1]->getName();   // OK
pp[0]->print();             // calls Person::print()
pp[1]->print();             // calls Person::print()
pp[1]->changeMajor(...);    // ERROR!

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

class Person {       // base class  
   virtual void print();         // print data
   //...
}; 
class Student : public Person {  // derived class
   virtual void print();         // print data
   //...
 };
Person* pp[100];  
pp[0] = new Person(...); 
pp[1] = new Student(...);

pp[0]->print();             // calls Person::print()
pp[1]->print();             // calls Student::print()
pp[1]->changeMajor(...);    // OK
    [person.cpp]

Виртуални деструктори

Ако в даден клас се дефинират виртуални функции, тогава трябва да се дефинира и виртуален деструктор, дори да е празен.
delete [] pp;

Полиморфизъм

Способността на променлива да приеме различни типове!

Шаблони (template)

Функции-шаблони

Класове-шаблони

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(10); // 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) {}
};

Изхвърляне (throwing) и прихващане (catching) на изключения

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
}
След изпълнение на catch блока, изпълнението на програмата продължава с първия оператор след последния catch блок.

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

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(); }