Tags:    c++

Afsnit 22
I afsnit 15 lovede jeg at fortælle hvad * og & skulle gøre godt for, så det må jeg hellere gøre.

For at computeren kan holde styr på dens hukommelse giver den hver celle i hukommelsen en adresse, en adresse kan siges at være et tal der er et index til en celle.

Når vi laver en variabel gemmer computeren den i sin hukommelse på en bestemt adresse. Vi kan få fat i den adresse:

   int i;
   int* p = &i;

&i betyder adressen på i, p er en pointer, der indeholder adressen på i. Det kan vi bruge til at ændre i:

   *p = 123;

Dette vil ændre i, da p peger på i. *p betyder indholdet af p, dvs. det p peger på.
En pointer ligner på flere måder en reference, idet de begge er associeret til en anden variabel.

Men en pointer er mere fleksibel end en reference, idet:
1: Den kan pege på ingenting:

   int* p = 0;

Hvis man vil finde ud af om en pointer peger på ingenting:

   if(p == 0)
     std::cout << "p peger ikke på noget" << std::endl;

2: Den kan sættes til at pege på noget andet:

   int i, j;
   int *p = &i;
   if(i == 7)
      p = &j;

Hvis man vil skrive hvad p peger på skal man skrive * foran:

   std::cout << *p << std::endl;

Hvis man bare skriver:

   std::cout << p << std::endl;

Får man adressen, og den er meget sjældent brugbar.

Hvis en pointer peger på et objekt af en class skal man bruge -> i stedet for .

   Entry entry;
   Entry* p = &Entry;
   p->Navn = "Ole Hansen";

Man kan også sætte pointere til at pege på "frie" objekter oprettet til formålet:

   int *p = new int;
   *p = 123;

Her opretter vi en int med new i "free store" også kaldet heap'en.

new er en operator der operetter et objekt af en bestemt type og returnerer en pointer til objektet.

En af ulemperne ved denne metode er at man selv skal nedlægge objekter der er oprette med new, det gøres med delete:

   int *p = new int;
   *p = 123;
   delete p;

For hver new skal du også have en delete.

Hvis du glemmer delete kan vil dit program, hvis det får lov til at køre længe nok, kunne "spise" alt hukommelsen på din computer.
Men systemet skal nok sørge for at hukommelsen bliver frigivet når det bliver lukket.

Man kalder brugen af new og delete for "dynamisk memory alokering", fordelen ved at bruge dynamisk memory er at man selv kan bestemme hvornår objekter oprettes og nedlægges.
Et eksempel:

Entry Get()
{
  Entry e;
  return e;
}

I Get opretter vi et Entry og returnerer det.
Men i virkeligheden er det ikke e der bliver returneret, men et kopi af e.
Hvis e fylder meget i hukommelsen kan det tage lang tid at kopiere et Entry, så man kunne bruge:

Entry* Get()
{
  Entry* e = new Entry;
  return e;
}

Her er det en pointer til et Entry der returneres, så der sker ingen kopiering.
Ulempen er igen at den der kalder Get skal huske at delete det Get returnerer, f.eks:

   Entry* p = Get()
   delete p;
   Man ser også at man bruger pointere i kald til funktioner:
   void Pop(int* p)
   {
     *p = 123;
   }

Her fungerer det på samme måde som med referencer. Man skal så kalde funktionen med:

   int k;
   Pop(&k);

Det er den metode der blev brugt med memset og asctime tidligere.
Men hvis du kan, så brug referencer.

Opgave
Lav en af udgaverne af regnemaskinen om så den kun bruger pointere og ikke "rigtige" objekter, dvs.
alle variable skal laves med new. Husk at rydde op efter dig.

Afsnit 23
I nogle tilfælde har man brug for et fast antal af en type.
Det kunne være ti int. Så kan man bruge en std::vector, eller man kan lave et array:

   int Liste[10];

Dette vil oprette en liste af 10 int, disse kan man tilgå med:

   int n;
   for(n = 0; n < 10; n++)
      Liste[n] = n;

Som med en std::vector hedden den første 0 og den sidste hedder N-1, hvis der er N i arrayet, N er 10 i vores eksempel, så den sidste hedder Liste[9].

I nogle tilfælde ved man ikke på forhånd hvor mange man skal bruge, så kan man oprette den med new []

   int x = 12;
   int* Set = new int [x];

Her er der plads til 12 i Set, man bruger den på samme måde som Liste ovenfor, dvs:

   Set[0] = 123;

Som sædvanligt når vi har brugt new til at oprette noget, skal vi bruge delete til at rydde op.
Da vi brugte new[] skal vi også bruge delete[];

  delete [] Set;

Man siger at et array der er oprettet med new [] er "Dynamisk Array"

En anden anvendelse af pointere er til at gennemløbe et array, lidt på samme måde som en iterator:

   int* Set = new int [10];
   int* p;
   for(p = Set; p != &Set[10]; p++)
     *p = 123;

I for delen sætter vi p til at pege på Set, dvs. det første element i Set.
&Set[10] er adressen på elementet lige efter det sidste i Set.
*p betyder indholdet af p, vi kunne også skrive p[0] = 123;
Dette virker med rigtige arrays så vel som med dynamiske arrays.
Det ses også at pointere og arrays virker på lidt samme måde.

At pointere virker lidt som en iterator gør at man kan bruge standard funktioner med arrays på samme måde som med std::vector. F.eks. kan man sortere et array:

   int P[10];
   std::sort(P, &P[10]);

En af ulemperne ved at bruge dynamiske arrays og pointere er at man ikke kan spørge dem om hvor store de er, dvs hvor mange elementer der er i deres array, for de ved det ikke.

Opgaver
Lav et program der spørger brugeren om hvor mange tal han vil indtaste, lav så et dynamisk array til disse tal og bed brugeren om at indtaste dem. Sorter derpå array'et og udskriv summen af alle tallene, det største og det mindste tal.

Afsnit 24
Hvis man har lavet en class som kan et eller andet, men i nogle tilfælde ønsker man at få den til at kunne noget mere, kan man naturligvis kopiere den og tilføje det man ønsker.

En anden, og lidt mere elegant måde er at bruge arv.
Hvis vi tager Entry som eksempel, men ønsker at tilføje email adresse til den kunne man lave:

class Entry
{
public:
  std::string Navn;
  unsigned int Nummer;
  void Udskriv(std::ostream& os)
  {
     os << Navn << std::endl << Nummer << std::endl;
  }
};
class EntryEx : public Entry
{
public:
   std::string EmailAdresse;
};

Så vil EntryEx kunne det samme som Entry, men den har også EmailAdresse.
Vi siger at EntryEx arver fra Entry, og at Entry er en base class for EntryEx.
Men hvis vil vil udskrive et EntryEx objekt vha. Udskriv funktionen, vil den kun udskrive Navn og Nummer, for Udskriv er en funktion i Entry, og den kender ikke EmailAdresse.
Løsningen er at lave en Udskriv funktion i EntryEx:

class EntryEx : public Entry
{
public:
   std::string EmailAdresse;
   void Udskriv(std::ostream& os)
   {
      Entry::Udskriv(os);
      os << EmailAdresse << std::endl;
   }
};

Da Udskriv funktionen findes i både Entry og EntryEx vil det være EntryEx udgaven af Udskriv der bliver kaldt. Man siger at Udskriv i den class der arver fra en base class overloader funktionen.

I EntryEx::Udskriv kalder vi først Entry::Udskriv, dvs. Udskriv i base class'en, denne vil udskrive Navn og Nummer, vi skriver derpå EmailAdresse.

Opgave
Gør koden herover færdig så den kan bruges til at gemme, hente og vise en hel telefonbog med email adresser.



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