Mavzu: oydning afzalliklari va kamchiliklari Reja: oydning afzalliklari oydning kamchiliklari

using namespace std;


class Device {
public:
int serial_number = 12345678;


void turn_on() {
cout << "Device is on" << endl;
}
};


class Computer: private Device {
public:
void say_hello() {
turn_on();
cout << "Welcome to Windows 95!" << endl;
}
};


int main() {
Device Device_instance;
Computer Computer_instance;

cout << "\t Device" << endl;

cout << "Serial number is: "<< Device_instance.serial_number << endl;
Device_instance.turn_on();

// cout << "Serial number is: " << Computer_instance.serial_number << endl;

// Computer_instance.turn_on();
// will cause compile time error

cout << "\t Computer" << endl;

Computer_instance.say_hello();
return 0;
}
Sinf Computerendi turn_on()har qanday xususiy usuldan foydalanadi: uni turn_on()sinf ichidan chaqirish mumkin, lekin uni to'g'ridan-to'g'ri ichidan chaqirishga urinish mainkompilyatsiya vaqtida xatoga olib keladi. Asosiy sinf Deviceuchun usul turn_on()ochiq qoladi va uni chaqirish mumkin main.

Polimorfizm uchun tushuncha / talablar

Polimorfizmni tushunish uchun - bu atama hisoblash fanida ishlatiladi - oddiy testdan boshlash va uni aniqlash foydali bo'ladi. O'ylab ko'ring:
Type1 x;
Type2 y;

f(x);
f(y);

Bu erda f() bir necha operatsiyani bajarish va qadriyatlarini olish kerak x va y paydo bo'ldi, deb.
Polimorfizmni namoyish qilish uchun siz f() kamida ikki xil turdagi (masalan, int va double) qiymatlar bilan ishlashingiz , ma'lum bir turga mos keladigan kodni topishingiz va bajarishingiz kerak.

C ++ polimorfizm mexanizmlari

Dasturchi aniqlagan aniq polimorfizm

Siz f() shunday yozishingiz mumkinki, u bir nechta turlarni quyidagi usullardan birida boshqarishi mumkin:

• 
  Dastlabki ishlov berish:
  
• 
  #define f(X) ((X) += 2)
  

// (note: in real code, use a longer uppercase name for a macro!)

• 
  Haddan tashqari yuk:
  
• 
  void f(int& x) { x += 2; }
  
• 
  

void f(double& x) { x += 2; }

• 
  Shablonlar:
  
• 
  template
  

void f(T& x) { x += 2; }

• 
  Virtual yuborish:
  
• 
  struct Base { virtual Base& operator+=(int) = 0; };
  
• 
  
• 
  struct X : Base
  
• 
  {
  
• 
  X(int n) : n_(n) { }
  
• 
  X& operator+=(int n) { n_ += n; return *this; }
  
• 
  int n_;
  
• 
  };
  
• 
  
• 
  struct Y : Base
  
• 
  {
  
• 
  Y(double n) : n_(n) { }
  
• 
  Y& operator+=(int n) { n_ += n; return *this; }
  
• 
  double n_;
  
• 
  };
  
• 
  

void f(Base& x) { x += 2; } // run-time polymorphic dispatch