1. No category

Värmdö Gymnasium
Datainstitutionen
Programmering B
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
Datainstitutionen
Programmering B
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;
Elev *p2;
p2 = new Elev(”Musse”);
…
…
delete p2;
}
// Här anropas för e1 defaultkonstruktorn
// OBS! Här skapas inget objekt, utan en pekare som får peka
// på ett objekt av typen Elev
// skapa objektet genom anrop till en överlagrad konstruktor
// 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
Datainstitutionen
Programmering B
//*** 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
Datainstitutionen
Programmering B
Läs
Läs 229-35, 243-45
Öva
Övning konst1
Skriv in exemplet i denna lektion och häng med på vad programmen gör och vad som förändras i
respektive program.
Övning konst2
Skapa en klass Rektangel. Klassen skall ha dataattributen(datamedlemmarna) langd och bredd (typen
float). Klassen skall ha operationerna area(), omkrets() och change(float sida1, float sida2). Se till att skriva
lämplig konstruktor samt destruktor. Skriv ett lite program där du testar din klass. Du ska då använda
pekare och skapa objekten dynamiskt samt se till att avallokera minnet innan programslut.
Övning konst 3
Skriv en klass som implementerar valfritt antal tärningar. Tärningen kan anta värdena 1 till 6. Möjliga
operationer på tärningen skall vara
- Läsa värdet på tärningen(arna).
- Kasta tärningen(arna) ett angivet antal gånger.
- Skriva ut statistik över tärningens(arnas) historiska värden(hur många gånger den varit etta, tvåa etc)
Skriv ett litet program där du testar din klass. Se till att använda dynamisk minneshantering.
C++ Lektion konstruktor(dev).doc
sida 4 (4)