Brugernavn:



Kodeord: Husk
Forside Forum Artikler Downloads Søg
 

C++ og klasser

Forord

I denne artikel vil jeg vise hvordan man kommer igang med klasser. Jeg ville gerne fortælle alt om klasser, men da det er et så komplekst emne vil jeg kun fortælle om det mest basale. Artiklen er ikke en artikel for en absolut begynder, da artiklen kun er om klasser og hvad dertil hører. Men tilgengæld er C++ et kendt sprog, så det er ikke just svært at finde guides, tutorials, sourcecode, etc. omkring sproget. Jeg har valgt at dele artiklen op i små kapitler. Hvert kapitel starter ud med et lille forord, så man kan se hvad der kommer i kapitlet. Til slut, slutter jeg af med en lille note. Nu har jeg ikke mere at sige end, håber i nyder den!

Indholdsfortegnelse

1.0   Klasser
   1.1   Hvad er en klasse?
   1.2   Hvorfor bruge klasser?
2.0   Lad os komme igang
   2.1   Vores første klasse
   2.2   Konstruktøren
   2.3   Destruktøren
   2.4   Et lille program
3.0   Static, const, ...
   3.1   static
   3.2   const
   3.3   mutable
   3.4   inline
   3.5   This-pointeren
4.0   Her til slut...

1.0  Klasser

Man kan ikke sige at klasser i sig selv er en del af C++, man kan derimod sige at klasser er en del af emnet OOP. Objekt Orienteret Programmering er den helt nye stil inden for programmering. Flere og flere sprog har efterhånden fået OOP intergreret, bl.a. kan disse nævnes: PHP, Python, Diverse Lisp-dialekter og mange flere. Jeg vil nu ikke fortælle så meget om OOP generelt, kun i C++-sammenhæng. C++ blev udviklet af danskeren, Bjarne Stroustrup i "79, så det var på samme tid ham der introducerede OOP i C++-verdenen. Nok om det, jeg fornemmer at I vil igang med hvad det nu er det hele handler om, Klasser.

1.1  Hvad er en klasse?

Klasser er som sagt en del af OOP. I sproget C, blev alting altid gjort i en stor smøre. Det var selvfølgelig struktureret, men ikke så godt som nu. I C-dagene brugte man, struct"s. Struct"s findes stadig i C++ og er stærkt beslægtet med både klasserne og union"s. Det som klassen har, og som struct"s og union"s ikke har, er at man kan både gøre brug af polymorfi, arv og meget meget mere. Disse ting vil jeg desværre ikke gennemgå i denne artikel, men det kan være det kommer en anden god gang? Du er måske interesseret i hvorfor man overhovedet bruger klasser, hvis du er, som jeg også var da jeg startede, så læs blot videre...

1.2  Hvorfor bruge klasser?

Hvis man arbejder med store mængde data, store systemer eller lignende, kan det godt være svært at holde styr på det hele. En klasse gør det netop nemmere at holde styr på det hele. I en klasse kan du holde stort set alt hvad du vil, templates, funktioner, variabler, structs, osv. Jeg bruger personligt klasser - og OOP i det hele taget, meget. Især til COM og Win32-programmering. Ta" et Win32-program, det fylder snildt over 2-300 linjer, og så kan det til tider være svært at holde overblikket. Ved brug af klasser, kan men hælde diverse funktioner op i klassen og bruge den derudfra. Det gør det også nemmere at f.eks. bruge flere headerfiler så man igen får endnu mere overblik. Det er generelt godt at lære OOP, da det er en del af "fremtidens" programmering.

2.0  Lad os komme igang

Jeg vil i dette kapitel vise hvordan en simpel klasse implementeres. Jeg slutter af med et program, så I kan se hvordan et eksempel med brug af klasser kunne være. Jeg vil derudover fortæller lidt om Konstruktøren og Destruktøren. Jeg venter med de lidt mere advancerede funktioner og tingel-tangel til næste kapitel. Nu skal I først og fremmest lære at bruge en klasse og for ikke at tale om, forstå den!

2.1  Vores første klasse

Der er 2 grundlæggende ting, man altid skal huske. Den første er, nøjagtig som normale variabler, at navnet på klassen IKKE må starte med et tal. Navnet skal starte med enten underscore ( _ ) eller et bogstav fra det engelske alfabet ( a...z ). Den anden ting er at man skal huske et semikolon ( ; ) i slutningen af klassen. Det er det samme som ved eksempelvis en struct, men ikke en funktion da funktioner ikke afslutter med et semikolon. Lad os se skeletet af en klasse...
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     // ...
  6. };

  8. int main()
  9. {
  10.     return 0;
  11. }
En klasse kan opdeles i 3 forskellige zoner, private, public og protected. Som default er hele klasse-zonen private, så intet ville kunne tilgåes udefra klassen, da den er, på dansk, privat. Alt i public-zonen kan tilgås udefra klassen, eksempelvis fra main(). Protected er til hvis man skal have gang i arv eller polymorfi. Som sagt vil denne artikel ikke omhandle disse emner, så du skal primært kun koncentrere dig om public og private.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     private:
  6.         // ...
  7.     public:
  8.         // ...
  9. };

  11. int main()
  12. {
  13.     return 0;
  14. }
Når man skal initalisere en klasse kan den både tage parametre og ikke. Vi vil i dette lille kapitel kun beskæftige os med klasser som IKKE tager parametre. Hvis du vil vide mere om dette, så kig under "Konstruktøren". Lad os prøve at initalisere vores klasse i main-delen og derefter vil jeg vise jer en anden metode som til tider er bedre.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     private:
  6.         // ...
  7.     public:
  8.         // ...
  9. };

  11. int main()
  12. {
  13.     VoresKlasse test;

  15.     return 0;
  16. }
Som du kan se har vi faktisk lavet vores egen datatype, nøjagtig som vi kender det fra de normale datatyper, int, char, bool, osv. Som sagt er der endnu en metode som dem der har leget med struct"s muligvis kender. Nemlig at deklarere variablen lige før semikolonet. Lad os se på det.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     private:
  6.         // ...
  7.     public:
  8.         // ...
  9. } test;

  11. int main()
  12. {
  13.     return 0;
  14. }
Som I nu kan se er der intet i main-delen da vi allerede har deklareret det vi skulle, man kan derefter bruge den på samme måde som på den anden måde. Hvis man vil putte noget i klassen, skal man som sagt huske at ALT under private KUN kan bruges af klassen selv, altså imellem tuborgklammerne ( {} ). Og alt under public kan man bruge fra hvor man har lyst. Vi prøver at sætte en int ( integer ) ind i klassen under public så vi kan tilgå den ude fra. Vi vil derefter sætte en værdi i variablen og derefter udskrive.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     private:
  6.         // ...
  7.     public:
  8.         int X;
  9. };

  11. int main()
  12. {
  13.     VoresKlasse test;

  15.     test.X = 10;
  16.     std::cout << test.X << std::endl;

  18.     return 0;
  19. }
Som I kan ses oprettes først klassen hvorefter at variablen X, som tilhører klassen sættes til 10. Derefter udskriver vi variablen, som selvfølgelig indeholder 10. Til dem som ikke forstår std::, så kan jeg sige at I kan fjerne std:: og i stedet putte using namespace std; oppe under iostream, så vil det hele også virke. Jeg vil ikke fortælle mere om dette da det er namespaces og er ikke en del af klasser. Nu når vi kan bruge vores klasse kan i jo lege lidt med det, evt. oprette flere typer af klassen og se hvad der sker. Kun fantasien sætter grænser. Det er også muligt at putte, som sagt, funktioner i klassen. En funktion i en klasse fungerer på nøjagtig den samme måde som en normal funktion, og dog. Der er nemlig 2 forskellige måder at bruge funktioner i klasser på. Den ene er at lave alt arbejdet inde i klassen, altså imellem tuborgklammerne, eller at gøre det "udenfor" klassen. Man kan ikke sige at det er udenfor selve klassen men det kan det godt ligne hvis man ikke har arbejdet med klasser før. Lad os starte ud med det første jeg snakkede om, og derefter kan i se den anden metode.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     public:
  6.         void VoresFunktion()
  7.         {
  8.             std::cout << "Hej!" << std::endl;
  9.         }
  10. };

  12. int main()
  13. {
  14.     VoresKlasse test;

  16.     test.VoresFunktion();

  18.     return 0;
  19. }
Her har vi puttet en funktion ind i klassen, og læg mærke til at det er under public, så vi kan tilgå den udefra. I kan også se at jeg har smidt private væk, som man ikke absolut behøver, på samme måde har jeg heller ikke protected inde. Denne metode er mest velegnet til små eventuelle inline funktioner, eller til små programmer. Hvis man vil lave store programmer som eventuelt bruger mange filer er den kommende løsning i mine øjne bedre, da det giver et godt overblik.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     public:
  6.         void VoresFunktion();
  7. };

  9. void VoresKlasse::VoresFunktion()
  10. {
  11.     std::cout << "Hej!" << std::endl;
  12. }

  14. int main()
  15. {
  16.     VoresKlasse test;

  18.     test.VoresFunktion();

  20.     return 0;
  21. }
I kan se at dette måske ikke helt er den optimale løsning i dette program, da det måske bliver lidt rodet. Når man gør det på denne måde skal funktionens returværdi ( return ) sættes først, hvorefter klassens navn forekommer efterfulgt af scopes ( :: ) og til sidst klassen navn og parameterliste ( (...) ). Lad os lave et lille program som bygger på hvad vi nu kan. Vi opretter en klasse hvor vi derefter sætter en variabel til hvad vi modtager fra klassen. Vi får bagefter en anden funktion til at udskrive variablens værdi.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     private:
  6.         int Variabel;
  7.     public:
  8.         void SaetVariabel(int Var)
  9.         {
  10.             Variabel = Var;
  11.         }

  13.         void HentVariabel()
  14.         {
  15.             std::cout << Variabel << std::endl;
  16.         }
  17. };

  19. int main()
  20. {
  21.     VoresKlasse test;

  23.     test.SaetVariabel(10);
  24.     test.HentVariabel();

  26.     return 0;
  27. }
Læg mærke til at vi har sat variablen under private, derfor kan vi heller ikke udskrive den som vi gjorde i vores eksempel med public og X"et. Alt andet er som det nu er med funktioner.

2.2  Konstruktøren

Konstruktøren er måske den vigtigste del af en klasse. Om du vil det eller ej vil der altid være en konstruktør. Hvis du ikke selv laver den, laver kompileren den, så der er ingen vej udenom. En konstruktør laves præcist når du initalisere din variabel af den type klasse med konstruktøren. Man kan give en konstruktør parameter, som den så sætter ind i klassen eller bruger lige fra start. En konstruktør hedder det samme som klassen selv, så i vores tilfælde hedder den VoresKlasse(). Lad os lave en simpel konstruktør, hvorefter vi bagefter vil lave en konstruktør som der tager parametre.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     public:
  6.         VoresKlasse()
  7.         {
  8.             std::cout << "Inde i konstruktøren!" << std::endl;
  9.         }
  10. };

  12. int main()
  13. {
  14.     VoresKlasse test;

  16.     return 0;
  17. }
Det der står inde i konstruktøren vil automatisk blive vist når vi skriver VoresKlasse test;. Lad os lave en konstruktør som tager imod paramtre. Der findes faktisk to måder at gøre dette på, jeg vil først vise jer den mest normale og derefter den anden.
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     public:
  6.         VoresKlasse(int x, int y)
  7.         {
  8.             std::cout << x+y << std::endl;
  9.         }
  10. };

  12. int main()
  13. {
  14.     VoresKlasse test(10, 20);

  16.     return 0;
  17. }
Som I kan se tager konstruktøren nu imod parametre og derefter udskriver de to tal pluset. Man kunne selvfølgelig putte en masse ekstra parametre på, men det er også KUN hvis man bruger denne metode. Hvis man derimod bruger den følgende metode må der kun være et parameter!
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     public:
  6.         VoresKlasse(int x)
  7.         {
  8.             std::cout << x << std::endl;
  9.         }
  10. };

  12. int main()
  13. {
  14.     VoresKlasse test = 10;

  16.     return 0;
  17. }
Og husk det nu: Kun ét parameter til den sidste løsning. Når vi kan sige A, må vi også sige B...

2.3  Destruktøren

Destruktøren gør nøjagtig det samme som konstruktøren, dog sættes destruktøren først igang når klassen lukkes ned. Det er ikke muligt at give destruktøren parametre på samme måde som med konstruktøren. Destruktøren har på samme måde som konstruktøren det samme navn som selve klassen, dog starter den med et Bitvis komplement ( ~ ) så i vores situation ville det se således ud ~VoresKlasse().
  1. #include <iostream>
  2.   
  3. class VoresKlasse
  4. {
  5.     public:
  6.         ~VoresKlasse()
  7.         {
  8.             std::cout << "Så lukker og slukker vi!" << std::endl;
  9.         }
  10. };

  12. int main()
  13. {
  14.     VoresKlasse test;

  16.     return 0;
  17. }
Det ligner næsten alt det andet vi har kigget på, så jeg vil ikke rigtigt sige andet om det. Man skal huske at destruktøren først lukker når klassen ikke skal bruges mere, så i dette tilfælde lukker klassen ned lige før at returtypen sættes ind. Der er ikke rigtigt mere at sige om destruktøren, så her slutter vi så.

2.4  Et lille program

Nu burde I efterhånden have nogenlunde styr på klasserne og hvordan de fungerer. Her i slutningen af dette kapitel vil jeg slutte af med et lille eksempel, som både gør brug af hvad vi har gennemgået: public, private, konstruktøren og destruktøren. I eksemplet indsætter jeg en konstruktør og destruktør med tekster samt tekster i funktionerne, så I kan se hvordan at klassen er opbygget og løber. Selve hovedfunktionen plusser 2 tal sammen hvorefter man kan hente dem med en anden funktion.
  1. #include <iostream>

  3. class VoresKlasse
  4. {
  5.     private:
  6.          // Privat variabel, kan kun bruges af klassen
  7.         int Resultat;
  8.     public:
  9.          // Vores konstruktør
  10.         VoresKlasse()
  11.         {
  12.             std::cout << "   *** VoresKlasse() ***   " << std::endl;
  13.             std::cout << "Saa aabner vi." << std::endl << std::endl;
  14.         }    
  15.         
  16.          // Her henter vi tallene
  17.         void SaetTal(int Tal1, int Tal2)
  18.         {
  19.             std::cout << "   *** SaetTal() ***   " << std::endl;
  20.             std::cout << "1: " << Tal1 << " - 2: " << Tal2 << std::endl << std::endl;
  21.             Resultat = Tal1 + Tal2;
  22.         }
  23.         
  24.          // Her udskriver vi resultatet af de to tal plusset
  25.         void HentTal()
  26.         {
  27.             std::cout << "   *** HentTal() ***   " << std::endl;
  28.             std::cout << Resultat << std::endl << std::endl;
  29.         }
  30.         
  31.          // Vores destruktør
  32.         ~VoresKlasse()
  33.         {
  34.             std::cout << "   *** ~VoresKlasse() ***   " << std::endl;
  35.             std::cout << "Saa lukker vi ned." << std::endl;
  36.         }    
  37. };

  39. int main()
  40. {
  41.     VoresKlasse test;
  42.     
  43.     test.SaetTal(10, 20);
  44.     test.HentTal();
  45.     
  46.     return 0;
  47. }
Håber I har fået et indblik i hvordan klasser fungerer. Før I hopper til næste kapitel skulle I måske prøve at lege rundt lidt med det hele, og når du så er klar går du bare videre.

3.0  Static, const, ...

Her i det sidste kapitel omhandlende klasser vil jeg fortælle lidt om de lidt mere advancerede ting. Af ting jeg vil fremhæve er static, const, mutable og This. Static bruges til at holde ting statiske. Const kender du muligvis hvis du har lidt erfaring med C og C++. Det bruges selvfølgelig til at gøre en hel funktion constant, så den ikke kan bruges til at ændre eksempelvis andre variabler. Hvis man har problemer med en funktion som er const, er der heldigvis en løsning, mutable, den bruges til at kunne lade en variabel i en const ændre. Lige før vi tager fat i This, skal vi snakke lidt om inline, som er en mindre vigtig del, men alligevel god at kende. Til sidst, en vigtig del af klasser, This-pointeren. This peger på objektet selv, mere om det i selve kapitlet.

3.1  static

Ved brug af static vil alle objekter have det samme. Normalt hvis man oprettede et objekt, test1, og plusede X med én, så ville den gå på nul igen hvis man oprettede et nyt objekt, test2. Men ved brug af static ville den fortsætte med at tælle i test2, så den ville komme op på 2, istedet for kun 1. Lad os lave et eksempel hvor man i konstruktøren tæller en op. Vi bruger selvfølgelig lige en static int-variabel, x. Læg mærke til hvordan den skal implementeres i forhold til klassen.
  1. #include <iostream>

  3. class VoresKlasse
  4. {
  5.     private:
  6.         static int x;
  7.     public:
  8.         VoresKlasse()
  9.         {
  10.             std::cout << ++x << std::endl;
  11.         }
  12. };        

  14. int VoresKlasse::x; // Her implementeres den

  16. int main()
  17. {
  18.     VoresKlasse test1;
  19.     VoresKlasse test2;
  20.     
  21.     return 0;        
  22. }
Prøv selv at leg lidt med static variablen, prøv evt. på long, double, måske funktioner?

3.2  const

Når en funktion i en klasse er const bliver den for det meste brugt til enten returværdier eller at udskrive. I en const funktion kan man ikke ændre variabler. Hvis man prøver at ændre en variabel i const-funktion vil din kompiler komme med fejl, eller en advarsel. Modsat variabler af const, så skal const sættes efter funktionens navn og parameter-liste.
  • returType funktionsNavn(parameter-liste) const
Jeg har valgt ikke at lave et eksempel da det ville være unødvendigt da det kun er nøgleordet ( keyword ), const, der som sagt bliver sat ind. Nu skal du bare huske at i const-funktionen kan du ikke ændre på en variabel overhovedet. Eller der er en mulighed, men den ser vi nærmere på i næste kapitel. Så i en const-funktion vil du ikke kunne gøre ting som:
  1. // Inde i const-funktion
  2. x++; // Fejl
  3. ++x; // Fejl
  4. x = 10; // Fejl
Altså der ville komme fejl på alle de måder der kan tildeles variabler på. Det er derimod helt okay både at udskrive, modtage input, returnere og lignende.
  1. // Inde i const-funktion
  2. std::cout << x << std::endl; // Okay
  3. std::cin >> x; // Okay
  4. return 100; // Okay
Som sagt er det muligt at gøre så en variabel kan ændres i en klasse, og det vil vi nu se nærmere på.

3.3  mutable

Med nøgleordet mutable kan man sætte en variabel i en klasse til godt at kunne blive ændret gennem en const-funktion. Der er egentligt ikke meget at sige om mutable, så i stedet vil jeg komme med et eksempel.
  1.  #include <iostream>

  3. class VoresKlasse
  4. {
  5.     private:
  6.         mutable int x;
  7.         // int y;
  8.     public:
  9.         void Saet() const
  10.         {
  11.             x = 10; // Jeps, x er mutable
  12.             // y = 10; // Fejl, y er ikke mutable
  13.         }
  14.         
  15.         void Hent() const
  16.         {
  17.             std::cout << x << std::endl;
  18.         }        
  19. };

  21. int main()
  22. {
  23.     VoresKlasse test;
  24.     
  25.     test.Saet();
  26.     test.Hent();
  27.     
  28.     return 0;
  29. } 
I eksemplet har jeg "ladet som om" at jeg initaliserede y, men det er kun gjort i kommentarer. Prøv evt. at fjerne kommentarerne og se hvad der sker med y. Der vil nemlig forekomme fejl da den jo ikke er sat til mutable og prøver at blive ændret i const.

3.4  inline

Inline funktioner bliver egentligt ikke brugt så meget mere, men er stadigvæk en, til tider, stor del af klasser. I C-tiden var inline en vigtig del da det speedede programmet op. Nu om dage er kompilerne blevet så gode at man egentligt ikke rigtigt har brug for nøgleordet inline mere. Dog gør det en lille forskel, og derfor har den også fået en lille plads her i min artikel. Inline skal ikke bruges til store funktioner, men mest bare til små funktioner som bliver brugt ofte og evt. kun udskriver en værdi eller returnerne en værdi. Inline bruges ikke kun i klasser, som du muligvis ved hvis du har lidt erfaring med C/C++ generelt. Det kan sagten bruges uden for klasser på helt normale funktioner. Inline-nøgleordet bliver sat lige før funktionens returtype, og derefter kører det bare derudaf. Jeg ville egentligt ikke have lavet et eksempel til denne sektion, men synes alligevel lige at I skulle have et eksempel med, så I kan se hvordan det f.eks. kan blive brugt.
  1. #include <iostream>

  3. class VoresKlasse
  4. {
  5.     public:
  6.         inline int PlusFunktion(int x, int y)
  7.         {
  8.             return x+y;
  9.         }    
  10. };

  12. int main()
  13. {
  14.     VoresKlasse test;
  15.     int Resultat;
  16.     
  17.     for(int i = 0, j = 0; i <= 10, j <= 20; i++, j += 2)
  18.     {
  19.         Resultat = test.PlusFunktion(i, j);
  20.         std::cout << Resultat << std::endl;
  21.     }    
  22.     
  23.     return 0;
  24. } 
Som I kan se bliver der kaldt, ialt 10 gange til funktionen, og da funktionen er lille er det optimalt at give den inline-nøgleordet, nøjagtigt som vi har gjort. Resten af programmet er jo som et normalt C++-program, så det er der ingen ben i.

3.5  This-pointeren

This-pointeren kan godt være lidt tricky, så hvis du ikke har nogenlunde styr på pointers er dette kapitel ikke lige for dig. This-pointeren er en pointer der peger på selve objektet selv. Det ville være nogenlunde det samme hvis man gjorde sådan her:
  • Objektet *var;
Men dog ikke helt. This kan bruges på to forskellige måder, enten ved brug af indirect ( -> ) eller ved brug af den gamle metode ( (* ) ). Jeg foretrækker personligt selv indirect, da det er nemmere at finde ud af og ser også bedre ud. Men i bund og grund er det en smagssag, så du må bruge hvad du føler er bedst. Som sagt peger This på objektet selv og holder altså kun styr på objektets variabler, funktioner og hvad der nu ellers er i sådan en klasse. Det vil sige at man kan bruge 2 variabler ved samme navn med This. Det ville man ikke normalt kunne. Jeg vil vise jer 2 eksempler hvor det første eksempel IKKE virker, men skal forestille et "problem" som vi så løser i det andet eksempel. I andet eksempel gør jeg brug af indirect og til sidst vil jeg vise jer hvordan man bruger det såkaldte "gamle" look.
  1. /////////////////////////////////
  2. // Dette program virker ikke!  //
  3. /////////////////////////////////

  5. #include <iostream>

  7. class VoresKlasse
  8. {
  9.     private:
  10.         int x;
  11.         int y;
  12.     public:
  13.         void Saet(int x, int y)
  14.         {
  15.             x = x; // Her forekommer den første fejl,
  16.             y = y; // og her den anden.
  17.         }    
  18.         
  19.         void Hent()
  20.         {
  21.             std::cout << x << std::endl;
  22.             std::cout << y << std::endl;
  23.         }
  24. };

  26. int main()
  27. {
  28.     VoresKlasse test;
  29.     
  30.     test.Saet(10, 20);
  31.     test.Hent();
  32.     
  33.     return 0;
  34. } 
Prøv så at kompilerer programmet, enten vil det ikke kompilerer eller også vil det udskrive forkerte tal. Det er netop fordi at i funktionen Saet kan den ikke finde ud af hvilken x der skal modtage og hvilken der skal hentes fra. Det er netop i et eksempel som dette at This-pointeren kommer til.
  1. #include <iostream>

  3. class VoresKlasse
  4. {
  5.     private:
  6.         int x;
  7.         int y;
  8.     public:
  9.         void Saet(int x, int y)
  10.         {
  11.             this->x = x; // Så fungerer det her,
  12.             this->y = y; // og her.
  13.         }    
  14.         
  15.         void Hent()
  16.         {
  17.             std::cout << this->x << std::endl;
  18.             std::cout << this->y << std::endl;
  19.         }
  20. };

  22. int main()
  23. {
  24.     VoresKlasse test;
  25.     
  26.     test.Saet(10, 20);
  27.     test.Hent();
  28.     
  29.     return 0;
  30. } 
Så fik vi brugt This med indirect. I kan se at den nu kan finde ud af hvilke der skal modtage værdi, altså objektet"s variabler. I funktionen Hent behøver man ikke This, da den godt ved at den skal tage fra objektet, men jeg har alligevel gjort det for en ordens skyld. Hvis man vil bruge det "gamle" look, som jeg kalder det, skal du simpelt nok bare udskifte this-> med (*this). husk punktummet til sidst, det er ligesom når man tilgår funktioner i klasser fra main, som vi efterhånden har set et par gange.

4.0  Her til slut...

...vil jeg sige, at jeg håber I har nydt artiklen, lige så meget som jeg har nydt at skrive den. Måske mener I at der mangler noget i artiklen, men jeg har valgt at tage med hvad jeg synes er relevant at have med i en artikel for nybegynderer til klasser. Til dem som ønsker at gå videre, kan vente på at jeg (måske?) skriver endnu en artikel eller at finde en af de mange tutorials på nettet. Af ting som jeg bl.a. ikke har fremhævet i denne artikel, kan nævnes: polymorfi, arv, virtual, friends, overloading, templates m/ klasser, abstrakte klasser, multiple arv, indkapsling og meget meget mere, så der er masser at gå igang med. Hvis I skulle have noget kritik, så gør det konstruktivt og ikke, "Fucking lorte artikel, jeg hader dig".

Igen, håber I har nydt artiklen.
Hyg jer derude!
Sidst redigeret 13:52 04/06/2007 af Rowl
Oprettet af:
v0id

C/C++

Point modtaget: 0

Rate:
18:43 04/09/2006

Kommentarer

Giv din mening tilkende om denne artikel, eller læs andres.
Har du spørgsmål eller brug for hjælp til denne artikel henvises du til forummet.
Fuuuck en god artikel.. Men det forklare jo ikk alt om C++.
Det kræver jo flere års træning
Oprettet af:
Ukendt bruger
  Mail
17:54 24/12/2006
En anden ting er at du ikk helt forklare de enkelte ting.
Oprettet af:
Ukendt bruger
  Mail
18:00 24/12/2006
Men det forklare jo ikk alt om C++.
Det kræver jo flere års træning
Denne artikel fortæller kun om en brøkdel af C++"s funktionalitet. Hvis du vil vide mere, må du ud og læse nogle bøger, tutorials eller hvad du nu finder på. Denne artikel handlede udelukkende om OOP. Dog er ikke alt indenfor OOP forklaret, som der også nævnes i artiklen.

En anden ting er at du ikk helt forklare de enkelte ting.
Kan du prøve at uddybe det lidt?
Jeg har svært ved at kunne ændre det til en anden gang, hvis jeg ikke ved hvad det er jeg gør galt. :-)
Oprettet af:
v0id
  Mail
17:58 10/01/2007
Den er fin Der er en del komma-fejl, men det er bare det gramatiske. Jeg læste ikke det hele igennem, men skimmede den hurtigt.
Sidst redigeret 15:12 - 16/01/2007
Oprettet af:
Ukendt bruger
  Mail
09:12 16/01/2007
v0id > Jeg laver en smule Win32 API men det er dog ikke meget, og slet ikke med klasser... Synes det utroligt hurtigt bliver utroligt avanceret - og som du selv siger, uoverskueligt - så har holdt mig lidt på måtten indtil videre.

Ukendt forfatter > Drop det der. For det første kræver artiklen ikke flere års erfaring, for det andet opretter du 2 temmeligt tåbelige kommentarer. Hvad mener du med at han ikke helt forklarer de enkle ting? Ved du overhovedet hvad programmering er? Eller hvad en computer er, for den sags skyld?
Oprettet af:
deXo-fan
  Mail
20:37 16/01/2007
v0id> Pinligt, det er først nu jeg ser dit inline eksempel. Må have sovet I)
Oprettet af:
deXo-fan
  Mail
13:01 30/01/2007
Jeg har et spørgsmål:

Hvornår bruger man pointer operatøren (ved ikke hvad den hedder, men test->something), og hvornår bruger man dot operatøren? (.)
Oprettet af:
TheOliver
  Mail
10:53 22/01/2011
Forrige
Side af 2
Du skal være oprettet og logget ind for at kommentere en artikel
Copyright © Rowl.dk v/ Michael Raagaard | 2005-12 | Alle rettigheder forbeholdes