{"id":14,"date":"2008-10-16T10:22:09","date_gmt":"2008-10-16T08:22:09","guid":{"rendered":"http:\/\/www.kristiansborg.dk\/bibliotek\/?page_id=14"},"modified":"2008-10-16T10:22:09","modified_gmt":"2008-10-16T08:22:09","slug":"objektorienteret-programmering-i-c","status":"publish","type":"page","link":"https:\/\/www.kristiansborg.dk\/bibliotek\/b%c3%b8ger\/objektorienteret-programmering-i-c\/","title":{"rendered":"Objektorienteret programmering i C++"},"content":{"rendered":"


\n<\/strong><\/p>\n

Indhold<\/strong><\/p>\n

Indledning…………………………………………………………………………………………………….. 2<\/p>\n

Hvordan en klasse erkl\u00e6res……………………………………………………………………………… 2<\/p>\n

Angivelse af funktioner……………………………………………………………………………………. 3<\/p>\n

Constructor…………………………………………………………………………………………………… 3<\/p>\n

Erkl\u00e6ring af et objekt……………………………………………………………………………………… 4<\/p>\n

Requests (kald af medlemsfunktioner)………………………………………………………………… 5<\/p>\n

Konstante objekter………………………………………………………………………………………… 5<\/p>\n

Multiple constructors………………………………………………………………………………………. 6<\/p>\n

Alternativ assignment-metode i constructors………………………………………………………… 7<\/p>\n

Operator overloading……………………………………………………………………………………… 7<\/p>\n

Friend-funktioner…………………………………………………………………………………………. 11<\/p>\n

Dynamisk instantiering af objekter……………………………………………………………………. 12<\/p>\n

Copy constructor…………………………………………………………………………………………. 13<\/p>\n

Destructor…………………………………………………………………………………………………… 14<\/p>\n

Kald af funktioner gennem pointere………………………………………………………………….. 15<\/p>\n

Templates…………………………………………………………………………………………………… 16<\/p>\n

Nedarvning…………………………………………………………………………………………………. 18<\/p>\n

Polymorfi……………………………………………………………………………………………………. 21<\/p>\n

Multipel nedarvning………………………………………………………………………………………. 22<\/p>\n

Virtuelle nedarvning………………………………………………………………………………………. 23<\/p>\n

Abstrakte klasser…………………………………………………………………………………………. 25<\/p>\n

Statiske funktioner………………………………………………………………………………………… 26<\/p>\n

\nIndledning<\/a><\/h2>\n

Objekt-orienteret programmering er ikke bare en ny m\u00e5de at programmere p\u00e5. Det er en helt ny m\u00e5de at t\u00e6nke p\u00e5. I stedet for at se sit program som opbygget af algoritmer, der kan opdeles i funktioner, skal man t\u00e6nke p\u00e5 sit program som best\u00e5ende af objekter, der alle har specielle egenskaber. At l\u00e6re at udnytte de objekt-orienterede muligheder i sit programmeringssprog er ikke det store problem, men \u00e6ndringen af tankegangen kommer f\u00f8rst med tiden.<\/p>\n

\u00a0<\/p>\n

Grundstenen i objekt-orienteret programmering er – ikke overraskende – objekter. Objekter er imidlertid ikke bare objekter; de er objekter af en bestemt type. Objekters type kaldes deres klasse.<\/p>\n

\u00a0<\/p>\n

Det er muligt at lave flere objekter af samme klasse. Disse vil s\u00e5 – til at starte med – v\u00e6re identiske. Med tiden vil de naturligvis udvikle sig forskelligt alt efter hvilke funktioner, der bliver kaldt p\u00e5 dem.<\/p>\n

\u00a0<\/p>\n

Hvordan en klasse erkl\u00e6res<\/a><\/h2>\n\n\n\n
class <\/strong>Cirkel {<\/p>\n

\u00a0 private:<\/strong> \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int r = 0); \/\/Constructor<\/p>\n

\u00a0\u00a0\u00a0 void<\/strong> SetRadius (int);<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> GetAreal();<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> GetOmkreds();<\/p>\n

};<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 1<\/p>\n

\u00a0<\/p>\n

Eksempel 1 viser, hvordan en klasse erkl\u00e6res. Som det ses starter man med det reserverede ord class<\/em>. Derefter gives navnet p\u00e5 klassen eller typen, hvorefter en kr\u00f8llet parentes f\u00f8lger.<\/p>\n

\u00a0<\/p>\n

Klasser kan indeholde to forskellige ting: Variable og funktioner. De er opdelt i to forskellige grupper. De private variable og funktioner og de offentlige variable og funktioner. Det er hovedsageligt variable, der er private, mens de fleste funktioner er offentlige, men det modsatte kan ogs\u00e5 v\u00e6re tilf\u00e6ldet.<\/p>\n

\u00a0<\/p>\n

De private variable indledes med ordet private:<\/em>. Herefter f\u00f8lger variabel-definitionerne, ganske som i en almindelig funktion. Det specielle ved private variable er, at de kun kan tilg\u00e5s fra de funktioner, der er medlemmer af klassen. Konceptet med private variable kaldes indkapsling. Det vil sige, at de data, der kun vedr\u00f8rer selve objektet, er afsk\u00e6rmet fra resten af programmet.<\/p>\n

\u00a0<\/p>\n

De offentlige variable og funktioner indledes med ordet public:<\/em>. Disse kan tilg\u00e5s fra hele programmet – hvordan vender vi tilbage til.<\/p>\n

\u00a0<\/p>\n

Funktioner i en klasse kaldes medlemsfunktioner eller member functions. Et funktionskald kaldes en request.<\/p>\n

\u00a0<\/p>\n

Bem\u00e6rk at der skal<\/em> v\u00e6re et semikolon efter den afsluttende kr\u00f8llede parentes.<\/p>\n

\u00a0<\/p>\n

Da den private variabel radius ikke kan tilg\u00e5s af andre funktioner end medlemsfunktionerne er det n\u00f8dvendigt, at have en funktion, der s\u00e6tter en ny radius. Den kaldes i dette eksempel SetRadius. Dette kan m\u00e5ske virke meget uhensigtsm\u00e6ssigt, men det er faktisk en af fordelene ved objekter. Da SetRadius er den eneste funktion, der \u00e6ndrer variablen radius ved vi, at hvis radius pludseligt antager en forkert v\u00e6rdi, s\u00e5 m\u00e5 \u00e6ndringen v\u00e6re sket gennem funktionen SetRadius – det letter fejlretningen.<\/p>\n

\u00a0<\/p>\n

I praksis vil der ofte v\u00e6re andre fordele ved indkapslingen. Man kan for eksempel forestille sig, et konto-objekt, der har en funktion, der tilskriver rente. Hvis reglerne for rentetilskrivning skal \u00e6ndres, er det kun n\u00f8dvendigt at \u00e6ndre denne ene funktion, og da kontoens saldo er privat, er det ikke muligt, at en travl programm\u00f8r falder for fristelsen til lige at l\u00e6gge et par procent til saldoen, og s\u00e5 er den rentetilskrivning ordnet.<\/p>\n

Angivelse af funktioner<\/a><\/h2>\n

I erkl\u00e6ringen af klassen skrives funktioner bare med deres prototype. N\u00e5r selve funktionen skal angives, skal man imidlertid f\u00f8rst angive, hvilken klasse funktionen h\u00f8rer til. Funktionshovedet vil have f\u00f8lgende format:<\/p>\n

\u00a0<\/p>\n

<returtype> <klasse>::<funktionsnavn> (<parametre…>)<\/p>\n

\u00a0<\/p>\n

Eksempler p\u00e5 dette kan ses i eksempel 2. Herefter f\u00f8lger funktionskroppen som i en almindelig funktion. Dobbelt-kolonet, der adskiller klasse og funktionsnavn, kaldes scope.<\/p>\n

Constructor<\/a><\/h2>\n

Som det ses i eksempel 1, st\u00e5r der “Constructor” i kommentaren efter medlemsfunktionen Cirkel(int r=0). En constructor er en funktion, der kaldes automatisk, n\u00e5r der oprettes et objekt af klassen. Det normale arbejde for constructor-funktionen er at initialisere variable, og det er ogs\u00e5 det, der er form\u00e5let med denne constructor. Parameteren r angiver radius – p\u00e5 den m\u00e5de kan cirkel-objektet i programmet initialiseres til at have en startv\u00e6rdi.<\/p>\n

\u00a0<\/p>\n

Hvis der ikke gives en startv\u00e6rdi, bliver r sat til default-v\u00e6rdien 0. Herefter udf\u00f8res den kode, der st\u00e5r i funktionen Cirkel::Cirkel.<\/p>\n

\u00a0<\/p>\n

Constructors skal altid have det samme navn som klassen.<\/p>\n

\u00a0<\/p>\n

Af eksempel 1 ses det ogs\u00e5, at der ikke angives nogen returtype for constructor’en. Det betyder ikke som normalt, at returtypen er int. Constructors kan ikke returnere noget, og derfor angiver man ingen returtype.<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
#include <iostream.h><\/p>\n

#include <math.h><\/p>\n

\u00a0<\/p>\n

#define pi M_PI<\/p>\n

\u00a0<\/p>\n

class <\/strong>Cirkel {<\/p>\n

\u00a0 private:<\/strong> \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int r = 0); \/\/Constructor<\/p>\n

\u00a0\u00a0\u00a0 void<\/strong> SetRadius (int);<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> GetAreal();<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetOmkreds();<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

Cirkel::Cirkel(int<\/strong> r)<\/p>\n

{<\/p>\n

\u00a0 radius = r;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

void <\/strong>Cirkel::SetRadius (int<\/strong> r)<\/p>\n

{<\/p>\n

\u00a0 radius = r;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

int <\/strong>Cirkel::GetAreal()<\/p>\n

{<\/p>\n

\u00a0 return<\/strong> pi*radius*radius;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

int <\/strong>Cirkel::GetOmkreds()<\/p>\n

{<\/p>\n

\u00a0 return<\/strong> 2*pi*radius;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

void <\/strong>main()<\/p>\n

{<\/p>\n

\u00a0 Cirkel rund(5);<\/p>\n

\u00a0<\/p>\n

\u00a0 cout << “Omkredsen er ” << rund.GetOmkreds() << endl;<\/p>\n

}<\/p>\n

\u00a0<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 2.<\/p>\n

Erkl\u00e6ring af et objekt<\/a><\/h2>\n

Et objekt erkl\u00e6res p\u00e5 samme m\u00e5de som alle andre variable. Det vil sige p\u00e5 formen<\/p>\n

<datatype> <navn><\/p>\n

\u00a0<\/p>\n

Hvis man i stedet for at definere en int ved navn x, vil definere et objekt af typen Cirkel med navnet rund, skriver man alts\u00e5 ikke int <\/strong>x; men Cirkel rund;<\/p>\n

Ligesom man kunne initialisere simple variable (fx int<\/strong> x=5;)\u00a0 kan man ogs\u00e5 initialisere komplekse variable som objekter, hvis klassen tillader det. Det g\u00f8r den i dette tilf\u00e6lde (constructeren tager parameteren r). Derfor kan man, hvis man vil initialisere rund med radius 5, skrive Cirkel rund(5);<\/p>\n

\u00a0<\/p>\n

Requests (kald af medlemsfunktioner)<\/a><\/h2>\n

N\u00e5r man har brug for at benytte en af de offentlige funktioner, der findes i objektet sender man et request. Det g\u00f8res p\u00e5 samme m\u00e5de som man foretager et funktionskald. Blot skal man huske at angive, hvilket objekt man kalder funktionen i. Bem\u00e6rk, at det skal v\u00e6re objektet (alts\u00e5 variablen), man angiver, og ikke klassen. Objektnavnet og funktionsnavnet adskilles med punktum (der udtales “dot”), s\u00e5 requesten har f\u00f8lgende format:<\/p>\n

\u00a0<\/p>\n

<objekt>.<funktion>(<parametre>);<\/p>\n

\u00a0<\/p>\n

Et eksempel p\u00e5 en request ses i main-delen af eksempel 2.<\/p>\n

Konstante objekter<\/a><\/h2>\n

Som alle andre variable kan objekter ogs\u00e5 g\u00f8res konstante. Det g\u00f8res ved at skrive const <\/strong><\/em>foran deres definition. Fx const <\/strong>Cirkel rund(5);<\/p>\n

\u00a0<\/p>\n

Det vil i det tilf\u00e6lde ikke v\u00e6re muligt at \u00e6ndre nogen variable i objektet. Deraf kan man slutte at funktionen SetRadius heller ikke m\u00e5 kaldes, da den jo netop \u00e6ndrer variablen radius (rent teknisk kan det godt lade sig g\u00f8re, men det giver advarslen “Non-const function Cirkel::SetRadius(int) called for const object”). Derimod skulle man tro, at det ville v\u00e6re helt i orden at kalde funktionerne GetOmkreds og GetAreal, da de jo kun l\u00e6ser radius, hvilket jo er helt legalt at g\u00f8re med konstante variable. S\u00e5dan er det imidlertid ikke. N\u00e5r et objekt er konstant er det hele objektet, der er konstant. Det vil sige, at et kald til GetOmkreds vil give en advarsel i stil med den som et kald til SetRadius gav.<\/p>\n

\u00a0<\/p>\n

Disse problemer kan imidlertid omg\u00e5s, s\u00e5 man kun f\u00e5r advarslen, n\u00e5r man virkeligt har brug for den – n\u00e5r man virkeligt foretager en \u00e6ndring af et konstant objekt. Det g\u00f8r man ved at tilf\u00f8je ordet const efter alle de medlemsfunktioner, der ikke<\/em> modificerer variable. I vores eksempel vil klasse-erkl\u00e6ringen komme til at se ud som i eksempel 3. Derudover skal man huske ogs\u00e5 at tilf\u00f8je const til funktionshovedet, n\u00e5r selve funktionen skrives.<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>Cirkel {<\/p>\n

\u00a0 private:<\/strong> \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int<\/strong> r = 0); \/\/Constructor<\/p>\n

\u00a0\u00a0\u00a0 void<\/strong> SetRadius (int<\/strong>);<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> GetAreal() const<\/strong>;<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetOmkreds() const<\/strong>;<\/p>\n

};<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 3.<\/p>\n

\u00a0<\/p>\n

Multiple constructors<\/a><\/h2>\n

\u00a0<\/p>\n

Som vi tidligere har set, kan constructoren have default-v\u00e6rdier. Men betragt eksemplet med nedenst\u00e5ende constructor i class’en Point:<\/p>\n

\u00a0<\/p>\n

Point::Point (int x = 0; int y = 0);<\/p>\n

\u00a0<\/p>\n

Hvis objekter af klassen instantieres med to parametre er der ingen problemer – det er der heller ikke, hvis der slet ikke angives parametre; s\u00e5 s\u00e6ttes de begge til nul. Men hvad, hvis der kun angives et parameter? S\u00e5 antager C++, at det er det f\u00f8rste parameter, der overf\u00f8res, og de resterende s\u00e6ttes til default-v\u00e6rdier. I dette tilf\u00e6lde vil det alts\u00e5 betyde, at y s\u00e6ttes til nul. Det er meget godt, hvis det var meningen, at y skulle s\u00e6ttes til default-v\u00e6rdien, men hvad, hvis vi hellere ville have haft, at det var x, der blev sat til default-v\u00e6rdien? Den eneste m\u00e5de det kan g\u00f8res p\u00e5 med default-parametre er at bytte om p\u00e5 parametrene, og det virker meget ulogisk.<\/p>\n

\u00a0<\/p>\n

For at afhj\u00e6lpe dette problem, kan man definere flere constructors[1]<\/a>. I vores cirkel-eksempel vil vi alts\u00e5 kunne definere to constructors i stedet for den ene, vi har med default-v\u00e6rdier. S\u00e5 kommer erkl\u00e6ringen af klassen og implementationen af de to constructors til at se s\u00e5ledes ud:<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>Cirkel<\/p>\n

{<\/p>\n

\u00a0 private<\/strong>: \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(); \/\/Constructor uden parametre<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int <\/strong>r); \/\/Constructor med radius som parameter<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>SetRadius (int<\/strong>);<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetAreal();<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetOmkreds();<\/p>\n

\u00a0 };<\/p>\n

\u00a0<\/p>\n

\u00a0 Cirkel::Cirkel ()<\/p>\n

\u00a0 {<\/p>\n

\u00a0\u00a0\u00a0 radius = 0;<\/p>\n

\u00a0 }<\/p>\n

\u00a0<\/p>\n

\u00a0 Cirkel::Cirkel(int <\/strong>r)<\/p>\n

\u00a0 {<\/p>\n

\u00a0\u00a0\u00a0 radius = r;<\/p>\n

\u00a0 }<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 4.<\/p>\n

\u00a0<\/p>\n

Alternativ assignment-metode i constructors<\/a><\/h2>\n

\u00a0<\/p>\n

Tidligere har vi i constructorens kode skrevet de assignments, der skulle foretages. Det er ogs\u00e5 muligt at skrive dem p\u00e5 en anden m\u00e5de. Fx kan vores constructor med parametren r <\/em>omskrives til f\u00f8lgende:<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
\u00a0<\/p>\n

\u00a0 Cirkel::Cirkel(int <\/strong>r) : radius ( r )<\/p>\n

\u00a0 {<\/p>\n

\u00a0 }<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 5.<\/p>\n

\u00a0<\/p>\n

Denne form for assignments kan kun anvendes i constructoren.<\/p>\n

\u00a0<\/p>\n

Nu da st\u00f8rrelsen p\u00e5 constructoren er begr\u00e6nset s\u00e5 den faktisk kan skrives p\u00e5 en linie, bliver det interessant at se, at man kan have koden til constructoren st\u00e5ende i klassens erkl\u00e6ring. Det kaldes inline-kode.<\/p>\n

\u00a0<\/p>\n\n\n\n
class<\/strong> Cirkel<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong> \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel() : radius(0) {}; \/\/Constructor uden parametre<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int <\/strong>r) : radius(r) {}; \/\/Constructor med radius som parameter<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>SetRadius (int<\/strong>);<\/p>\n

\u00a0\u00a0\u00a0 int<\/strong> GetAreal();<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetOmkreds();<\/p>\n

};<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 6.<\/p>\n

\u00a0<\/p>\n

Det er smag og behag, hvilken metode man foretr\u00e6kker, men her vil vi for l\u00e6sevenlighedens skyld forts\u00e6tte med den “gamle” metode.<\/p>\n

\u00a0<\/p>\n

Operator overloading<\/a><\/h2>\n

Operator overloading vil sige, at man tillader brug af operatorer p\u00e5 sine objekter. Normalt vil nedenst\u00e5ende jo ikke v\u00e6re tilladt:<\/p>\n

\u00a0<\/p>\n

Cirkel a,b;<\/p>\n

\u00a0<\/p>\n

if (a == b)<\/p>\n

cout << “Ens”;<\/p>\n

\u00a0<\/p>\n

Det er imidlertid muligt at fort\u00e6lle C++-compileren, at den, n\u00e5r den m\u00f8der udtrykket “==” skal udf\u00f8re en bestemt funktion. For at g\u00f8re det, skal man bruge nogle forud-bestemte funktionsnavne. Det generelle syntaks herfor er:<\/p>\n

\u00a0<\/p>\n

<returtype> operator<\/strong> <operator> (<parametre>);<\/p>\n

\u00a0<\/p>\n

Antallet af parametre bruges til at kende forskel p\u00e5 un\u00e6re og bin\u00e6re operatorer. Fx er den eneste forskel p\u00e5<\/p>\n

\u00a0<\/p>\n

int operator<\/strong>– ();<\/p>\n

og<\/p>\n

int operator<\/strong>– (int<\/strong>);<\/p>\n

\u00a0<\/p>\n

at\u00a0 den \u00f8verste er un\u00e6rt minus (fx -5), mens den nederste er bin\u00e6rt minus (fx 3-5).<\/p>\n

\u00a0<\/p>\n

Det er ikke alle klasser, der kan g\u00f8re fornuftigt brug af alle operatorer, og s\u00e5 kan man bare n\u00f8jes med at inkludere de fornuftige – s\u00e5 kommer compileren med en fejlmeddelelse, hvis man pr\u00f8ver at bruge nogen af de andre.<\/p>\n

\u00a0<\/p>\n

I vores eksempel vil operatoren =, == og + v\u00e6re fornuftige (der kan selvf\u00f8lgeligt findes andre, men de tre giver os mulighed for at se lidt af hvert).<\/p>\n

\u00a0<\/p>\n

= s\u00e6tter vores cirkel lig med en anden cirkel – det vil sige, at radius s\u00e6ttes til radius af den anden cirkel.<\/p>\n

\u00a0<\/p>\n

== sammenligner om radius p\u00e5 to cirkler er ens og returnerer en boolsk v\u00e6rdi.<\/p>\n

\u00a0<\/p>\n

+ l\u00e6gger ikke to cirkler sammen, men l\u00e6gger en konstant til radius.<\/p>\n

\u00a0<\/p>\n

Erkl\u00e6ringen af klassen med de tre operatorer og implementationen heraf kunne se s\u00e5ledes ud:<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>Cirkel<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong> \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(); \/\/Constructor uden parametre<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int <\/strong>r); \/\/Constructor med radius som parameter<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>SetRadius (int <\/strong>r);<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetAreal();<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetOmkreds();<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 \/\/Operators<\/p>\n

\u00a0\u00a0\u00a0 Cirkel& <\/strong>operator= (Cirkel);<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>operator== (Cirkel);<\/p>\n

\u00a0\u00a0\u00a0 Cirkel operator+ (int<\/strong>);<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n

Cirkel& Cirkel::operator<\/strong>= (Cirkel c)<\/p>\n

{<\/p>\n

\u00a0 radius = c.radius;<\/p>\n

\u00a0 return <\/strong>*this<\/strong>;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

int <\/strong>Cirkel::operator== (Cirkel c)<\/p>\n

{<\/p>\n

\u00a0 return <\/strong>radius == c.radius;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

Cirkel Cirkel::operator+ (int <\/strong>x)<\/p>\n

{<\/p>\n

\u00a0 return <\/strong>Cirkel(radius + x);<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 7.<\/p>\n

\u00a0<\/p>\n

Umiddelbart kan de forskellige returtyper m\u00e5ske virke forvirrende, men pr\u00f8v at se p\u00e5 et par eksempler.<\/p>\n

\u00a0<\/p>\n

Cirkel A(5), B; \/\/Opret to cirkler – en med radius 5 og en med radius 0<\/p>\n

\u00a0<\/p>\n

B = A;<\/p>\n

\u00a0<\/p>\n

Her ser vi to objekter af samme klasse med en operator i mellem. F\u00f8rst skal det understreges, at det altid er objektet til venstre for en bin\u00e6r operator, der f\u00e5r funktionskaldet. I dette tilf\u00e6lde vil det alts\u00e5 v\u00e6re B’s funktion operator=, der kaldes.<\/p>\n

\u00a0<\/p>\n

Denne funktion skal prim\u00e6rt s\u00f8rge for, at B’s radius s\u00e6ttes lig med A’s radius. Man kunne p\u00e5 den baggrund argumentere for, at den ikke beh\u00f8vede at returnere noget. Imidlertid er det jo s\u00e5dan i C++, at assignments har en v\u00e6rdi. Man kan fx skrive X = Y = 5, hvilket medf\u00f8rer, at b\u00e5de Y s\u00e6ttes til 5 og X s\u00e6ttes til v\u00e6rdien af assignmentet Y = 5, hvilket vil sige 5. Ergo s\u00e6ttes b\u00e5de X og Y til 5.<\/p>\n

\u00a0<\/p>\n

Hvis vi \u00f8nsker, at det samme skal g\u00e6lde for objekter af cirkelklassen, fx C = B = A, skal B = A alts\u00e5 returnere v\u00e6rdien B.<\/p>\n

\u00a0<\/p>\n

At returtypen er en reference skyldes blot, at dataene fra det ene objekt ikke skal kopieres over i et andet – det har ingen betydning i dette eksempel, men ved klasser med store m\u00e6ngder private data, kan man spare tid p\u00e5 denne m\u00e5de.<\/p>\n

\u00a0<\/p>\n

Det mest interessante ved funktionen er nok at den returnerer *this. this er en pointer til det aktuelle objekt, alts\u00e5 i dette tilf\u00e6lde objektet p\u00e5 venstre-siden af lighedstegnet. At der s\u00e6ttes en stjerne foran, skyldes blot at det er v\u00e6rdien og ikke adressen, der skal returneres (at det er <\/em>adressen, der bliver returneret, fordi resultatet returneres per reference, er en anden sag).<\/p>\n

\u00a0<\/p>\n

Hvis vi v\u00e6lger at sammenligne de to cirkler kan det g\u00f8res med nedenst\u00e5ende if-struktur:<\/p>\n

\u00a0<\/p>\n

if (A==B)<\/p>\n

cout << “Ens”;<\/p>\n

else<\/p>\n

cout << “Uens”;<\/p>\n

\u00a0<\/p>\n

Her skal operator== returnere en boolsk v\u00e6rdi (dvs 0 eller 1) alt efter om de to cirklers radius er ens. Det g\u00f8res i dette tilf\u00e6lde ved at returnere resultatet af sammenligningen af de to radia.<\/p>\n

\u00a0<\/p>\n

operator+ derimod skal returnere en variabel af typen Cirkel. Det ses af nedenst\u00e5ende eksempel:<\/p>\n

\u00a0<\/p>\n

B = A+2;<\/p>\n

\u00a0<\/p>\n

Her skal udtrykket A+2 evalueres f\u00f8rst. Det g\u00f8res ved et kald til A’s operator+ (A st\u00e5r p\u00e5 venstre side af operatoren). Herefter skal resultatet af denne evaluering l\u00e6gges over i B (hvilket i \u00f8vrigt sker ved et kald til B’s operator=). Da den eneste v\u00e6rdi vi kan s\u00e6tte lig med en cirkel er en anden cirkel, m\u00e5 returtypen af operator+ alts\u00e5 v\u00e6re en cirkel.<\/p>\n

\u00a0<\/p>\n

Returneringen fra operator+ viser ogs\u00e5, at man godt kan kalde en klasses constructor direkte. Returtypen herfra er et objekt af klassen.<\/p>\n

\u00a0<\/p>\n

En pudsig ting ved operator-funktioner, der returnerer objekter er, at man kan kalde member-funktioner fra assignments. Fx vil linien<\/p>\n

\u00a0<\/p>\n

cout << (c+1).GetOmkreds();<\/p>\n

\u00a0<\/p>\n

udskrive omkredsen af en cirkel med en radius en st\u00f8rre end c’s (men vil ikke \u00e6ndre c’s radius!)<\/p>\n

\u00a0<\/p>\n

Ligesom det var muligt at have multiple constructors er det ogs\u00e5 muligt at have flere implementationer af den samme operator. Det foreg\u00e5r efter pr\u00e6cis samme princip som multiple constructors. P\u00e5 den m\u00e5de vil det v\u00e6re muligt – udover at l\u00e6gge en int til en cirkel – at l\u00e6gge to cirkler sammen, eller m\u00e5ske ogs\u00e5 en cirkel og en float. Hvis man arbejder med flere forskellige klasser kan man endda skrive funktioner, der g\u00f8r det muligt at sammenligne, addere osv. de forskellige klasser.<\/p>\n

\u00a0<\/p>\n

Det kan m\u00e5ske virke overraskende, at de forskellige operator-funktioner kan tilg\u00e5 variablen radius i de cirkler de f\u00e5r over som parametre. Det skyldes, at memberfunktioner i en klasse, altid kan tilg\u00e5 de private variable (og funktioner) som objekter af samme klasse har.<\/p>\n

\u00a0<\/p>\n

Det er ikke alle operatorer, der kan overloades, men de fleste kan. Nedenst\u00e5ende skema, viser hvilke der kan og ikke kan. Nogle af operatorerne vender vi tilbage til i afsnittet om friend-funktioner.<\/p>\n

\u00a0<\/p>\n

F\u00f8lgende operatorer kan overloades:<\/p>\n\n\n\n\n\n\n\n
+<\/td>\n–<\/td>\n*<\/td>\n\/<\/td>\n%<\/td>\n^<\/td>\n&<\/td>\n|<\/td>\n<\/tr>\n
~<\/td>\n!<\/td>\n=<\/td>\n<\u00a0<\/td>\n>\u00a0<\/td>\n+=<\/td>\n-=<\/td>\n*=<\/td>\n<\/tr>\n
\/=<\/td>\n%=<\/td>\n^=<\/td>\n&=<\/td>\n|=<\/td>\n<<\u00a0<\/td>\n>>\u00a0<\/td>\n<<=<\/td>\n<\/tr>\n
>>=<\/td>\n==<\/td>\n!=<\/td>\n<=<\/td>\n>=<\/td>\n&&<\/td>\n||<\/td>\n++<\/td>\n<\/tr>\n
–<\/td>\n-><\/td>\n,<\/td>\n-><\/td>\n[]<\/td>\n()<\/td>\nnew<\/strong><\/td>\ndelete<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\u00a0<\/p>\n

F\u00f8lgende operatorer kan ikke overloades:<\/p>\n\n\n\n
.<\/td>\n.*<\/td>\n::<\/td>\n?:<\/td>\nsizeof<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\u00a0<\/p>\n

Friend-funktioner<\/a><\/h2>\n

\u00a0<\/p>\n

Af og til kan man have brug for at tillade enkelte funktioner udenfor klassen at tilg\u00e5 private variable og funktioner. Det g\u00f8r man ved at inkludere funktionsnavnet i klassens erkl\u00e6ring og tilf\u00f8je det reserverede ord friend foran.<\/p>\n

\u00a0<\/p>\n

En typisk anvendelse af friend-funktioner er n\u00e5r man vil overloade en operator, hvor ens objekt st\u00e5r p\u00e5 h\u00f8jre siden. Betragt for eksempel nedenst\u00e5ende linie:<\/p>\n

\u00a0<\/p>\n

cout << C;<\/p>\n

\u00a0<\/p>\n

Her vil det v\u00e6re cout, der f\u00e5r funktionskaldet, og funktioner i cout vil normalt ikke kunne tilg\u00e5 private variable i cirklen C. Derfor v\u00e6lger vi at g\u00f8re cout’s funktion til en friend af vores klasse, og vi skriver selv implementationen til udskriftsrutinen. Husk at cout blot er en variabel af typen ostream.<\/p>\n

\u00a0<\/p>\n

Erkl\u00e6ringen af klassen og implementationen af udskriftsrutinen ser s\u00e5ledes ud:<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>Cirkel<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong> \/\/Private variable<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>radius;<\/p>\n

\u00a0 public:<\/strong> \/\/Member functions<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(); \/\/Constructor uden parametre<\/p>\n

\u00a0\u00a0\u00a0 Cirkel(int <\/strong>r); \/\/Constructor med radius som parameter<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>SetRadius (int <\/strong>r);<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetAreal();<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>GetOmkreds();<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 \/\/Operators<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>operator= (Cirkel);<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>operator== (Cirkel);<\/p>\n

\u00a0\u00a0\u00a0 Cirkel operator+ (int<\/strong>);<\/p>\n

\u00a0\u00a0\u00a0 friend <\/strong>ostream& operator<\/strong><< (ostream& ostr, Cirkel C);<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n

ostream& operator<\/strong><< (ostream& ostr, Cirkel C)<\/p>\n

{<\/p>\n

\u00a0 ostr << C.radius;<\/p>\n

\u00a0 return <\/strong>ostr;<\/p>\n

}<\/p>\n

\u00a0<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 8.<\/p>\n

\u00a0<\/p>\n

Bem\u00e6rk at funktionen ikke er medlem af klassen Cirkel – det vil sige, at man ikke skal inkludere klassenavnet i funktionshovedet.<\/p>\n

\u00a0<\/p>\n

At returtypen er en ostream skyldes, at man kan lave l\u00e6nkede outputs. Fx<\/p>\n

\u00a0<\/p>\n

cout << “Radius er ” << C << endl;<\/p>\n

\u00a0<\/p>\n

Hvis udskriften af C ikke returnerede en ostream, ville de ikke v\u00e6re muligt at sende endl i samme str\u00f8m.<\/p>\n

\u00a0<\/p>\n

Den ostream, der tages som parameter er den man skal sende udskriften til. Man skal alts\u00e5 v\u00e6re opm\u00e6rksom p\u00e5 ikke af gammel vane at skrive cout. Hvis man anvender cout i stedet for ostream vil funktionen kun kunne bruges til udskrift p\u00e5 sk\u00e6rmen og ikke til fx udskrift til fil.<\/p>\n

\u00a0<\/p>\n

I dette tilf\u00e6lde skal objektet ogs\u00e5 tages som parameter. Det skyldes, at denne funktion jo ikke tilh\u00f8rer klassen – hvis vi skal kende objektet, er vi n\u00f8dt til at f\u00e5 det med som parameter.<\/p>\n

\u00a0<\/p>\n

Dynamisk instantiering af objekter<\/a><\/h2>\n

Dynamisk allokering af hukommelse er ikke nogen speciel objektorienteret funktion, men det er medtaget her, fordi det aff\u00f8der nogle interessante problemer i forhold til objekter.<\/p>\n

\u00a0<\/p>\n

Hvis vi i stedet for vores klasse Cirkel, der kun kan indeholde information om en cirkel, \u00f8nsker at lave en klasse med flere cirkler – CirkelList – kan vi opbevare informationerne om de forskellige cirkler i et privat array af typen Cirkel. St\u00f8rrelsen p\u00e5 dette array kan imidlertid variere, da vi lader det v\u00e6re op til brugeren af klassen at bestemme, hvor mange cirkler, der skal v\u00e6re plads til. Derfor har vi brug for at allokere hukommelsen dynamisk. Vi lader brugeren angive antallet af cirkler n\u00e5r han instantierer objektet. Hvis der ikke angives nogen v\u00e6rdi, vil der blive lavet plads til 10 cirkler. S\u00e5 vil erkl\u00e6ringen af klassen og constructoren komme til at se s\u00e5ledes ud:<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>CirkelList<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 Cirkel *Liste;<\/p>\n

\u00a0 public:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 CirkelList(int <\/strong>antal=10);<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

CirkelList::CirkelList (int<\/strong> Antal)<\/p>\n

{<\/p>\n

\u00a0 if<\/strong> (Antal < 1)<\/p>\n

\u00a0 return<\/strong>;<\/p>\n

\u00a0 Liste = new <\/strong>Cirkel[Antal];<\/p>\n

\u00a0 count = 0;<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 9.<\/p>\n

\u00a0<\/p>\n

Bem\u00e6rk, at Liste, der skal v\u00e6re det array, der indeholde de forskellige cirkler, blot er en pointer – den f\u00e5r f\u00f8rst tildelt hukommelse i constructoren.<\/p>\n

\u00a0<\/p>\n

Copy constructor<\/a><\/h2>\n

Det er tidligere n\u00e6vnt, at constructoren kaldes, n\u00e5r et objekt bliver instantieret. Pr\u00f8v at betragte nedenst\u00e5ende eksempel:<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
\u00a0 void <\/strong>main()<\/p>\n

\u00a0 {<\/p>\n

\u00a0\u00a0\u00a0 Cirkel rund(5);<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 CirkelList List1;<\/p>\n

\u00a0\u00a0\u00a0 List1.Add (rund);<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 CirkelList List2=List1;<\/p>\n

\u00a0 }<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 10<\/p>\n

\u00a0<\/p>\n

Her bliver List2 instantieret og bliver omg\u00e5ende sat lig med List1. Det betyder, at alle List1’s variable bliver kopieret over til List2. Det g\u00e6lder s\u00e5ledes ogs\u00e5 pointeren List1.Liste, der peger p\u00e5 placeringen af cirklerne i hukommelsen. Det medf\u00f8rer, at det ikke er to forskellige lister vi har, men to referencer til den samme liste af cirkler. I s\u00e5danne tilf\u00e6lde har man brug for at kalde en s\u00e5kaldt copy constructor. Den kaldes automatisk, n\u00e5r der kan v\u00e6re behov for at kopiere data i constructoren. Udover ovenst\u00e5ende eksempel er det n\u00e5r et objekt gives med som parameter i et funktionskald (men ikke, hvis parameteren gives som pointer eller som reference).<\/p>\n

\u00a0<\/p>\n

Copy constructoren ser s\u00e5ledes ud:<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>CirkelList<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 Cirkel *Liste;<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>size, count; \/\/Max. st\u00f8rrelse og antal indtastede<\/p>\n

\u00a0 public:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 CirkelList(int <\/strong>antal=10); \/\/ Standard constructor<\/p>\n

\u00a0\u00a0\u00a0 CirkelList (const CirkelList &cl); \/\/ Copy constructor<\/p>\n

\u00a0\u00a0\u00a0 CirkelList& operator<\/strong>= (CirkelList cl);<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>Add (Cirkel c); \/\/Tilf\u00f8jer cirkel<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

CirkelList::CirkelList (const <\/strong>CirkelList &cl)<\/p>\n

{<\/p>\n

\u00a0 count = cl.count;<\/p>\n

\u00a0 size = cl.size;<\/p>\n

\u00a0 Liste = new <\/strong>Cirkel [size];<\/p>\n

\u00a0 for (int <\/strong>i = 0; i < count; i++)<\/p>\n

\u00a0 Liste[i] = cl.Liste[i];<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 11<\/p>\n

\u00a0<\/p>\n

Det interessante ved copy constructoren ses allerede i funktionshovedet. Som enhver anden constructor har den ingen returtype. Derudover skal parametren var const og referenceparameter. Parametertypen skal naturligvis v\u00e6re en instans af klassen – det er jo h\u00f8jresiden i tildelingen. I eksemplet fra Eksempel 10 vil parametren alts\u00e5 v\u00e6re List1.<\/p>\n

\u00a0<\/p>\n

Da objekter af samme klasse automatisk er friends<\/em> kan copy contructoren uden videre tilg\u00e5 parametrens private data, s\u00e5som size og count.<\/p>\n

\u00a0<\/p>\n

Bem\u00e6rk ogs\u00e5, at copy constructoren kun kan tage den ene parameter. Det betyder fx at nedenst\u00e5ende s\u00e6tning ikke er tilladt:<\/p>\n

\u00a0<\/p>\n

CirkelList List2(5)=List1;<\/p>\n

\u00a0<\/p>\n

Destructor<\/a><\/h2>\n

\u00a0<\/p>\n

Det kan n\u00e6sten h\u00f8res af navnet: Destructor er det modsatte af constructor. Destructoren kaldes, n\u00e5r et objekt skal fjernes. Det kan enten skyldes at dets scope er udl\u00f8bet (for lokale variable), eller at objektet er blevet instantieret dynamisk og nu bliver fjernet ved hj\u00e6lp af delete kommandoen. Endeligt kan det ogs\u00e5 skyldes, at programmet er afsluttet.<\/p>\n

\u00a0<\/p>\n

Da C++ ikke har garbage collection er det op til objekterne selv at frigive den hukommelse, de har allokeret dynamisk. Den hukommelse, der er tildelt statisk – det vil sige til variable, der ikke er pointere – bliver automatisk frigivet og skal ikke frigives i destructoren.<\/p>\n

\u00a0<\/p>\n

Nedenst\u00e5ende er et eksempel p\u00e5 en destructor i klassen CirkelList.<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
class <\/strong>CirkelList<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 Cirkel *Liste;<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>size, count; \/\/Max. st\u00f8rrelse og antal indtastede<\/p>\n

\u00a0<\/p>\n

\u00a0 public:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 \/\/ Constructors<\/p>\n

\u00a0\u00a0\u00a0 CirkelList(int <\/strong>antal=10);<\/p>\n

\u00a0\u00a0\u00a0 CirkelList (const CirkelList &cl);<\/p>\n

\u00a0<\/p>\n

\u00a0 \/\/ Destructor<\/p>\n

\u00a0 ~CirkelList ();<\/p>\n

\u00a0<\/p>\n

\u00a0 \/\/ Operatorer<\/p>\n

\u00a0 CirkelList& operator= (CirkelList cl);<\/p>\n

\u00a0<\/p>\n

\u00a0 \/\/ Andre funktioner<\/p>\n

\u00a0 void <\/strong>Add (Cirkel c); \/\/Tilf\u00f8jer cirkel<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

CirkelList::~CirkelList()<\/p>\n

{<\/p>\n

\u00a0 if<\/strong> (Liste)<\/p>\n

\u00a0 delete<\/strong>[] Liste;<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 12<\/p>\n

\u00a0<\/p>\n

Ligesom constructoren, har destructoren ingen returtype. Dens navn skal v\u00e6re klassens navn med en tilde (~) foran. Destructoren tager aldrig parametre. I dette eksempel skal den kun frigive det hukommelse, der er tildelt pointeren Liste. F\u00f8rst kontrollerer den dog, at pointeren ikke er null, hvilket kunne v\u00e6re tilf\u00e6ldet, hvis en illegal parameter var overf\u00f8rt til constructoren, eller hvis der ikke havde v\u00e6ret tilstr\u00e6kkelig hukommelse til instantiering.<\/p>\n

\u00a0<\/p>\n

Bem\u00e6rk i \u00f8vrigt den s\u00e6re notation med de kantede parenteser efter delete. Det angiver, at hele array’et skal slettes. Var de der ikke, var kun det f\u00f8rste element blevet fjernet.<\/p>\n

\u00a0<\/p>\n

Kald af funktioner gennem pointere<\/a><\/h2>\n

\u00a0<\/p>\n

Hvis man har en pointer til et objekt og gerne vil kalde et af objektets funktioner, bruger man i stedet for det vanlige punktum en pil (->) som scope-angivelse. Se nedenst\u00e5ende eksempel.<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
\u00a0 void <\/strong>main()<\/p>\n

\u00a0 {<\/p>\n

\u00a0\u00a0\u00a0 Cirkel rund(5), rund2;<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 CirkelList *List1;<\/p>\n

\u00a0\u00a0\u00a0 List1 = new <\/strong>CirkelList();<\/p>\n

\u00a0\u00a0\u00a0 List1->Add (rund);<\/p>\n

\u00a0\u00a0\u00a0 delete<\/strong> List1;<\/p>\n

\u00a0 }<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 13<\/p>\n

\u00a0<\/p>\n

Bem\u00e6rk, at der f\u00f8rst laves en pointer til et CirkelList-objekt, hvorefter det instantieres ved hj\u00e6lp new. Herefter kaldes funktionen Add med kommandoen List1->Add(); Slutteligt fjernes objektet med delete. Grunden, til at man er n\u00f8dt til at bruge pilen, er, at man ikke kan dereferenciere objekter. Ellers kunne man jo have klaret sig med kommandoen *List1.Add(rund); Det er ikke <\/em>tilladt.<\/p>\n

Templates<\/a><\/h2>\n

\u00a0<\/p>\n

Ligesom man i C++ kan lave generiske funktioner (template-funktioner) kan man ogs\u00e5 lave template-klasser. I en template-klasse, bygger man klassen til at kunne benytte flere forskellige slags datatyper – det er herefter op til den enkelte programm\u00f8r at angive i koden, hvilken datatype, der skal benyttes.\u00a0 Hvis vi i stedet for vores CirkelList klasse, ville have en klasse, der bare skulle v\u00e6re en liste, og ellers ikke bekymre sig om, hvad den var en liste af, kunne vi passende g\u00f8re den til en template-klasse. S\u00e5 ville funktionerne komme til at se s\u00e5ledes ud:<\/p>\n

\u00a0<\/p>\n

\u00a0<\/p>\n\n\n\n
template <\/strong><class <\/strong>T><\/p>\n

class <\/strong>List<\/p>\n

{<\/p>\n

\u00a0 private:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 T *Liste;<\/p>\n

\u00a0\u00a0\u00a0 int <\/strong>size, count; \/\/Max. st\u00f8rrelse og antal indtastede<\/p>\n

\u00a0<\/p>\n

\u00a0 public:<\/strong><\/p>\n

\u00a0\u00a0\u00a0 \/\/ Constructors<\/p>\n

\u00a0\u00a0\u00a0 List(int<\/strong> antal=10);<\/p>\n

\u00a0\u00a0\u00a0 List(const <\/strong>List<T> &l);<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 \/\/ Destructor<\/p>\n

\u00a0\u00a0\u00a0 ~List ();<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 \/\/ Operatorer<\/p>\n

\u00a0\u00a0\u00a0 List<T>& operator<\/strong>= (List<T> l);<\/p>\n

\u00a0<\/p>\n

\u00a0\u00a0\u00a0 \/\/ Andre funktioner<\/p>\n

\u00a0\u00a0\u00a0 void <\/strong>Add (T c); \/\/Tilf\u00f8jer element<\/p>\n

};<\/p>\n

\u00a0<\/p>\n

template <\/strong><class <\/strong>T><\/p>\n

List<T>::List (int<\/strong> Antal)<\/p>\n

{<\/p>\n

\u00a0 if <\/strong>(Antal < 1)<\/p>\n

\u00a0 return<\/strong>;<\/p>\n

\u00a0 Liste = new <\/strong>T[Antal];<\/p>\n

\u00a0 count = 0;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

template <\/strong><class <\/strong>T><\/p>\n

List<T>::List (const <\/strong>List<T> &l)<\/p>\n

{<\/p>\n

\u00a0 count = l.count;<\/p>\n

\u00a0 size = l.size;<\/p>\n

\u00a0 Liste = new <\/strong>T [size];<\/p>\n

\u00a0 for (int <\/strong>i = 0; i < count; i++)<\/p>\n

\u00a0 Liste[i] = l.Liste[i];<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

template <\/strong><class <\/strong>T><\/p>\n

List<T>::~List()<\/p>\n

{<\/p>\n

\u00a0 if <\/strong>(Liste)<\/p>\n

\u00a0 delete<\/strong>[] Liste;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

template <\/strong><class <\/strong>T><\/p>\n

List<T>& List<T>::operator<\/strong>= (List<T> l)<\/p>\n

{<\/p>\n

\u00a0 size = size < l.size ? size : l.size; \/\/V\u00e6lg mindste st\u00f8rrelse<\/p>\n

\u00a0<\/p>\n

\u00a0 for <\/strong>(int <\/strong>i = 0; i < size; i++)<\/p>\n

\u00a0 Liste[i] = l.Liste[i];<\/p>\n

\u00a0<\/p>\n

\u00a0 return *this<\/strong>;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

template <\/strong><class <\/strong>T><\/p>\n

void <\/strong>List<T>::Add (T c)<\/p>\n

{<\/p>\n

\u00a0 Liste[count++] = c;<\/p>\n

}<\/p>\n

\u00a0<\/p>\n

void <\/strong>main()<\/p>\n

{<\/p>\n

\u00a0 List<int<\/strong>> IntegerListe (5);<\/p>\n

\u00a0 IntegerListe.Add (6);<\/p>\n

\u00a0<\/p>\n

\u00a0 List<Cirkel> *CirkelListe;<\/p>\n

\u00a0 Cirkel rund(5);<\/p>\n

\u00a0<\/p>\n

\u00a0 CirkelListe = new <\/strong>List<Cirkel>();<\/p>\n

\u00a0 CirkelListe->Add (rund);<\/p>\n

\u00a0 delete<\/strong> CirkelListe;<\/p>\n

}<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Eksempel 14<\/p>\n

\u00a0<\/p>\n

Det b\u00e6rende i template-klasser er udtrykket template <class T>, der skrives foran selve klassen og alle medlemsfunktioner. Faktisk er T bare en pladsholder for en hvilken som helst type, og T kan derfor erstattes af et hvilket som helst andet navn.<\/p>\n

\u00a0<\/p>\n

Da T er pladsholder for den type, der skal bruges i klassen, ser man, at Liste ikke l\u00e6ngere er en pointer til Cirkel, men en pointer til T.\u00a0<\/p>\n

\u00a0<\/p>\n

Klassens rigtige navn er nu List<type<\/em>>, og da den type vi arbejder med er T, skal den klasse, der skal overf\u00f8res til copy constructoren var List<T>. Det samme g\u00f8r sig g\u00e6ldende i alle funktionshovederne. Her er klasseangivelsen p\u00e5 venstre side af scope-tegnet List<T>. Generelt kan konverteringen af en specifik klasse til en generel template-klasse opdeles i tre punkter:<\/p>\n

\u00a0<\/p>\n