Värmdö Gymnasium Programmering B Datainstitutionen
C++ Lektion Klasser konstruktor och destruktor
Innehållet i denna lektion ligger på VG-nivå.
Teori
Den enkla klassen från lektionen ”Klasser grunder” såg ut på följande sätt:
class Elev {
public:
string namn;
int points;
};
Tidigare i vårt programmerande har vi ofta initierat variabler direkt vid deklarationen.
T ex
int x=0;
double y=2.2;
Detta är inte tillåtet för datamedlemmar i en klass, t ex ovan kan vi inte skriva
int points=0; då får vi ett felmeddelande vid kompileringen.
Konstruktor
Är en medlemsfunktion i en klass med samma namn som klassen. Den anropas när ett objekt ska skapas och de initierar ett objekt. Det kan finnas flera konstruktorer i en klass. Dessa skiljer sig åt genom olika antal argument och/eller olika argumentstyper. (”Överlagrade” konstruktorer.)
En speciell konstruktor är defaultkonstruktorn som inte har några argument. Om vi inte skriver någon konstruktor i vår klassdefinition så definieras automatiskt en defaultkonstruktor som inte gör något än att skapa ett objekt.
Ex på konstruktorer till vår klass:
Elev( ) {
namn=”ingen”;
points=0;
}
Elev( string n) {
namn=n;
points=0;
}
Elev( string n, int p ) {
namn=n;
points=p;
}
Vi kan omdefiniera defaultkonstruktorn till att göra något och vi kan skapa egna konstuktorer.
C++ Lektion konstruktor(dev).doc sida 1 (4)
Värmdö Gymnasium Programmering B Datainstitutionen
Anrop av konstruktor I deklarationen:
Elev e1, e2(”Kalle”,22); // Här anropas för e1 defaultkonstruktorn och för e2 en överlagrad //
konstruktor
Elev *p1, *p2; // OBS! Här skapas inget objekt, utan en pekare som får peka // på ett objekt av typen Elev
p1 = new Elev(); // skapa objektet genom anrop till defaultkonstruktorn p2 = new Elev(”Musse”); // skapa objektet genom anrop till en överlagrad konstruktor
När det gäller pekarna p1 och p2 så skapas objekten till dom dynamiskt, dvs när vi någonstans i programmet väljer att anropa operatorn new.
Destruktor
En parameterlös medlemsfunktion som anropas automatiskt när ett objekt upphör att finnas till. Den används för att ”städa bort” ett objekt så att minnesutrymmet kan ”lämnas tillbaka”. Destruktorn har samma namn som klassen men med ett ~(tilde)-tecken före.
OBS! Används inte i Dev c++, du kan anropa destruktorn med delete ändå.
Destruktor till vår klass Elev:
~Elev( ); // Destruktor
Destruktorn placeras lämpligen efter konstruktorerna.
Anrop av destruktor
Beroende på hur man skapat ett objekt, anropas destruktorn.
Se följande exempel
{
Elev e1; // Här anropas för e1 defaultkonstruktorn
Elev *p2; // OBS! Här skapas inget objekt, utan en pekare som får peka // på ett objekt av typen Elev
p2 = new Elev(”Musse”); // skapa objektet genom anrop till en överlagrad konstruktor …
…
delete p2; // destruktorn för p2 anropas, och friställer detta minnesutrymme } //Här anropas destruktorn för e1 automatiskt, för här lämnar vi det // ”block” som e1 är deklarerat i
Vårt program från ”Klasser grunder” nu utökat med konstruktor och destruktor
Jag använder här programmet från förra gången(Klasser grunder).
Där anropade vi defaultkonstruktorn (den automatiskt genererade) när vi skapade objekt, samt så hade vi en funktion skriv_in_data( ) som vi använde för att lägga in ”värden” i vårt objekt.
Vi skriver om programmet lite :
• lägg till en omdefinierad defaultkonstruktor
• en överlagrad konstruktor med två argument
• destruktor
• samt skriv om huvudprogrammet lite.
C++ Lektion konstruktor(dev).doc sida 2 (4)
Värmdö Gymnasium Programmering B Datainstitutionen
//*** classex6.cpp ***
#include <iostream>
#include <string>
using namespace std;
//--- //Klassdeklarationen
class Elev {
private: // här deklareras gömda (utanför objektet) datamedlemmar och medlemsfunktioner string namn; // datamedlemmar
int points;
public: // här deklareras synliga (utanför objektet) datamedlemmar och medlemsfunktioner Elev( ); //omdefinierad defaultkonstruktor
Elev( string n, int p); //överlagrad konstruktor ~Elev( ); //destruktor
void skriv_in_data(); // medlemsfunktioner void skriv_ut_data();
void increase_points(int x);
};
//--- /// HUVUDPROGRAMMET classex6.cpp
main() {
Elev *p1, *p2; // OBS! Här skapas inget objekt, utan en pekare som får peka // på ett objekt av typen Elev
p1 = new Elev(); //skapa objekten genom anrop till defaultkonstruktorn
p2 = new Elev("Kalle Anka", 34); // skapa objekten genom anrop till konstruktorn med 2 argument p1->skriv_ut_data(); //nu kommer inget skräp utan datamedlemmarna har ju fått värden p1->increase_points(10);
p1->skriv_ut_data();
p1->skriv_in_data();
p1->skriv_ut_data();
delete p1; //frigör (deallokera) minnesutrymme cout<<endl<<endl;
p2->skriv_ut_data();
delete p2;
}
//--- //***************************************************************
//definitioner av medlemsfunktioner i klassen
//skillnaden mot att definiera vanliga funktioner är att du måste // ange vilken klass de tillhör, här Elev::
Elev::Elev( )
{ namn=”ingen”;
points=0; }
Elev::Elev( string n, int p ) { namn=n;
points=p; } Elev::~Elev( ) { }
void Elev::skriv_ut_data()
{ cout<<" Elevnnamn: "<<namn<<" Poäng: "<<points<<endl; } void Elev::skriv_in_data()
{ cout<<" Elevnamn: "; cin>>namn;
cout<<" Poäng: "; cin>>points; cout<<endl; } void Elev:: increase_points(int x)
{ points+=x; }
//***************************************************************
C++ Lektion konstruktor(dev).doc sida 3 (4)
Värmdö Gymnasium Programmering B Datainstitutionen
C++ Lektion konstruktor(dev).doc sida 4 (4)
