Tags:    c++

Afsnit 16
En lidt anden måde at lave telefonbogs opslaget fra sidste afsnit var at bruge en class:

class Entry
{
public:
  std::string Navn;
  unsigned int Nummer;
};

Når den skrives på denne måde vil den virke på samme måde som den med struct.
I et senere afsnit skal jeg nok fortælle hvad public: gør.
Vi kunne så lave en funktion der læser et Entry:

void ReadEntry(Entry& entry)
{
   std::getline(std::cin, entry.Navn);
   std::cin >> entry.Nummer;
}

Og man kunne lave en tilsvarende funktion til at udskrive dem.

Men, der findes en smartere måde, man kan lave en funktion i class'en, så den kommer til at se sådan ud:

class Entry
{
public:
  void ReadEntry();
  std::string Navn;
  unsigned int Nummer;
};

Her er ReadEntry blevet til en medlems funktion, det er kun en en prototype, selve funktionen kan vi lave uden for class'en, den kunne se sådan ud:

void Entry::ReadEntry()
{
   std::getline(std::cin, Navn);
   std::cin >> Nummer;
}

Det bemærkes at man skriver Entry:: foran funktions navnet, det er for at markere at det er Entry's ReadEntry, da andre class'er kan have funktioner der hedder det samme.
Det bemærkes også at vi bare skriver Navn, det er fordi member funktioner godt ved at det er dens egen Navn der menes, så vi behøver ikke at fortælle den det. Det samme gælder for Nummer.

Når vi så vil kalde denne ReadEntry funktion gør man sådan her:

   Entry entry;
   entry.ReadEntry();

I kaldet til entry.ReadEntry vil den så læse entry.Navn og entry.Nummer.
Hvis man vil sammenligne to Entry's er man nød til at lave en funktion til det. Man kunne gøre det med en medlems funktion, så class'en kom til at se sådan ud:

class Entry
{
public:
  void ReadEntry();
  bool Compare(const Entry& other);
  std::string Navn;
  unsigned int Nummer;
};

Compare funktionen kunne se sådan ud:

bool Entry::Compare(const Entry& other)
{
   if(Navn == other.Navn && Nummer == other.Nummer)
      return false;
   return true;
}

Og man kunne bruge den sådan her:

   Entry e1, e2;
   if(e1.Compare(e2))
      std::cout << "..." << std::endl;

I Compare ser vi at den ene udgave af Entry kan tilgåes ved blot at skrive Navn, det er e1 fra main, den anden udgave af Entry,
e2 tilgår vi ved at skrive other.Navn.
Senere skal vi se hvordan man kan lave det så man kan sammenlige med ==

Opgave
1: Lave en Udskriv funktion til Entry ovenfor.

2: Endnu en gang regnemaskinen. Lav en class som udgør et regnestykke.
class'en skal have tre funktioner, én til at bede brugeren om det der skal beregnes, én til at beregne og én til at udskrive.

Afsnit 17
Der er to funktioner i class'er som er specielle.
Den første er den funktion (eller rette de funktioner) der hedder det samme som class'en.
Det specielle ved denne funktion er at den bliver kaldt når man laver en variabel eller objekt af class'en.
Et meget simpelt eksempel:

#include <iostream>
class X
{
public:
   X()
   {
      std::cout << "Hej der" << std::endl;
   }
};
int main()
{
   X x;
}

Dette program vil, når det køres skrive "Hej der", fordi vi opretter en X, og når vi gør det køres X :: X.

Bemærk at vi i dette tilfælde skrev selve koden til funktionen inden i class'en, det er meget almindeligt for små funktioner som denne.

X :: X er en constructor, som er et engelsk ord, der kan oversættes til konstruktør, altså en der opretter objektet.
Bemærk også at constructorer ikke returnerer noget, man kan og skal altså ikke skrive int eller void foran.

Ofte bruger man constructoren til at sætte default værdier for objektet, vi kunne f.eks. lave:

#include <iostream>
class X
{
public:
   X(int y)
   {
      x = y;
   }
   int x;
};
int main()
{
   X x(123);
}

Man kan også skrive X :: X sådan:

   X(int y) : x(y)
   {

   }

Det gør det samme som den X :: X som vi så før. Tricket kan kun bruges med constructorer.

Den anden funktion er er speciel er funktionen (og der er kun én) der hedder det samme som class'en men med ~ foran.

Du laver en ~ ved at trykke AltGr+<knap til højre for Å> og mellemrum.

Et simpelt eksempel:

#include <iostream>
class X
{
public:
   X()
   {
      std::cout << "Goddag" << std::endl;
   }
   ~X()
   {
      std::cout << "Farvel" << std::endl;
   }
};
int main()
{
   X x;
}

Dette program vil skrive:
Goddag
Farvel
Det skriver Goddag når programmet når til linjen X x; Og det skriver Farvel når det kommer til den sidste }.

destructor bruges normalt til at rydde op efter sig selv.

Opgaver
1: Lav regnemaskinen fra sidste afsnit om så det er constructoren der beder brugeren om de tal der skal beregnes, og destructoren skal skrive resultatet.

2: Lav regnemaskinen om så de to tal overføres i constructoren.

3: Vha. difftime osv. som vi så på i forrige afsnit skal du lave en class der når den bliver oprettet husker hvornår den blev oprettet.
Lav så to udgave af denne class, med en std::cin.get() imellem, derved kan du beregne hvor mange sekunder brugeren var om at trykke enter.
Lav denne beregning i en member funktion.

Afsnit 18
Vi lavede tidligere denne class:

class Entry
{
public:
  void ReadEntry();
  bool Compare(const Entry& other);
  std::string Navn;
  unsigned int Nummer;
};

Men at bruge compare til at sammenligne med var lidt kluntet, det kunne være smartere at man kunne skrive:

   Entry e1, e2;
   if(e1 == e2)
      std::cout << "..." << std::endl;

For at kunne gøre det er vi nødt til at lave en operator.

En operator virker næsten på samme måde som en funktion, den ser lidt anderledes ud og man kalder den på en anden måde, men ellers er det det samme.

En == operator kunne se sådan ud:

bool operator == (const Entry& lhs, const Entry& rhs)
{
   if(lhs.Navn == rhs.Navn && lhs.Nummer == rhs.Nummer)
      return false;
   return true;
}

Bemærk at denne operator ikke er medlem af class'en, det er en global funktion.

lhs bliver ofte brugt for navn på den ene parameter, lhs betyder "Left Hand Side", dvs. den del der står på venstre side, på samme måde betyder rhs "Right Hand Side" altså det der står til højre.

Vi kunne også lave operatoren som en del af class'en, så kunne det komme til at se sådan ud:

class Entry
{
public:
  std::string Navn;
  unsigned int Nummer;
  bool operator == (const Entry& rhs)
  {
     if(Navn == rhs.Navn && Nummer == rhs.Nummer)
        return false;
     return true;
   }
};

Bemærk at vi her kun får et argument, det andet argument er automatisk lhs.
Om man foretrækker den ene eller den anden form er mest et spørgsmål om smag og behag.

Man kan lave operatorer for alle de almindelige operationer, f.eks, + - * / = += ++ osv, men man kan ikke opfinde sine egne, f.eks. kan man ikke lave en <> eller en +- operator.

Opgaver
1: lav en class der indeholder et tal, og funktioner til at læse og skrive dette tal.
Lav så +,-,* og / operator for to objekter af denne class. Derved kan du lave endnu en version af regnemaskinen.



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