2.6 - Kivetelkezeles

Ma mar minden programozasi nyelvben jelen van. Tulajdonkeppen egyfele hibakezelez altalanositasanak is tekintheto.
Olyan hibakat oldhatunk meg vele, amit helyben nem lehet megszuntetni.
Egyik nagy elonye , hogy a hagyomanyos kodot es a hibakezelo kodot szetvalassza.
A C++ nylevben a kiveltelesemenyt jelenzni lehet egy primitiv tipusu valtozo segitsegevel.

class Error{...};
void f(){
   if(feltetel){
     throw Error()
   }
}

// kivetel lekezelese

try{
   f();
}catch(Error){
 // kiveltelkezelo blokk
}

Pelda: stack.h

#ifndef stack_h
#define stack_h
using namespace std;
 class Staxk{
  public:
   class Stack_Overflow{};
   class Stack_Underflow{};
   virtual void push(char)=0;
   virtual char pop()=0;

 };

 class Array_Stack : public Stack{
  private:
   char *s;
   int top;
   int max_size;
  public: 
   Array_Stack(int max_size);
   Array_Stack(const Array_Stack&);
   ~Array_Stack();
   void push(char c) throw (Stack_Overflow);
   char pop() throw (Stack_Underflow); 
 };
$endif

A fenti Stack osztaly egy absztrakt osztaly amely csak tipusdefiniciokat es fugvenydeklaraciokat tartalmaz, tehat tamogatja az absztrak adatipusokat, mivel nem ad meg semmi informaciot az adatok abrazolasara, illetve a muveletek implementaciojara vonatkozoan.
Az ilyen absztrakot osztalyokat feluleteknek is nevezzuk, mert feluletet biztositnak mas osztalyok szamara.
Erre epitjuk fel az Array_Stack konkrek osztalyt, amely az absztrakt osztaly konkret leszarmazotja lesz.
Az osztalyunknak ket konstruktora van az elso parameter nelkuli, a masodik a masolo konstruktor.
A C++ nincs automatikus szemetgyujtes ezert szuksegunk van a destruktorra, amely az objektum dinamikus helyfoglalasat semmisiti meg.

Pelad: stack.cpp

#include "stack.h"
#include 
using namespace std;

Array_Stack :: Array_Stack(int _max_size){
 max_size = _max_size;
 s = new char[_max_size];
 top = 0;
}

// masolo konstruktor
Array_Stack :: Array_Stack(Array_Stack & _as){
 this->max_size = _as.max_size;
 this->s = new char[max_size];
 this->top = _as.top;
}

// destruktor
Array_Stack :: ~Array_Stack(){
 //cout<<"\nDestructor: "<< this->max_size<<"\n";
 delete [] s;
}

void Array_Stack :: push(char c) throw (Stack_Overflow){
 if(top >= max_size) throw Stack_Overflow();
 s [top++] = c;
}

char Array_Stack :: pop() throw (Stack_Underflow){
 if(top == 0) throw Stack_Underflow();
 return s[--top];
}

A fenti kod a Stack_Array osztaly metodusait implementalja.
Pelda: test_stack.cpp

#include 
#include "stack.h"
#include 
using namespace std;

int main(){
 Array_Stack as(100);
 try{
  printf("\n%c", as.pop());
 }catch(Stack :: Stack_Underflow x){
  //cout<<"Stack_Underflow"<<"\n";
 }
 return 0;
}