C++/Class/Interface

Материал из C\C++ эксперт
Перейти к: навигация, поиск

Demonstrate virtual functons: list interface

<source lang="cpp">

  1. include <iostream>
  2. include <cstdlib>
  3. include <cctype>

using namespace std; class list { public:

 list *head;             // pointer to start of list
 list *tail;             // pointer to end of list 
 list *next;             // pointer to next item
 int num;                // value to be stored
 list() { 
    head = tail = next = NULL; 
 }
 virtual void store(int i) = 0;
 virtual int retrieve() = 0;

}; class queue : public list { public:

 void store(int i);
 int retrieve();

}; void queue::store(int i) {

 list *item;
 item = new queue;
 if(!item) {
   cout << "Allocation error.\n";
   exit(1);
 }
 item->num = i;
 if(tail) 
    tail->next = item;
 tail = item;
 item->next = NULL;
 if(!head) 
    head = tail;

} int queue::retrieve() {

 int i;
 list *p;
 if(!head) {
   cout << "List empty.\n";
   return 0;
 }
 // remove from start of list
 i = head->num;
 p = head;
 head = head->next;
 delete p;
 return i;

} class stack : public list { public:

 void store(int i);
 int retrieve();

}; void stack::store(int i) {

 list *item;
 item = new stack;
 if(!item) {
   cout << "Allocation error.\n";
   exit(1);
 }
 item->num = i;
 if(head) 
    item->next = head;
 head = item;
 if(!tail) 
    tail = head;

} int stack::retrieve() {

 int i;
 list *p;
 if(!head) {
   cout << "List empty.\n";
   return 0;
 }
 // remove from start of list
 i = head->num;
 p = head;
 head = head->next;
 delete p;
 return i;

} int main() {

 list *p;
 // demonstrate queue
 queue q_ob;
 p = &q_ob; // point to queue
 p->store(1);
 p->store(2);
 p->store(3);
 cout << "Queue: ";
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << "\n";
 // demonstrate stack
 stack s_ob;
 p = &s_ob; // point to stack
 p->store(1);
 p->store(2);
 p->store(3);
 cout << "Stack: ";
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << "\n";
 return 0;

}


      </source>


"Interface" for subclass

<source lang="cpp">

  1. include <iostream>

using namespace std; class AreaClass { public:

 double height;
 double width;

}; class Rectangle : public AreaClass { public:

 Rectangle(double h, double w);
 double area();

}; class Isosceles : public AreaClass { public:

 Isosceles(double h, double w);
 double area();

}; Rectangle::Rectangle(double h, double w) {

 height = h;
 width = w;

} Isosceles::Isosceles(double h, double w) {

 height = h;
 width = w;

} double Rectangle::area() {

 return width * height;

}

double Isosceles::area() {

 return 0.5 * width * height;

} int main() {

 Rectangle rectangleObject(10.0, 5.0);
 Isosceles isoscelesObject(4.0, 6.0);
 cout << "Rectangle: " << rectangleObject.area() << endl;
 cout << "Triangle: " << isoscelesObject.area() << endl;
 return 0;

}


      </source>


Use virtual function to define interface.

<source lang="cpp">

  1. include <iostream>

using namespace std; 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()
 { 
   cout << "You must override this function\n";
   return 0.0;
 }

}; class rectangle : public area { public:

 double getarea() 
 {
   double d1, d2;
   getdim(d1, d2);
   return d1 * d2;
 }

}; class triangle : public area { public:

 double getarea()
 {
   double d1, d2;
 
   getdim(d1, d2);
   return 0.5 * d1 * d2;
 }

}; int main() {

 area *p;
 rectangle r;
 triangle t;
 r.setarea(3.3, 4.5);
 t.setarea(4.0, 5.0);
 p = &r;
 cout << "Rectangle has area: " << p->getarea() << "\n";
 p = &t;
 cout << "Triangle has area: " << p->getarea() << "\n";
 return 0;

}

      </source>


Virtual functions: interface class

<source lang="cpp">

  1. include <iostream>
  2. include <cstdlib>

using namespace std; class list { public:

 list *head;  // pointer to next item in list
 list *tail;
 list *next;
 int num;     // value to be stored
 list() { 
    head = tail = next = NULL; 
 }
 virtual void store(int i) = 0;
 virtual int retrieve() = 0;

}; class queue : public list { public:

 void store(int i);
 int retrieve();

}; void queue::store(int i) {

 list *item;
 item = new queue;
 if(!item) {
   cout << "Allocation error.\n";
   exit(1);
 }
 item->num = i;
 // put on end of list
 if(tail) 
    tail->next = item;
 tail = item;
 item->next = NULL;
 if(!head) 
    head = tail;

} int queue::retrieve() {

 int i;
 list *p;
 if(!head) {
   cout << "List empty.\n";
   return 0;
 }
 i = head->num;
 p = head;
 head = head->next;
 delete p;
 return i;

} class stack : public list { public:

 void store(int i);
 int retrieve();

}; void stack::store(int i) {

 list *item;
 item = new stack;
 if(!item) {
   cout << "Allocation error.\n";
   exit(1);
 }
 item->num = i;
 // put on front of list for stack-like operation
 if(head) 
    item->next = head;
 head = item;
 if(!tail) 
    tail = head;

} int stack::retrieve() {

 int i;
 list *p;
 if(!head) {
   cout << "List empty.\n";
   return 0;
 }
 // remove from start of list
 i = head->num;
 p = head;
 head = head->next;
 delete p;
 return i;

} class sorted : public list { public:

 void store(int i);
 int retrieve();

}; void sorted::store(int i) {

 list *item;
 list *p, *p2;
 item = new sorted;
 if(!item) {
   cout << "Allocation error.\n";
   exit(1);
 }
 item->num = i;
 // find where to put next item
 p = head;
 p2 = NULL;
 while(p) { // goes in middle
   if(p->num > i) {
     item->next = p;
     if(p2) p2->next = item;  // not 1st element
     if(p==head) head = item; // new 1st element
     break;
   }
   p2 = p;
   p = p->next;
 }
 if(!p) { // goes on end
   if(tail) tail->next = item;
   tail = item;
   item->next = NULL;
 }
 if(!head) // is first element
   head = item;

} int sorted::retrieve() {

 int i;
 list *p;
 if(!head) {
   cout << "List empty.\n";
   return 0;
 }
 // remove from start of list
 i = head->num;
 p = head;
 head = head->next;
 delete p;
 return i;

} int main() {

 list *p;
 queue q_ob;
 p = &q_ob; // point to queue
 p->store(1);
 p->store(2);
 p->store(3);
 cout << "Queue: ";
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << "\n";
 stack s_ob;
 p = &s_ob; // point to stack
 p->store(1);
 p->store(2);
 p->store(3);
 cout << "Stack: ";
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << "\n";
 sorted sorted_ob;
 p = &sorted_ob;
 p->store(4);
 p->store(1);
 p->store(3);
 p->store(9);
 p->store(5);
 cout << "Sorted: ";
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << p->retrieve();
 cout << "\n";
 return 0;

}

      </source>