Există două tipuri de conversii: implicite și explicite.
1.Prisvoenie „mai mult de tip“ la „mai puțin ca“. Atribuirea în condiții de siguranță asigură valori constante.
unsigned int UnsignedIntVal;
unsigned char UnsignedCharVal;
2.Prisvoenie „tip mai mic de“ valoare „a unui tip mai mare.“ Potențial periculoasă misiune, amenință pierderea de informații.
Valoarea 3.Preobrazovanie a „mai mic de“ în „tip superior“. Se numește un tip de extensie.
Valorile 4.Preobrazovanie de „tip mare“ în „clasa de jos.“ Se numește tip constricție. Este o transformare periculoasă.
executarea corectă a acțiunilor de diferite tipuri, cu valori în condiții de siguranță și, în unele cazuri, cazuri periculoase asigurate de implementat în C ++ sistem tip de conversie.
În cazul în care traducerea expresiei cu diferite tipuri de operanzi compilatorul utilizează mecanismele de conversii implicite, care se bazează pe transformările standard, următoarele reguli:
- Atribuirea unui obiect de valoare convertește această valoare pentru tipul de obiect.
· MyIntU unsigned int;
· MyIntU = (int unsigned) 3.14159;
- Valorile de transmisie atunci când un apel de funcție convertește această valoare într-un parametru de tip funcții. El devine cunoscut pentru prototipul numit funcției.
· Ff nule (int); // functie prototip.
În acest caz, în etapa de traducere poate provoca avertizare de tip constricție.
- Aritmetică tip rezultat exprimarea expresiei este determinată de tipul „larg“ printre toate operanzi de expresie generatoare. Acest tip se numește tipul rezultat al expresiei. Acest tip de convertit toate operanzi rămase.
· Int Nesemnate MyIntU = 5;
expresii tip de rezultat aici este dublu, reprezentat în termeni literale 3.14159. În procesul de calcul al valorii expresiei variabilei MyIntU convertit la 5,0, care se adaugă la 3,14159.
- Tipul de transformare în calculul expresiilor aritmetice aplicate la copii ale valorilor de expresie care formează subexpressions. Procesul de conversie Rezultatele subexpressions tipuri de transformări nu este atribuit.
· Int Nesemnate MyIntU = 5;
· MyIntU = MyIntU + 3,14159;
Au existat două transformări consecutive:
În cursul evaluării MyIntU variabila expresie se extinde pentru a dubla și copie extinsă a valorii 5.0 se adaugă 3.14159. Ulterior, valoarea rezultată 8.14159 conform cu prima regulă, se îngustează la tipul unsigned int. Valoarea rezultată a 8 se obține și se atribuie MyIntU variabilei.
· Char * p_chVal = 0;
· Const int * pc_iVal = &iVal;
· // REGULA 5 se efectuează.
· // Eroare: pc_iVal - un pointer la o constantă.
· Const void * pcVal = pc_iVal;
· Și aici, toate bune! Pointer la o constantă este atribuit un pointer la o constantă.
Înainte de operație, endiancu un vid * pointer pentru a converti în mod explicit la un pointer la un anumit tip, la fel ca în acest caz, nu există nici o informație despre tipul, fapt care ia determinat traducătorul cum să interpreteze secvența de biți reprezentată de indicatorul:
char * p_chValName = "Marina";
p_chVal = (char *) p_Val; / Casting *. * /
Mecanismul de conversie implicită poate fi dezactivată în mod explicit prin specificarea tipurilor dorite în programul de conversie de text.
Astfel, modificarea exemplul considerat anterior
MyIntU = MyIntU + (int) 3.14159;
dezactivează mecanismul de schimbare implicit și valoarea de calcul a variabilei se face, doar un singur tip de transformare care se reduce tipul valoarea literala 3.14159.
* Stupid copie. Descrie-te ... prostii.
Trebuie să-l dau seama totul.
Întrebarea este echivalent cu „Ce este începe sfârșitul?»
Clasele care utilizează memoria liberă: definirea și punerea în aplicare a, utilizarea de cazuri de clasă, probleme. Constructorul copy si destructor, supraîncărcat operatorul de atribuire: definirea și utilizarea.
// Nu conteaza ce tip va folosi memoria liberă, nu yuzaetsya noi
// indiferent de clasa este structura sau altceva.
C ++ nou operator permite programul să aloce memorie în timpul rulării. Pentru a utiliza noul operator trebuie să specificați numărul de octeți de memorie pe care doriți să le programați. De exemplu, să presupunem că programul dvs. necesită o matrice de 50 de biti. Folosind noul operator, puteți comanda această memorie, așa cum se arată mai jos:
char * buffer = new char [50];
Pe scurt, în cazul în care noul operator alocă cu succes de memorie, acesta returnează un pointer la începutul zonei de memorie.
De ce am nevoie pentru a aloca dinamic memorie utilizând noi
Multe aplicații utilizează pe scară largă a matrice pentru stocarea unei multitudini de valori ale unui anumit tip. La proiectarea programelor lor, programatorii încearcă, de obicei să declare matrice cu o dimensiune suficientă pentru a satisface nevoile viitoare ale programului. Din păcate, în cazul în care se întâmplă ca programul trebuie să depășească vreodată aceste așteptări programator, atunci cineva trebuie să editeze și să recompilați un program.
Designer - o metodă de clasă care se execută în mod automat atunci când creați obiectul.
privat:
date char;
publice:
clasă (char d): datele (d) <>// constructor (inițializează)
_class * _example = new _class (tt); // crea clasa pamyatiekzemplyara liber
cout <<*_example -> date < privat: Dacă programul nu are nevoie de mai mult decât memoria alocată, aceasta ar trebui să-i elibereze folosind operatorul delete. Pentru a elibera memorie folosind operatorul delete, specificați pur și simplu operator la un pointer la această zonă de memorie, după cum se arată mai jos: Destructorul este o funcție care C ++ pornește automat atunci când el sau distruge obiectul de program. Distrugător are același nume ca și clasa obiect; Cu toate acestea vă sunt precedate de numele tilda destructor ( _class. În programul său, definiți un destructor în același mod ca și orice altă metodă a clasei. privat: _class (void) <>// destructor puncte Operatorul de atribuire este necesar să fie determinată sub forma funcțiilor clasei, deoarece este indisolubil legată de obiectul din stânga a „=“. Determinarea operatorului de atribuire într-o formă globală ar face posibilă pentru a trece peste comportamentul implicit al operatorului „=“. exemplu: _class (i int): date (i)<> _class operatorul = (_class const dreapta)
în cazul în care (acest == dreapta)
date = right.data; // în cazul în care nu este egal cu sine, atunci ... Tipuri de relații între clase. clase de containere: definirea, vizibilitatea membrilor clasei. Implementare si constructori de asteptare si destructori claselor imbricate. Punerea în aplicare și utilizarea metodelor. // pinteni scris că doar două tipuri de Trei tipuri de relații între clase sunt prevăzute în OOP tradiționale: Container - o metodă de organizare de stocare a datelor. (Stivă, matrice, listă înlănțuită ....) clase de containere - un clase șablon universal, pentru stocarea elementelor de tipul specificat în regiunile de memorie adiacente. standard C ++ include deja un număr mare de containere, ca parte a STL (Standard Template Library - Standard Template Library). Container determinat ca: De exemplu: vector O clasă poate fi declarată într-o altă clasă, în acest caz, o clasă interioară se numește imbricată: Accesul la componentele unei clase imbricate, având atributul privat posibilă numai dintr-o clasă imbricate caracteristici și funcții ale clasei exterioare declarate cu prietenul Specificator într-o clasă imbricată. clasa cls1 // clasa externă cls2 (int bb). b (bb)<>// cls2 constructor publice: // secțiunea publică pentru cls1 Clasa de CSL3 // clasa imbricată publice: // public-secțiune pentru CSL3 clasa CSL3 (int cc): c (cc) <>// CSL3 constructor cls1 (int aa): a (aa) <>// constructor cls cls1 :: bb cls2 (456); // cls2 eroare nu poate avea acces la privat cout < // a declarat în clasa „cls1 :: CSL3“ acces la EXEMPLUL-componente particulare imbricate clasa de funcții de clasă exterioare declarate cu un prieten specifier, de mai jos. void fun (cls1 :: cls2); // Funcția primește cls2 obiect de clasă friend cls1 void :: fun (cls1 :: cls2); // ip-TION, cursuri de prietenos cls1 cls1. cc cls2 (789); Clasa de cls1 externă conține funcția publică-fun (cls1 :: cls2 dd), în cazul în care dd este obiectul care corespunde cls2 de clasă, a investit în clasa cls1. La rândul său, clasa a cls2 prieten al-functia void cls1 :: fun (cls1 :: cls2 dd), care oferă acces la funcții distractive clasa cls1 la componenta locală a cls2 de clasă. 11. clase derivate: mostenire simplu, concepte de bază și definiții. Regulile pentru determinarea clasei derivate, tipuri de moștenire, vizibilitatea membrilor clasei. Implementarea și utilizarea constructori și destructori ai bazei și a claselor derivate. Folosind copii ale bazei și claselor derivate. Pointeri la bază și clase derivate. Moștenirea - o proprietate a sistemului, permițând să descrie o nouă clasă pe baza unui existent parțial sau complet împrumută funcționalitate. Clasa din care se face moștenire, numită bază sau părinte. Noua clasă - descendent, moștenitor sau o clasă derivată. Acestea ascunse în clasa părinte privat, nu este accesibilă din clasa derivată. A (int a, int b): date (a), vasya (b) clasa B: A publică
B (int a, int b): aa (a), vasya (b) a = date; // eroare de acces (date a fost clasa părinte privat) a = vasya; // totul e ok (vasya a fost în clasa părinte publică) A * = aaa nouă A; // a crea o instanță de clasa A (constructor gol) A * aaa_2 = new A (23,42) // instantiind A cu parametrii specificați B * bbb_2 nou B = (23, 52) // instantiind B cu parametrii specificați (mai bine să folosiți o variantă activă) A * bbb = new B (23, 52) // instantierea B, cu parametrii specificați (opțiunea de rău datorită eliberării de memorie mai târziu)
date char;
publice:
_class (_class _example)
date char;
publice:
clasă (char d): datele (d) <>
articole similare