Inleiding tot C ++ -klassen en -objecten

Voorwerpen zijn het grootste verschil tussen C ++ en C. Een van de vroegste namen voor C ++ was C met klassen.

Een klasse is een definitie van een object. Het is een type zoals int. Een klas lijkt op een struct met slechts één verschil: alle struct-leden zijn standaard openbaar. Alle klassenleden zijn privé.

Onthoud: een klasse is een type en een object van deze klasse is slechts een variabel.

Voordat we een object kunnen gebruiken, moet het worden gemaakt. De eenvoudigste definitie van een klasse is:

 naam van de klasse {

 // leden

 }

Deze voorbeeldklasse hieronder modelleert een eenvoudig boek. Met OOP kunt u het probleem abstract maken en erover nadenken en niet alleen willekeurige variabelen.

 // voorbeeld één

 # opnemen 

 # opnemen 

 klasboek

 {

 int PageCount;

 int Huidige pagina; 

 openbaar:

 Boek (int Numpages); // Constructor

 ~ Book () {}; // Vernietiger

 void SetPage (int PageNumber);

 int GetCurrentPage (nietig);

 }; 

 Boek:: Boek (int NumPages) {

 PageCount = NumPages;

 }

 void Book:: SetPage (int PageNumber) {

 CurrentPage = PageNumber;

 }

 int Book:: GetCurrentPage (void) {

 geef CurrentPage terug;

 }

 int main () {

 Boek ABook (128);

 Een boek. SetPage (56);

 std:: cout << "Huidige pagina" << ABook. GetCurrentPage () << std:: endl;

 terugkeer 0;

 }

Alle code van klasboek tot aan de int Book:: GetCurrentPage (void) { functie maakt deel uit van de klas. De hoofd() functie is er om dit een uitvoerbare applicatie te maken.

In de hoofd() functie wordt een variabele A van het type Boek gemaakt met de waarde 128. Zodra de uitvoering dit punt bereikt, wordt het object ABook geconstrueerd. Op de volgende regel de methode Een boek. Zet pagina() wordt aangeroepen en de waarde 56 wordt toegewezen aan de objectvariabele Een boek. Huidige pagina. Vervolgens Cout voert deze waarde uit door de aan te roepen Een boek. GetCurrentPage () methode.

Wanneer de uitvoering de bereikt terugkeer 0; het ABook-object is niet langer nodig door de toepassing. De compiler genereert een oproep naar de destructor.

Alles tussen Klasboek en de } is de klasseverklaring. Deze klasse heeft twee privéleden, beide van het type int. Dit zijn privé, omdat de standaardtoegang voor groepsleden privé is.

De openbaar: richtlijn vertelt de compiler die vanaf nu toegankelijk is. Zonder dit zou het nog steeds privé zijn en voorkomen dat de drie regels in de main () -functie toegang krijgen tot Abook-leden. Probeer commentaar te geven op de openbaar: line-out en opnieuw compileren om de compileerfouten te zien.

Deze regel hieronder verklaart een constructor. Dit is de functie die wordt genoemd wanneer het object voor het eerst wordt gemaakt.

 Boek (int Numpages); // Constructor 

Het wordt vanaf de lijn genoemd

 Boek ABook (128); 

Dit maakt een object met de naam ABook van het type Book en roept de functie Book () aan met de parameter 128.

In C ++ heeft de constructor altijd dezelfde naam als de klasse. De constructor wordt aangeroepen wanneer het object wordt gemaakt en hier moet u uw code plaatsen om het object te initialiseren.

In boek De volgende regel na de constructor de destructor. Dit heeft dezelfde naam als de constructor, maar met een ~ (tilde) ervoor. Tijdens de vernietiging van een object wordt de destructor opgeroepen om het object op te ruimen en ervoor te zorgen dat bronnen zoals geheugen en bestandsingang die door het object worden gebruikt, worden vrijgegeven.

Onthouden—Een klasse xyz heeft een constructorfunctie xyz () en destructorfunctie ~ xyz (). Zelfs als u niet aangeeft, voegt de compiler ze stil toe.

De destructor wordt altijd aangeroepen wanneer het object wordt beëindigd. In dit voorbeeld wordt het object impliciet vernietigd als het buiten bereik valt. Om dit te zien, wijzigt u de vernietigingsverklaring hierin:

 ~ Book () {std:: cout << "Destructor genaamd";}; // Vernietiger 

Dit is een inline-functie met code in de aangifte. Een andere manier om inline te plaatsen is door het woord inline toe te voegen

 inline ~ Book (); // Vernietiger

en voeg de destructor toe als een functie als deze.

 inline Book:: ~ Book (void) { 

 std:: cout << "Destructor genaamd";

 }

Inline-functies zijn hints voor de compiler om efficiëntere code te genereren. Ze mogen alleen worden gebruikt voor kleine functies, maar als ze op geschikte plaatsen worden gebruikt, zoals binnen lussen—Kan een aanzienlijk verschil maken in prestaties.

Beste oefening voor objecten is om alle gegevens privé te maken en er toegang toe te krijgen via functies die accessor-functies worden genoemd. Zet pagina() en GetCurrentPage () zijn de twee functies die worden gebruikt om toegang te krijgen tot de objectvariabele Huidige pagina.

Verander de klasse verklaring om te structureren en opnieuw te compileren. Het moet nog steeds compileren en correct worden uitgevoerd. Nu de twee variabelen Paginanummer en Huidige pagina zijn publiek toegankelijk. Voeg deze regel toe na het Boek ABook (128) en het zal compileren.

 Een boek. PageCount = 9;

Als je struct terug verandert in klasse en opnieuw compileren, zal die nieuwe regel niet langer compileren als Paginanummer is nu weer privé.

Na de body of Book Class-verklaring zijn er de vier definities van de lidfuncties. Elk wordt gedefinieerd met het voorvoegsel Book:: om aan te geven dat het tot die klasse behoort.:: wordt het bereik-ID genoemd. Het identificeert de functie als onderdeel van de klasse. Dit is duidelijk in de klasseverklaring maar niet daarbuiten.

Als u een lidfunctie in een klasse hebt verklaard, moet u het hoofdgedeelte van de functie op deze manier opgeven. Als u de klasse Book door andere bestanden wilt laten gebruiken, kunt u de boekdeclaratie naar een andere verplaatsen koptekst bestand, misschien book.h. Elk ander bestand zou het dan kunnen opnemen met

 # include "book.h" 

Dit voorbeeld zal overerving aantonen. Dit is een tweeklasse-applicatie waarvan de ene klasse is afgeleid van een andere.

 # opnemen 

 # opnemen 

 Class Point

 {

 int x, y;

 openbaar:

 Punt (int atx, int aty); // Constructor

 inline virtueel ~ Point (); // Vernietiger

 virtuele ongeldige Draw ();

 }; 

 class Circle: public Point {

 int straal;

 openbaar:

 Cirkel (int atx, int aty, int theRadius);

 inline virtuele ~ Circle ();

 virtuele ongeldige Draw ();

 };

 Point:: Point (int atx, int aty) {

 x = atx;

 y = aty;

 }

 inline Point:: ~ Point (void) { 

 std:: cout << "Point Destructor genaamd";

 }

 void Point:: Draw (void) {

 std:: cout << "Punt:: Teken punt op" << x << "" << y << std:: endl;

 }

 Circle:: Circle (int atx, int aty, int theRadius): Point (atx, aty) {

 radius = theRadius;

 }

 inline Circle:: ~ Circle () {

 std:: cout << "Circle Destructor genaamd" << std:: endl;

 }

 void Circle:: Draw (void) {

 Point:: Draw ();

 std:: cout << "cirkel:: Teken punt" << "Radius" << radius << std:: endl;

 }

 int main () {

 Cirkel ACircle (10,10,5);

 Een cirkel. Draw ();

 terugkeer 0;

 }

Het voorbeeld heeft twee klassen, Punt en Cirkel, die een punt en een cirkel modelleren. Een punt heeft x- en y-coördinaten. De klasse Circle is afgeleid van de klasse Point en voegt een straal toe. Beide klassen omvatten een Trek() lid functie. Om dit voorbeeld kort te houden, is de uitvoer alleen tekst.

De klas Cirkel is afgeleid van de Punt klasse. Dit gebeurt op deze regel:

 klasse Circle: Point {

Omdat het is afgeleid van een basisklasse (punt), neemt Circle alle groepsleden over.

 Punt (int atx, int aty); // Constructor

 inline virtueel ~ Point (); // Vernietiger

 virtuele ongeldige Draw ();

 Cirkel (int atx, int aty, int theRadius);

 inline virtuele ~ Circle ();

 virtuele ongeldige Draw ();

Zie de klasse Circle als de klasse Point met een extra lid (straal). Het neemt de Member-functies van de basisklasse en privévariabelen over X en y.

Het kan deze alleen toewijzen of gebruiken behalve impliciet omdat ze privé zijn, dus moet het dit doen via de lijst Initializer van de Circle-constructor. Dit is iets dat je moet accepteren zoals het nu is. Ik kom terug naar initialisatielijsten in een toekomstige zelfstudie.

Voorheen in de Circle Constructor theRadius is toegewezen aan de straal, wordt het puntgedeelte van de cirkel opgebouwd via een aanroep van de constructor van Point in de initialisatielijst. Deze lijst bevat alles tussen de: en de {hieronder.

 Cirkel:: Cirkel (int atx, int aty, int theRadius): Point (atx, aty) 

Overigens kan initialisatie van het constructortype worden gebruikt voor alle ingebouwde typen.

 int al (10);

 int a2 = 10;

Beide doen hetzelfde.

Polymorfisme is een generieke term die "vele vormen" betekent. In C ++ is de eenvoudigste vorm van polymorfisme het overbelasten van functies. Bijvoorbeeld verschillende functies genoemd SortArray (arraytype) waar sortarray misschien een is array van ints of verdubbelt.

We zijn hier echter alleen geïnteresseerd in de OOP-vorm van polymorfisme. Dit wordt gedaan door een functie te maken (bijvoorbeeld Draw ()) virtueel in de basisklasse Point en vervolgens overschrijven in de afgeleide klasse Cirkel.

Hoewel de functie Trek() is virtueel in de afgeleide klasse Cirkel, dit is eigenlijk niet nodig - het herinnert me eraan dat dit virtueel is. Als de functie in een afgeleide klasse overeenkomt met een virtuele functie in de basisklasse op naam en parametertypen, is deze automatisch virtueel.

Een punt tekenen en een cirkel tekenen zijn twee zeer verschillende bewerkingen met alleen de coördinaten van het punt en de cirkel gemeen, dus het is belangrijk dat de juiste Trek() wordt genoemd. Hoe de compiler code weet te genereren die de juiste virtuele functie krijgt, zal worden behandeld in een toekomstige zelfstudie.

Een constructor is een functie die de leden van een object initialiseert. Een constructeur weet alleen hoe hij een object van zijn eigen klasse moet bouwen.

Constructors worden niet automatisch geërfd tussen de basis- en afgeleide klassen. Als u er geen in de afgeleide klasse opgeeft, wordt er een standaardwaarde opgegeven, maar dit is mogelijk niet wat u wilt.

Als er geen constructor wordt geleverd, wordt er door de compiler een standaard gemaakt zonder parameters. Er moet altijd een constructor zijn, ook al is deze standaard en leeg. Als u een constructor van parameters voorziet, wordt er GEEN standaardwaarde gemaakt.

Enkele punten over constructeurs:

• Constructors zijn slechts functies met dezelfde naam als de klasse.
• Constructors zijn bedoeld om de leden van de klasse te initialiseren wanneer een instantie van die klasse wordt gemaakt.
• Constructors worden niet rechtstreeks aangeroepen (behalve via initialisatielijsten)
• Constructeurs zijn nooit virtueel.
• Er kunnen meerdere constructors voor dezelfde klasse worden gedefinieerd. Ze moeten verschillende parameters hebben om ze te onderscheiden.

Er is nog veel meer te leren over constructors, bijvoorbeeld standaardconstructors, toewijzing en kopieerconstructors. Deze worden in de volgende les besproken.

Een destructor is een klasse-lidfunctie die dezelfde naam heeft als de constructor (en de klasse) maar met een ~ (tilde) ervoor.

 ~ Circle ();

Wanneer een object buiten het bereik valt of, meer zelden, expliciet wordt vernietigd, wordt de vernietiger ervan genoemd. Als het object bijvoorbeeld dynamische variabelen heeft, zoals pointers, dan moeten die worden vrijgegeven en is de destructor de juiste plaats.

In tegenstelling tot constructors kunnen en moeten destructors virtueel worden gemaakt als je afgeleide klassen hebt. In de Punt en Cirkel klassen voorbeeld, de destructor is niet nodig omdat er geen opruimwerkzaamheden moeten worden uitgevoerd (het dient slechts als voorbeeld). Waren er dynamische lidvariabelen geweest (zoals wijzers) dan zouden die moeten zijn vrijgemaakt om geheugenlekken te voorkomen.

Ook wanneer de afgeleide klasse leden toevoegt die moeten worden opgeruimd, zijn virtuele destructors nodig. Als het virtueel is, wordt de meest afgeleide klassevernietiger eerst genoemd, vervolgens wordt de vernietiger van zijn directe voorouder genoemd, enzovoort, tot aan de basisklasse.

In ons voorbeeld

 ~ Circle ();

vervolgens

 ~ Punt ();

De destructor van de basisklassen wordt als laatste genoemd.

Hiermee is deze les voltooid. In de volgende les leert u over standaardconstructors, kopieerconstructors en toewijzing.