Tags:    c++

Afsnit 25
I dette afsnit skal vi se lidt på exceptions.
Exceptions bruges normalt når noget i programmet går galt, dvs. at noget ikke kan lade sig gøre eller ikke gik som det skulle.

Brug af exceptions er delt i tre dele, en try, en trow og en catch. Dvs. man forsøger noget (try), går det ikke godt er der nogen der kaster (throw) en exception, og en der fanger (catch).
Et simpelt eksempel kunne være en divider funktion der kaster en exception hvis man forsøger at dividere med 0:

#include <iostream>
int Divider(int a, int b)
{
   if(b == 0)
   {
      throw "Kan ikke dividere med 0" ;
   }
   return a/b;
}
int main()
{
   try
   {
      std::cout << Divider(123, 0);
   }
   catch (const char* e)
   {
      std::cout << "Ups, exception: " << e << std::endl;
   }
}

I main laver vi en try-blok, i denne kalder vi funktionen Divider.
I Divider checker vi om b er 0, hvis den er, kaster vi en exception i form at en streng, eller rettere en const char *
I main vil vil så fange denne exception, hvis den bliver kastet og udskriver teksten og exceptionen.

Man kan kaste exceptions af alle typer, også int. Men den der fanger skal vide hvad det er der forsøges fanget, eller man kan bruge ... i sin catch, for at fange alt:

  catch ()
   {
      std::cout << "Ups, exception" << std::endl;
   }

Ulempen ved denne metode er at man ikke kan vide hvad det er der blev kastet.

Der er en del standard funktioner der kaster en exception hvis noget går galt.
Hvis man f.eks. bruger en std::vector, men ikke helt har styr på hvor mange elementer der er i den, kan man bruge at() til at hente med, den vil kaste en std::out_of_range exception hvis man forsøger at tilgå et invalid index. F.eks:

#include <iostream>
#include <exception>
#include <vector>
#include <stdexcept>
int main()
{
   std::vector<int > MyVector;
   MyVector.push_back(123);
   MyVector.push_back(321);
   MyVector.push_back(111);
   try
   {
      int i = 0;
      while(1)
         std::cout << MyVector.at(i++) << std::endl;

   }
   catch (std::out_of_range e)
   {
      std::cout << "Ups, exception: " << e.what() << std::endl;
   }
}

Dette program vil udskrive alle elementer i MyVector, og exception teksten når den kommer til enden.
Med Borland compileren vil programmet skrive:
Ups, exception: index out of range in function: vector:: at(size_t)
index: 3 is greater than max_index: 3
Hvis man bruger at funktionen uden at have en try/catch vil programmet sandsynligvis udskrive en fejlbesked og lukke.

Opgave
Lav telefonbogs programmet om så det bruger exceptions, hvis der indtastes et telefon nummer der ikke er gyldigt.
Lav den GetTal funktion du lavede i afsnit 13 om så den kaster en exception hvis det tal brugeren skrev ikke er et gyldigt tal.

Afsnit 26
Du har set at når vi laver class'er skriver jeg public: i toppen og jeg bruger også public ved arv, her skal vi kikke lidt på hvad det betyder.

Hvis du laver en class der skal repræsentere en firkant kunne den se sådan ud:

class Firkant
{
public:
   Firkant(int h, int w) :
      Height(h),
      Width(w)
   {}
   int Height;
   int Width;
};

Men hvis du så vil lave en funktion der kan fortælle dig arealet af firkanten, kan du enten lave en areal variabel og udregne denne i constructor'en eller du kan lave en funktion der hedder Areal som beregner den hver gang.

Men hvis du ikke helt ved hvilken metode der er bedst, og gerne vil kunne ændre det senere uden at skrive en mængde kode om, hvad gør du så?
Du kunne starte med at lave en variabel og en funktion:

class Firkant
{
public:
   Firkant(int h, int w) :
      Height(h),
      Width(w),
      Areal(h*,w
   {}
   int GetAreal() { return Areal; }
   int Height;
   int Width;
   int Areal;
};

Men nu risikerer du at folk der bruger din class bruger Areal direkte, og så skal du skrive koden om, hvis du senere bestemmer dig for at fjerne den.
Løsningen er at gøre den private:

class Firkant
{
public:
   Firkant(int h, int w) :
      Height(h),
      Width(w),
      Areal(h*,w
   {}
   int GetAreal() { return Areal; }
   int Height;
   int Width;
private:
   int Areal;
};

Ved at gøre Areal privat, kan andre ikke bruge Areal, kun class'en selv.
Det betyder at man ikke kan:

   Firkant firkant(123, 321);
   std::cout << firkant.Areal << std::endl;

Men man bliver nødt til at bruge GetAreal til at hente Areal med:

   Firkant firkant(123, 321);
   std::cout << firkant.GetAreal() << std::endl;

Nå vi brugte public ved arv:

class EntryEx : public Entry
{

Betyder det at brugeren af EntryEx også må få adgang til public variable og funktioner i Entry, hvis vi skrev private var det kun EntryEx der måtte tilgå variable og funktioner i Entry.

Den findes en udgave mere som hedder protected.
Den betyder at det kun er class'en selv og class'er der arver fra clas'en der må få adgang.
Dette kan synes et anelse besværligt og overflødigt.
Men hvis du tænker på en class som std::ofstream må den have en mængde interne variable og funktioner til at holde styr på filen, dens størrelse, placering på harddisken osv.
Hvis du kunne få adgang til disse kunne du komme til at lave en mængde ting som kunne have fatale konsekvenser for din harddisk.

Opgave
Lav det nyeste regnemaskine eksempel om så alle class'ens variable er private og lav en nogle public funktioner til at tilgå disse med.

Afsnit 27
Alle artikler skal have en ende, denne artikel ender her.
Dette betyder ikke at du nu har lært alt om C++, for det har du ikke.
Der er skrevet adskillige bøger på mange hundrede sider om C++
Men jeg håber at du har forstået lidt af hvordan det fungerer, og har fået lyst til at fortsætte.
Kast dig ud i flere forsøg og find på flere opgaver selv.
Læs nogle flere tutorials, og gå biblioteket og se om de har nogle bøger om emnet.


Du skal lige have en sidste information.
Ofte er det praktisk at kunne skrive kommentarer i koden, som ikke skal være en del af programmet, men som kan hjælpe den der læser koden.
Det kunne være en beskrivelse af hvad koden, funktionen eller programmet gør, eller ting som er vigtig at huske for at forstå hvordan programmet virker.
Der er to måder at lave kommentarer på.
Den ene starter med // og gælder resten af linjen, den anden består af alt mellem /* og */, og kan dække flere linjer.
Nogle eksempler:

/* Dette program skrive 123 til test.txt
** Det er ikke specielt brugbart, men en text
*/
// Starter med include filer, alle standard
#include <fstream>
#include <iostream>
int main()
{  /* Her starter programmet */
   std::ofstream Fil("test.txt");
   if(!Fil)
   {  // Hvis ikke filen kunne åbnes
      std::cout << "Kunne ikke åbne test.txt" << std::endl;
      return 1;
   }
   Fil << 123;
   // Fil bliver lukket af systemet når vi returnerer fra main
}

Du vil sikkert opdage at programmet skriver kommentarer i en anden farve, for at markere at det netop er kommentarer.


Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X