Konstruktor och destruktor

Initialisering av medlemmar

I våra exempel ovan har konstruktorn egentligen intr gjort något mera än kopierat givna parametrar till datamedelemmar. Kopierandet kan göras lättare om man vill. Istället för att i konstruktorns kropp explicit göra ett antal tilldelningar kan de göras direkt vid konstruktordefinitionen. Vi kan skriva om konstruktorerna från ovan till:

Coordinate (float X, float Y) : m_X(X), m_Y(Y) { }
Coordinate () : m_X(0), m_Y(0) { }

Man placerar alltså direkt efter parentesen ett : (kolon) och räknar därefter upp de medlemmar som skall initialiseras och inom parentse de värden de skall få. Den första ger värden från parametrar, medan den andra ger hårdkodade värden. Har man flera initialiseringar placerar man ett kommatecken emellan. Efter initialiseringarna kommer det som normalt skulle komma. I vårt fall behöver vi inte längre någon kodkropp för konsturktorn, eftersom allt arbete redan gjorts.

Initialiseringarna görs före den kod som finns i konstruktorn exekveras, så själva kodkroppen kan använda sig av de initialiserade medlemmarna.

Multipla konstruktorer

För att göra klasser lättare och bekvämare atta använda kan man låta dem ha multipla konstruktorer. Meningen är att de skall ta olika parametrar (om alls) så att de kan skapas på olika sätt. Vi kan modifiera vår klass så att den tillåter båda konstruktorerna vi hittills sett:

class Coordinate {
public:
  // konstruktorer
  Coordinate (float X, float Y) { m_X = X; m_Y = Y; };
  Coordinate () { m_X = 0; m_Y = 0; };

  // accessera medlemmar
  float x () const { return m_X; };
  float y () const { return m_Y; };
  void setX (float X) { m_X = X; };
  void setY (float Y) { m_Y = Y; };

private:
  // medlemmar
  float m_X;
  float m_Y;
};

Nu kan man enkelt skapa objekt av klassen Coordinate. Man kan ha hur många konstruktorer som helst, så länge som ett visst set av parametarar endast kan användas av en konstruktor. De måste alltså vara unika. Om det finns två konstruktorer som tar likadana parametrar vet kompilatorn inte vilken som skall väljas och man får ett felmeddelande vid kompileringsskedet.

Om man inte definierar någon konstruktor överhuvudtaget i en klass kommer kompilatorn att skapa en tom konstruktor som inte gör någonting. Detta endast för att en konstruktor måste finnas. En tom konstruktor för Coordinate skulle se ut på detta sätt:

Coordinate () { };

Det är dock bättre att själv definiera denna konstruktor så att man kan vara säker på att medlemmar initialiseras till giltiga initialvärden.

Copy-konstruktor

Det finns en annan typ av konstruktor som används förutom de som visats ovan. En speciell typ av konstruktor används vid vissa specialfall då objekt kopieras. Denna konstruktor kallas för (svengelskt sagt) en copy-konstruktor. Även detta är en metod som kompilatorn automatiskt genererar om den inte definieras av programmeraren. Denna konstruktor används bl.a. i följande situationer:

• då ett nytt objekt skapas som en kopia av ett annat redan existerande.

• då ett objekt skickas som parameter till en funktion eller metod. Gäller dock ej om det är frågan om en pekare eller referensparameter.

Allmänt ser en copy-konstruktor ut på detta sätt:

class namn {
  namn (const namn & variabel);
};

Den tar alltså som parameter ett objekt av samma typ som den själv. Objektet är definierat som en konstant parameter (const) som inte kan modifieras samt som en referensparameter för att göra anropet effektivare. Vad denna konstruktor skall göra är att den skall kopiera alla värden i variabel till "sig själv", alltså generera en kopia av denna. Copy-konstruktorn för vår klass kunde se ut på följande sätt:

Coordinate (const Coordinate & Original) { m_X = Original.x (); m_Y = Original.y (); };

Här kopierar vi helt enkelt värdena som Original innehåller. Notera att eftersom Original är definierad som ett const objekt kan man inte anropa metoder för detta objekt som inte är definierade som const. Detta är orsaken till att vi tidigare definierade x() och y() som const-metoder. Några exempel på situationer då en copy-konstruktor används:

Coordinate C1;
// copy-konstruktorer
Coordinate C2 ( C1 );
Coordinate C3 = C1;
Coordinate C3 = Coordinate ( C1 );

Medan anropet:

Coordinate C1 (10, 10);

inte anropar någon copy-konstruktor. Det är alltså frågan om en ganska viktig konsturktor som det i många fall kan vara värt att definiera manuellt och inte lita på den definition som kompilatorn automatiskt ger åt oss. Kompilatorn kommer att kopiera data medlem för medlem från originalet till kopian, vilket ju nog var exakt samma sak som vi gjorde. Vi kunde alltså använt den automatiska definitionen i vårt fall, men i vissa fall kan man få allvarliga fel om man gör detta. Vi kommer att stöta på sådana klasser senare.

Copy-konstruktorn används även då man skickar objekt som värdeparametrar. Ett exempel:

#include <iostream>

class Coordinate {
public:
  // konstruktorer
  Coordinate (float X, float Y) { m_X = X; m_Y = Y; };
  Coordinate (const Coordinate & Original) { m_X = Original.x (); m_Y = Original.y (); };
  Coordinate () { m_X = 0; m_Y = 0; };

  // accessera medlemmar
  float x () const { return m_X; };
  float y () const { return m_Y; };
  void setX (float X) { m_X = X; };
  void setY (float Y) { m_Y = Y; };

private:
  // medlemmar
  float m_X;
  float m_Y;
};

// skriv ut en koordinat
void printCoordinate (Coordinate C) {
  cout << "X = " << C.x () << ", Y= " << C.y () << endl;
}

int main () {
  Coordinate C1 ( 1, 2);
  Coordinate C2 ( C1 );
  Coordinate C3 = C1;

  // skriv ut de olika koordinaterna
  printCoordinate ( C1 );
  printCoordinate ( C2 );
  printCoordinate ( C3 );
}

Vi har här en funktion printCoordinate() som tar som parameter ett objekt av typen Coordinate. Eftersom det skickas som värdeparameter kommer copy-konsturktorn att användas då den lokala variabeln C i funktionen printCoordinate() skapas. Copy-konstruktorn används alltså endast då objekt skickas som värdeparametrar. Om vi istället skirver om printCoordinate() till följande kommer vi inte att använda en copy-konstruktor för att skapa C:

void printCoordinate (Coordinate & C) {
  cout << "X = " << C.x () << ", Y= " << C.y () << endl;
}

Vi har nu undvikit en onödig konstruktion av variabeln C och även gjort vårt program en aning effektivare. Men i och med att vi skickar parametrarna till printCoordinate() som referensparametrar och vi inte har något behov av att ändra på dessa kan vi använda definitionen:

void printCoordinate (const Coordinate & C) {
  cout << "X = " << C.x () << ", Y= " << C.y () << endl;
}

Vi lägger alltså till definitionen const för parameter Coordinate & C för att tydligt markera att denna funktion inte modifierar referensparametern (även om den skulle kunna göra det). Det är god sed att använda const för parametrar, funktioner och metoder där det är lämpligt för att göra gränssnitt lättare att använda smat tydligare markera ut var objekt kan tänkas bli modifierade.

Destruktor

Vi har hittills sett olika metoder för hur objekt kan skapas och hur konstruktorer används. I C++ finns det även en metod som körs då ett objekt förstörs, nämligen en destruktor. Denna exekveras för varje objekt vid en tidpunkt dår objektet redan är "för sent att rädda". Destruktorer skall användas för att göra diverse uppstädning efter ett objekt. Det kan vara frågan om att frigöra allokerat minne, stänga öppnade filer eller frigöra andra resurser. I många fall måste destruktorer användas för att undvika minnesläckor. En destruktor definieras allmänt på detta sätt:

class namn {
  ...
  ~namn ();
  ...
};

Man har alltså en metod med samma namn som klassen själv, men som har ett ~ framför namnet. En destruktor tar aldrig parametrar och returnerar aldrig något. Då en destruktor är exekverad finns objektet inte längre. Man behöver aldrig manuellt kalla på en destruktor, det görs totalt automatiskt vid rätt ögonblick. En generell regel är att ett objekt förstörs då det går "utanför scope", d.v.s. då det inte längre är aktuellt. I följande exempel förstörs alla de lokala objekten av typ Coordinate då funktionen de är definierade i avslutas:

void foo (Coordinate C) {
  Coordinate Tmp1, Tmp2;
  ...
}

int main () {
  Coordinate Point;
  ...
  foo ( Point );
  ...
}

De lokala variablerna Tmp1, Tmp2 och Point förstörs då funktionerna avslutas, likaså parametern C som skapas i foo(). Tmp1 och Tmp2 skapas på nytt varje gång foo() anropas. En destruktor för vår Coordinate-klass har egentligen ingenting egentligen att göra, men vi kan skapa en tom destruktor:

class Coordinate {
public:
  // konstruktorer
  Coordinate (float X, float Y) { m_X = X; m_Y = Y; };
  Coordinate (const Coordinate & Original) { m_X = Original.x (); m_Y = Original.y (); };
  Coordinate () { m_X = 0; m_Y = 0; };

  // destruktor
  ~Coordinate () { };
  ...
};

Destruktorn gör ingenting. Vi kan istället se på en enkel vektor vars längd man kan dynamiskt specificera då den skapas. Vektorn har en konstruktor, en destruktor, två metoder för att läsa och skriva ett värde samt en för att returnera storleken.

#include <iostream>

class Vector {
public:
  // konstruktor och destruktor
  Vector (unsigned int Size) { m_Data = new int [Size]; m_Size = Size; }
  ~Vector () { }
  
  // accessmetoder
  void set (unsigned int Index, int Value) { m_Data[Index] = Value; }
  int get (unsigned int Index) const { return m_Data[Index]; }

  // storleken på vektorn
  unsigned int size () const { return m_Size; }

private:
  // pekare till datablock
  int * m_Data;

  // storlek på vektor
  unsigned int m_Size;
};

  
int main () {

  // skapa en dynamisk vektor med 100 element
  Vector V ( 100 );

  // fyll den med data
  for ( int Index = 0; Index < 100; Index++ ) {
    V.set ( Index, Index * 10 );
  }
}

I konstruktorn allokeras nu ett minnesblock som rymmer Size element. Den observante märker att programmet är mycket dåligt skrivet, vi gör inga kontroller överhuvudtaget att givna Index är inom rimliga gränser, men det duger för vårt exempel. Tittar man litet närmare på programmet ser man förstås att det allokerar minne med new i konstruktorn, men aldrig frigör minnet! Vi har även en tom destruktor som inte gör någonting överhuvudtaget. Hur skall vi kunna undvika att läcka minne om vi skapar och förstör upprepade instanser av Vector? Jo, vi kan se till att frigöra minnet i destruktorn. Det är precis dylika uppgifter som skall skötas i en destruktor. Vår nya destruktor blir således:

~Vector () { delete [] m_Data; }

Här borde även göras kontroller på att m_Data verkligen är allokerad, men det lämnas som en övning för läsaren. Nu läcker vår klass inte längre minne.

Mera om copy-konstruktor

Vi har nu fått ett annat problem med vår Vector-klass. Vad händer om vi kopierar ett objekt till ett annat, t.ex. på följande sätt:

Vector Source ( 10 );
Vector Destination ( Source );

Kör vi detta program kommer vi att få en segmentation fault, som indikerar att vi gör något fel ved vår minneshantering. Vad går fel och varför? den automatiska copy-konstruktor som kompilatorn skapar oss kopierar alla medlemmar skilt för sig, d.v.s. m_Size och m_Data kopieras. Dock kopieras endast pekarens värde, inte minnesområdet som pekaren pekar på. Vi får således två pekare som pekar på samma minnesområde, vilket inte i sig är ett problem. Problemet framkommer då objekten förstörs. Eftersom båda pekar på samma område frigör det ena objektet minnet i destruktorn precis som det är menat, men då det andra objektet försöker frigöra samma minne är det reda frigjort och ett fel uppstår. Man kan komma undan detta genom att skapa en copy-konstruktor som ser till att kopiera även det minne som pekaren pekar på, så att det nya objektet pekar på ett eget minnesområde. Vi definieraren copy-konstruktor den enligt följande:

class Vector {
  ...
  Vector (const Vector & Original) {
    // allokera minne
    m_Size = Original.size ();
    m_Data = new int [ m_Size ];

    // kopiera minnet
    memcpy ( m_Data, Original.m_Data, sizeof(int) * m_Size );
  }

Funktionen memcpy() som användes för att utföra kopieringen är en funktion som är inkluderad i och med #include <iostream>. Den kopierar data från ett ställe till ett annat, och ersätter i vårt fall en for-slinga. Nu har klassen inte längre samma problem med minne som frigörs två gånger. Inte heller läcker det minne. Nu återstår endast felhantering för att göra den komplett.

Den observate märkte säkert att den nya copy-konstruktorn kunde accessera den privata datamedlemmen m_Data i Original. Hur kan detta gå för sig, den borde väl vara skyddad? Jo, den är skyddad, men endast för objekt av andra klasser, inte för objekt av samma klass! Detta kan vara bra att veta då man t.ex. skriver copy-konstruktorer eller andra metoder som tar en (eller flera) parameter av samma klass.