Bevezetés a C ++ osztályokba és objektumokba

tárgyak a legnagyobb különbség a C ++ és a C között. A C ++ egyik legkorábbi neve a C osztályokkal volt.

Az osztály egy objektum meghatározása. Ez egy típus, akárcsak int. Egy osztály a struct csak egy különbséggel: alapértelmezés szerint az összes tag tag nyilvános. Minden osztály tagja magán.

Ne feledje: egy osztály egy típus, és ennek az osztálynak egy tárgya csak egy változó.

Mielőtt használhatnánk egy objektumot, létre kell hoznunk. Az osztály legegyszerűbb meghatározása:

 osztály név {

 // tagok

 }

Az alábbi példaosztály egy egyszerű könyvet modellez. Az OOP használata lehetővé teszi a probléma elvont és gondolkodását, és nem csupán az önkényes változókat.

 // 1. példa

 #include 

 #include 

 osztálykönyv

 {

 int PageCount;

 int CurrentPage; 

 nyilvános:

 Könyv (int. Számok); // Kivitelező

 ~ Book () {}; // Pusztító

 érvénytelen SetPage (int PageNumber);

 int GetCurrentPage (érvénytelen);

 }; 

 Könyv:: Könyv (int NumPages) {

 PageCount = NumPages;

 }

 érvénytelen könyv:: SetPage (oldalszám száma) {

 CurrentPage = PAGENUMBER;

 }

 int könyv:: GetCurrentPage (érvénytelen) {

 visszatérő CurrentPage;

 }

 int main () {

 ABook könyv (128);

 Könyv. SetPage (56);

 std:: cout << "Aktuális oldal" <
 visszatérés 0;

 }

Az összes kód osztálykönyv le a int könyv:: GetCurrentPage (érvénytelen) { A funkció az osztály része. Az fő() a funkció az, hogy ez futtatható alkalmazás legyen.

Ban,-ben fő() Funkcióhoz létrejön egy Book típusú típusú ABook változó 128 értékkel. Amint a végrehajtás eléri ezt a pontot, az ABook objektum felépítésre kerül. A következő sorban a módszer Könyv. SetPage () hívják, és az objektumváltozóhoz 56 értéket rendelnek Könyv. Aktuális oldal. Azután cout ezt az értéket adja ki a Könyv. GetCurrentPage () eljárás.

Amikor a végrehajtás eléri a visszatérés 0; az ABook objektumra az alkalmazásnak már nincs szüksége. A fordító hívást generál a pusztítóhoz.

Minden között Osztálykönyv és a } az osztálynyilatkozat. Az osztálynak két magántagja van, mindkettő int. Ezek privát, mivel az osztály tagjaihoz alapértelmezett hozzáférés van privát.

Az nyilvános: irányelv azt mondja: fordítóprogram hogy az innen elérhető hozzáférés nyilvános. Ennek hiányában ez továbbra is privát, és megakadályozza a main () függvény három sorának elérését az Abook tagokhoz. Próbáljon megjegyzést fűzni a nyilvános: vonja össze és újrafordítsa a következő fordítási hibákat.

Az alábbi sor egy kivitelezőt jelöl. Ez az az objektum első létrehozásakor hívott függvény.

 Könyv (int. Számok); // Kivitelező 

A vonaltól hívják

 ABook könyv (128); 

Ez létrehoz egy ABook típusú könyv nevû objektumot, és meghívja a Book () függvényt a paraméter 128.

A C ++ esetén a konstruktornak mindig ugyanaz a neve, mint az osztálynak. Az építő hívja az objektum létrehozásakor, és oda kell helyeznie a kódot az objektum inicializálásához.

A könyvben A következő sor a kivitelező után a pusztító. Ennek ugyanaz a neve, mint a konstruktornak, de ~ (tilde) előtte van. Egy objektum megsemmisítése során a pusztítót fel kell hívni az objektum megtisztítására és annak biztosítására, hogy az objektum által használt erőforrások, például a memória és a fájlkezelő felszabaduljanak.

Emlékezik—A xyz osztály rendelkezik xyz () és destructor ~ xyz () konstruktorfüggvénnyel. Még ha nem is deklarálja, a fordító csendesen hozzáadja őket.

A pusztítót mindig hívják, amikor az objektum megszűnik. Ebben a példában az objektumot implicit módon megsemmisítik, amikor kizárja a hatókört. Ennek megtekintéséhez módosítsa a pusztító nyilatkozatát erre:

 ~ Book () {std:: cout << "A pusztító neve";}; // Pusztító 

Ez egy inline függvény, amelynek kódja van a nyilatkozatban. A beillesztés másik módja a szó beillesztése

 inline ~ könyv (); // Pusztító

és adjuk hozzá a pusztítót ehhez hasonló függvényként.

 inline Book:: ~ Book (érvénytelen) { 

 std:: cout << "Meghívott pusztító";

 }

Az inline funkciók a hatékonyabb kód előállítása érdekében a fordítónak mutatnak tippeket. Csak kisméretű funkciókhoz szabad felhasználni, de megfelelő helyen - például belül hurkok- jelentős teljesítménybeli változást eredményezhet.

Legjobb gyakorlat az objektumok számára az az, hogy az összes adatot privátvá tegyék, és hozzáférési funkcióknak nevezett funkciókkal férjen hozzá hozzá. SetPage () és GetCurrentPage () az objektumváltozó eléréséhez használt két függvény Aktuális oldal.

Változtasd meg a osztály nyilatkozat szerkesztésről és újrafordításról. Ennek továbbra is le kell fordulnia és helyesen kell futnia. Most a két változó PageCount és Aktuális oldal nyilvánosan hozzáférhetők. Adja hozzá ezt a sort a Book ABook (128) után, és lefordul.

 Könyv. PageCount = 9;

Ha a structot visszaváltja a osztály és fordítsa újra, hogy az új sor már nem fordul el PageCount most újra privát.

A Book Class deklaráció törzse után a tagfunkciók négy meghatározása található. Mindegyiket a Book:: előtaggal határozzuk meg, hogy azonosítsuk az adott osztályba tartozóval.:: Hatókör-azonosítónak nevezzük. A funkciót az osztály részeként azonosítja. Ez nyilvánvaló az osztálynyilatkozatban, de azon kívül nem.

Ha egy tagfüggvényt deklarált egy osztályban, akkor így kell megadnia a függvény törzsét. Ha azt akarta, hogy a Könyv osztályt más fájlok is használják, akkor külön könyvbe helyezheti a könyv nyilatkozatát fejléc fájl, talán könyv.h. Bármely más fájl tartalmazhatja azt

 #include "book.h" 

Ez a példa bemutatja az öröklődést. Ez egy két osztályú alkalmazás, amelynek egyik osztálya egy másikból származik.

 #include 

 #include 

 osztály pont

 {

 int x, y;

 nyilvános:

 Pont (int atx, int aty); // Kivitelező

 inline virtuális ~ pont (); // Pusztító

 virtuális void Draw ();

 }; 

 osztály kör: nyilvános pont {

 int sugár;

 nyilvános:

 Kör (int atx, int aty, int theRadius);

 inline virtuális ~ kör ();

 virtuális void Draw ();

 };

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

 x = atx;

 y = aty;

 }

 inline pont:: ~ pont (érvénytelen) { 

 std:: cout << "Pontpusztító neve";

 }

 void Point:: Döntetlen (érvénytelen) {

 std:: cout << "Pont:: Húzz pontot a" << x << "" << y << std:: endl;

 }

 Kör:: Kör (int atx, int aty, int theRadius): Pont (atx, aty) {

 sugár = theRadius;

 }

 inline Circle:: ~ Circle () {

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

 }

 void Circle:: Draw (void) {

 Pont:: Döntetlen ();

 std:: cout << "kör:: Rajzolási pont" << "Sugár" << sugár << std:: endl;

 }

 int main () {

 Circle ACircle (10,10,5);

 Egy kör. Húz() ;

 visszatérés 0;

 }

A példa két osztályt tartalmaz, a pontot és a kört, amelyek egy pontot és egy kört modelleznek. Egy pont x és y koordinátáival rendelkezik. A Kör osztály a Pont osztályból származik, és hozzáad egy sugarat. Mindkét osztályba tartozik a Húz() tag funkció. Ahhoz, hogy ez a példa rövid legyen, a kimenet csak szöveg.

Osztály Kör származik a Pont osztály. Ez a következő sorban történik:

 osztály kör: pont {

Mivel egy alap osztályból (pontból) származik, a Circle az osztály minden tagját örökli.

 Pont (int atx, int aty); // Kivitelező

 inline virtuális ~ pont (); // Pusztító

 virtuális void Draw ();

 Kör (int atx, int aty, int theRadius);

 inline virtuális ~ kör ();

 virtuális void Draw ();

Gondolj a Kör osztályra, mint egy Pont osztályra egy extra elemmel (sugár). Ez örökli az alaposztály tagfüggvényeit és a magánváltozókat x és y.

Ezeket nem oszthatja ki és nem használhatja, kivéve implicit módon, mert privát jellegűek, tehát a Circle konstruktor Initializer listáján keresztül kell megtennie. Ez olyasvalami, amelyet mostanában el kell fogadnia. Visszajövök az inicializáló listákhoz egy későbbi bemutatóban.

A Körgyártóban, korábban theRadius hozzá van rendelve a sugár, a Circle Point részét az inicializáló listában lévő Point konstruktorának való hívás útján építik fel. Ez a lista a következők és az {alábbiak között található.

 Kör:: Kör (int atx, int aty, int theRadius): Pont (atx, aty) 

Mellesleg, a konstruktor típusának inicializálása minden beépített típushoz használható.

 int a1 (10);

 int a2 = 10;

Mindkettő ugyanazt teszi.

A polimorfizmus egy általános kifejezés, amely "sok formát" jelent. A C ++ esetében a polimorfizmus legegyszerűbb formája a funkciók túlterhelése. Például számos funkciót hívtak SortArray (arraytype) ahol a sortarray lehet sor inta vagy páros.

Itt azonban csak a polimorfizmus OOP formája érdekli. Ez egy függvény létrehozásával történik (pl. Draw ()) tényleges az alap osztály pontjában, majd felülírja azt a származtatott osztály Kör.

Bár a funkció Húz() virtuális a származtatott osztályban Kör, erre valójában nincs szükség - csupán emlékeztető számomra, hogy ez virtuális. Ha a származtatott osztály függvénye megegyezik egy alap- és virtuális függvénnyel a név- és paramétertípusoknál, akkor automatikusan virtuális lesz.

Pont és egy kör rajzolása két nagyon különféle művelet, csak a pont és a kör koordinátáival közös, ezért fontos, hogy a helyes Húz() nak, nek hívják. A későbbi oktatóanyag ismerteti, hogy a fordító hogyan képes létrehozni a megfelelő virtuális funkciót elérő kódot.

A kivitelező egy olyan funkció, amely inicializálja az objektum tagjait. Az építő csak azt tudja, hogyan lehet saját osztályba tartozó objektumot felépíteni.

A konstruktorok nem öröklik automatikusan az alap és a származtatott osztályok között. Ha nem ad meg egyet a származtatott osztályban, akkor alapértelmezés lesz megadva, de ez nem biztos, hogy megteszi azt, amit akar.

Ha nem szállít konstruktort, akkor a fordító alapértelmezett értéket hoz létre paraméterek nélkül. Mindig konstruktornak kell lennie, még akkor is, ha ez az alapértelmezett és üres. Ha paramétereket ad meg egy konstruktornak, akkor az alapértelmezés nem jön létre.

Néhány pont a konstruktorokról:

• A konstruktorok csak olyan funkciók, amelyek ugyanazon a néven vannak, mint az osztály.
• A konstruktorok célja az osztály tagjai inicializálása, amikor az osztály példánya létrejön.
• Az építőket nem hívják közvetlenül (kivéve az inicializáló listákat)
• A konstruktorok soha nem virtuálisak.
• Ugyanazon osztályhoz több konstruktor is definiálható. Különböző paraméterekkel kell rendelkezniük a megkülönböztetéshez.

Sokkal többet lehet megtanulni a konstruktorokról, például az alapértelmezett konstruktorokról, a hozzárendelésről és a másolási konstruktorokról. Ezeket a következő leckében tárgyaljuk.

A pusztító olyan osztálytag-függvény, amelynek ugyanaz a neve, mint a konstruktornak (és az osztálynak), de ~ (tilde) előtt van.

 ~ Kör ();

Ha egy objektum elhagyja a hatókört vagy ritkábban kifejezetten elpusztul, akkor annak pusztítóját hívják. Például, ha az objektumnak olyan dinamikus változói vannak, mint például mutatók, akkor ezeket meg kell engedni, és a pusztító a megfelelő hely.

A konstruktorokkal ellentétben a destruktorok virtuálissá válhatnak és kell is, ha származtatott osztályokból áll. Ban,-ben Pont és Kör osztályok példája, a pusztítóra nincs szükség, mivel nincs elvégzendő tisztítási munka (csak példaként szolgál). Ha voltak dinamikus tagváltozatok (például mutatók), akkor azoknak meg kellett volna szabadulniuk a memóriaszivárgások megakadályozása érdekében.

Továbbá, ha a származtatott osztály hozzáadja tagokat, amelyek megkövetelik a tisztítást, akkor virtuális destruktúrákra van szükség. Amikor virtuális, akkor a leginkább származtatott osztálypusztítót hívják először, majd a közvetlen őse pusztítóját hívják, és így tovább az alaposztályig.

Példánkban

 ~ Kör ();

azután

 ~ Pont ();

Az alap osztályok pusztítóját utoljára hívják.

Ez befejezi ezt a leckét. A következő leckében megismerheti az alapértelmezett építőket, a másoló építőket és a hozzárendelést.