Conversion típusmegjelölést, a használata

előző ◈ a következő

Kétféle konverziók: implicit és explicit.

1.Prisvoenie „több típus” a „kevesebb mint”. Biztonságos hozzárendelés biztosítja az állandó értékeket.







unsigned int UnsignedIntVal;

unsigned char UnsignedCharVal;

2.Prisvoenie „kisebb fajta” érték „a magasabb típusú”. Potenciálisan veszélyes feladat, veszélyezteti a adatvesztést.

3.Preobrazovanie értéke a „kisebbik” a „magasabb típusú”. Ez az úgynevezett kiterjesztés típus.

4.Preobrazovanie értékei „nagy betűkkel” a „alsó osztály”. Ez az úgynevezett szűkület típus. Ez egy veszélyes átalakulás.

Helyes végrehajtása akciók különböző típusú értékek biztonságos és néhány esetben veszélyes esetekben biztosítani végrehajtott C ++ típusú átalakító rendszer.

Ha a fordítás a kifejezést különböző típusú operandusok a fordító használja a mechanizmusok implicit konverzió, ami alapján a következő szabályok szokásos transzformációk:

  • Ha értéket objektumot átalakítja ezt az értéket, hogy az objektum típusát.

· Unsigned int MyIntU;

· MyIntU = (unsigned int) 3.14159;

  • Váltó értékeket függvényhívás átalakítja ezt az értéket egy paraméter típusú funkciókat. Ő lesz ismert a prototípust a hívott függvény.

· Void ff (int); // függvény prototípust.

Ebben az esetben a szakaszában fordítás okozhat figyelmeztető szűkület típus.

  • Az aritmetikai kifejezés eredmény típusa a kifejezés határozza meg a „széles” típusú között generátorok expressziós operandusok. Ez a típus az úgynevezett eredmény típusú kifejezés. Ez a típusú átalakított összes fennmaradó operandusok.

· Unsigned int MyIntU = 5;

Eredmény típusú kifejezések itt kettős képviseli a szó szempontból 3.14159. A folyamat során a kiszámításakor a változó értékét expressziós MyIntU alakítjuk 5,0, amelyet hozzáadunk 3.14159.

  • Transzformáció-típus a számtani kifejezések alkalmazott példányban expressziós értékeit alkotó részkifejezésekre. Az átalakítási folyamat eredménye részkifejezésekre típusú átalakulások nincs bekötve.

· Unsigned int MyIntU = 5;

· MyIntU = MyIntU + 3.14159;

Voltak két egymást követő átalakulások:

Ennek során a kifejezés kiértékelésének változó MyIntU kétszeresére bővül és kiterjesztett másolatát érték 5,0 hozzáadjuk 3.14159. Ezt követően, az így kapott érték 8,14159 szerint az első szabály, szűkül unsigned int típusú. Az így kapott érték 8 kapunk, és hozzá van rendelve a változó MyIntU.

· Char * p_chVal = 0;

· Const int * pc_iVal = &iVal;

· // 5. szabály végezzük.

· // Hiba: pc_iVal - mutató, amely egy állandó.

· Const void * pcVal = pc_iVal;

· És itt minden jó! Pointer konstans van rendelve egy mutató egy állandó.

A művelet előtt, dereference void * mutatóban, hogy kifejezetten konvertálni egy mutató egy bizonyos típusú, mint ebben az esetben nincs információ arról, hogy milyen típusú, amely kéri a fordító hogyan kell értelmezni a bitsorozatot képviseli a mutatót:

char * p_chValName = "Marina";

p_chVal = (char *) p_Val; / Öntés *. * /

implicit átváltási mechanizmus lehet kapcsolni pontosan megadják a kívánt típusú szöveges konvertáló program.

Így, módosítása a korábban úgy példa

MyIntU = MyIntU + (int) 3.14159;

letiltja mechanizmus implicit változást és a számítás változó értékét készül, csak egy típusú átalakulás szűkül a típusú karakterlánc értéke 3.14159.

* Ostobán példányt. Írja le magát ... nonszensz.

Meg kell találnunk az egészet ki.

A kérdés felér „Mi kezdődik végén?»

Osztályok, hogy használja a szabad memória: a meghatározása és végrehajtása során, a használata osztály példányok, problémákat. A másolat konstruktor és destruktor, túlterhelt értékadó operátor: meghatározásáról és használatáról.

// Nem számít, hogy milyen típusú fogja használni a szabad memória, yuzaetsya nem új

// függetlenül attól, osztály szerkezete vagy valami mást.

C ++ új üzemeltető lehetővé teszi a programot, hogy a memóriát a futás során. Ahhoz, hogy az új üzemeltető meg kell adnia a bájtok számát memóriával rendelkezik, amely a programozni kívánt. Tegyük fel például, hogy a program megköveteli a 50-os tömbben. Az új üzemeltető, akkor azért ez a memória, az alábbiak szerint:







char * puffer = új char [50];

Röviden, ha az új üzemeltető memóriát sikeresen, akkor visszaad egy pointert az elején a memória területet.

Miért van szükség dinamikusan kiosztani memóriát új

Sok alkalmazás széles körben alkalmaznak tömbök tárolására számos értéket egy bizonyos típusú. Megtervezése során a program, a programozók általában megpróbálja tömböt, amelynek mérete elegendő, hogy megfeleljen a jövőbeli igényeit a program. Sajnos, ha ez megtörténik, a programot kell elveszett haladja meg ezeket a várakozásokat programozó, akkor valakinek meg kell szerkeszteni, és újrafordítani a programot.

Designer - egy osztály módszer, amely automatikusan elindul, ha létre az objektumot.

private:
char adatokat;
nyilvános:
osztály (char d): adatok (d) <>// kivitelező (inicializálunk)

_class * _example = új _class (tt); // létre ingyenes pamyatiekzemplyara osztály

cout <<*_example -> adat <

private:
char adatokat;
nyilvános:
_class (_class _example)

Ha a program nem kell több, mint a memóriát, meg kell szabadítani a delete operátor. Ahhoz, hogy a szabad memória a delete operátor, akkor egyszerűen adja meg az üzemeltetőt, hogy a mutató ez a memóriaterület, az alábbiak szerint:

A destruktor olyan funkció, hogy a C ++ automatikusan elindul, amikor ő vagy elpusztítják a program objektum. Destructor ugyanaz a neve, mint az objektum osztály; Te azonban megelőzte a neve a destruktor hullámvonal (

_class. Az ő programja, hogy határozzon meg egy destruktor ugyanúgy, mint bármely más módszer az osztály.

private:
char adatokat;
nyilvános:
osztály (char d): adatok (d) <>

_class (void) <>// destruktor pont

A hozzárendelés szereplő köteles kell meghatározni formájában funkciók az osztály, mert elválaszthatatlanul kapcsolódik az objektum a bal oldalon a „=”. Meghatározása az értékadó operátor a globális forma lehetővé tenné, hogy felülbírálja az alapértelmezett viselkedés az üzemeltető „=”. például:

_class (int i): az adatok (i)<>

_class operátor = (const _class jobbra)

ha (ez == jobbra)

adatok = right.data; // ha nem egyenlő önmagával, akkor ...

Típusú kapcsolatok osztályok között. Container osztály: a meghatározása, láthatóságát osztály tagjai. Végrehajtás és hívja konstruktorok és a destruktor a beágyazott osztályok. Végrehajtása és módszerek használatát.

// a Spurs írva, hogy csak kétféle

Háromféle közötti kapcsolatok osztályait a hagyományos OOP:

  • Használat: közvetlen befolyása.
    • A osztály tagja üzenetet küld egy objektum osztály B
    • Osztályú tag hoz létre, vagy visszatér tárgyak egy B osztály
  • Engedélyezése néha összesítés. Hajtja végre, logikai kapcsolatok típus „része”.
    • Egy osztály objektum tartalmaz belső objektum egy osztály B.
  • Öröklés: végrehajtja a logikai kapcsolatok, mint a „különleges eset”.
    • ///////////////////// magyarázható 1 jegy.

Container - módszer adattároló szervezet. (Stack, tömb, láncolt lista ....)

Container osztályok - egy univerzális sablon osztályok, tárolására az elemek a megadott típusú a szomszédos memóriában régiókban. C ++ szabvány már tartalmaz számos konténerek részeként STL (Standard Template Library - Standard Template Library).

Container meghatározni:

Például: vektor example_vector; // létrehoz egy vektor egészek

Egy osztály lehet nyilvánítani egy másik osztályba, ebben az esetben, egy belső osztály neve beágyazott:

Az alkatrészekhez való hozzáférés a beágyazott osztály, amelynek a saját attribútum csak egy beágyazott osztály jellemzői és funkciói a külső osztály deklarált a tervező barátja egy beágyazott osztály.

osztály cls1 // külső osztály

CLS2 (int bb). b (bb)<>// konstruktor CLS2

Nyilvános: // nyilvános szakaszt cls1

osztály cls3 // beágyazott osztály

Nyilvános: // nyilvános szakasza az osztály cls3

cls3 (int CC): c (cc) <>// konstruktor cls3

cls1 (int aa): a (aa) <>// konstruktor CLS

cls1 :: CLS2 bb (456); // hiba CLS2 nem tud hozzáférni saját

cout <

// deklarált osztály cls1 :: cls3 "

Példa hozzáférjenek magán-komponensek egymásba osztály műveleteit külső osztály deklarált specifikátor barátja, az alábbiakban.

void fun (cls1 :: CLS2); // függvény megkapja az osztály objektum CLS2

barátja void cls1 :: fun (cls1 :: CLS2); // ip-CIÓ, barátságos osztályok cls1

cls1. CLS2 cc (789);

Külső cls1 osztály tartalmaz állami funkció fun (cls1 :: CLS2 dd), ahol dd az objektum osztályának megfelelő CLS2 fektetett cls1 osztályban. Másfelől, az osztály CLS2 barát-funkció barátjának void cls1 :: fun (cls1 :: CLS2 dd), amely hozzáférést biztosít a szórakoztató osztály cls1 funkciók a helyi eleme az osztály CLS2.

11. Származtatott osztály: egyszerű öröklés, alapfogalmak és meghatározások. A szabályok meghatározására a származtatott osztály, öröklés típusok láthatóságának osztály tagjai. Végrehajtását és használatát konstruktorok és a destruktor a bázis és a származtatott osztályok. Segítségével példányban alap és származtatott osztályok. Mutatók bázis és az azokból származó osztályok.

Öröklési - ingatlan a rendszer, amely lehetővé teszi, hogy egy új osztályát írják, a meglévő részben vagy teljesen kölcsönöz funkciót. Az osztály, amelyből öröklési készült, úgynevezett bázis vagy szülő. Új osztály - leszármazottja, örökös vagy származtatott osztály.

Ezek elrejtve a szülő osztály saját, nem érhető el a származtatott osztály.

A (int a, int b): az adatok (a), Vasya (b)

B osztály: nyilvános A

B (int a, int b): aa (a), Vasya (b)

a = adatok; // hozzáférési hiba (adatok saját szülő osztály)

a = Vasya; // minden rendben van (Vasya volt az állami szülő osztály)

A * aaa = új A; // egy példányának létrehozásához osztályú (üres kivitelező)

A * aaa_2 = új A (23,42) // példányosítanánk Egy a megadott paraméterekkel

B * bbb_2 új B = (23, 52) // példányosítanánk B a megadott paraméterekkel (jobb használni aktív változata)

A * bbb = new B (23, 52) // példányosítanánk B a megadott paraméterekkel (rossz lehetőség miatt memória kiadás később)




Kapcsolódó cikkek

előző ◈ a következő