Inceputul Programarea cu C ++ pentru Dummies Cheat Sheet - dummies

De către Stephen R. Davis

C ++ nu este un limbaj de programare ușor de stăpânit. Doar prin experiență, nenumăratele combinații de simboluri vor începe să vă pară naturale. Acest Cheat Sheet, cu toate acestea, vă oferă câteva sfaturi solide despre relaxarea acelei tranziții de la începutul C ++ la C ++ guru: Cunoașteți cum să citiți expresii C ++ complexe; aflați cum să evitați problemele indicatoarelor; și dați seama cum și când să faceți copii profunde.

Cum se citește o expresie C ++ complexă

C ++ este plină de simboluri mici, fiecare adăugând semnificația expresiilor. Regulile gramaticii C ++ sunt atât de flexibile încât aceste simboluri pot fi combinate în combinații aproape impenetrabile complexe. Expresiile în limbajul C mai simplu pot deveni atât de obtuzive încât a existat un concurs anual pentru cine ar putea scrie programul cel mai obscur și cine ar putea să o înțeleagă.

Nu este niciodată o idee bună să încercați să scrieți coduri complexe, dar uneori veți rula expresii în C ++ care sunt puțin uimitoare la prima vedere. Doar utilizați următorii pași pentru a le determina:

Începeți la cele mai încorporate paranteze.

Începeți să căutați cele mai exterioare paranteze. În cadrul acestora, căutați paranteze încorporate. Repetați procesul până când vă veți strădui să ajungeți la cea mai adâncă pereche de paranteze. Începeți evaluarea acestei subexpresii utilizând mai întâi următoarele reguli. După ce înțelegeți expresia respectivă, reveniți la nivelul următor și repetați procesul.
În cadrul perechii de paranteze, evaluați fiecare operație în ordinea precedentă.

Ordinea pe care operatorii o evaluează este determinată de precedența operatorului prezentată în tabel. Indirecția vine înainte de multiplicare care vine înainte de adăugare, astfel următoarele adaugă 1 plus 2 ori valoarea indicată de * ptr.

int i = 1 + 2 * * ptr;

Operatori în ordine de precedență

Precedență	Operator	Semnificație
1	unic)	Dereference un pointer
2	- (unary)	Returnează negativul argumentului său
3	++ >	49% (binar)
Decrement	4
Modulul	5	+ (binar)
Adăugare	5	- (binar)
	6	! !
Tipuri de atribuire	Evaluați operațiile aceleiași precedente de la stânga la dreapta (cu excepția alocării, care merge în altă direcție).	Majoritatea operatorilor de aceeași prioritate evaluează de la stânga la dreapta. Astfel se adaugă 1 la 2 și se adaugă rezultatul la 3:
int i = 1 + 2 + 3;	Ordinea de evaluare a unora dintre operatori nu contează. De exemplu, adăugarea funcționează la fel de la stânga la dreapta, așa cum se întâmplă de la dreapta la stânga. Ordinea de evaluare face o mare diferență pentru unele operații, cum ar fi diviziunea. Următoarele împărțesc 8 la 4 și împart rezultatul cu 2:	int i = 8/4/2;
Principala excepție de la această regulă este atribuirea, care este evaluată de la dreapta la stânga:	a = b = c;	Aceasta atribuie c la b și rezultatul unui a.
Evaluați subexpresiile în nici o ordine particulară.	Luați în considerare expresia următoare:	int i = f () + g () * h ();
Înmulțirea are o prioritate mai mare, deci puteți presupune că funcțiile g () și h () sunt numite înainte de f (), totuși acest lucru nu este cazul. Apelul de funcții are cea mai mare prioritate a tuturor, deci toate cele trei funcții sunt chemați înainte de înmulțirea sau adăugarea. (Rezultatele returnate de la g () și h () se înmulțesc și apoi se adaugă la rezultatele returnate de la f ().)	Singura dată în care ordinea în care funcțiile sunt numite face o diferență este atunci când funcția are efecte secundare cum ar fi deschiderea unui fișier sau modificarea valorii unei variabile globale. Cu siguranță nu ar trebui să vă scrieți programele astfel încât acestea să depindă de aceste tipuri de efecte secundare.	Efectuați orice tip de conversii numai atunci când este necesar.
Nu trebuie să faceți mai multe conversii de tip decât este absolut necesar. De exemplu, următoarea expresie are cel puțin trei și eventual patru tipuri de conversii:	float f = 'a' + 1;	Char 'a' trebuie să fie promovat la un int pentru a efectua adăugarea. Int este apoi convertit la un double și apoi în jos convertit la un singur float de precizie. Amintiți-vă că toate aritmetica este efectuată fie int sau dublu. În general, ar trebui să evitați performanța aritmetică a tipurilor de caractere și să evitați o singură flotare de precizie unică.

5 moduri de evitare a problemelor indicatorilor în C ++

În C ++, un indicator
este o variabilă care conține adresa unui obiect din memoria internă a calculatorului. Utilizați acești pași pentru a evita problemele cu indicii în C ++:
```
Inițializați indicii atunci când sunt declarați.
```
Nu lăsați niciodată variabilele pointerului neinitializate - lucrurile nu ar fi prea rău dacă indicatorii neinitializați conțin întotdeauna valori aleatorii - marea majoritate a valorilor aleatoare sunt valori ale indicatorilor ilegali și vor provoca crashul programului imediat ce sunt utilizați. Problema este că variabilele neinitializate tind să preiau valoarea altor variabile ale pointerilor folosite anterior. Aceste probleme sunt foarte greu de depanat.
```
Dacă nu știți ce altceva să inițializați un pointer, inițializați-l la nullptr. nullptr este garantat a fi o adresă ilegală.
```
Indicați zero după ce le utilizați.
În mod similar, este întotdeauna zero o variabilă a indicatorului odată ce pointerul nu mai este valabil prin atribuirea valorii nullptr. Acest lucru este valabil în special atunci când returnați un bloc de memorie în heap utilizând ștergerea; întotdeauna zero pointer după returnarea memorie heap.

Alocați memoria din heap și returnați-o la halda la același "nivel" pentru a evita scurgeri de memorie.
```
Încercați întotdeauna să întoarceți un bloc de memorie la heap la același nivel de abstractizare pe care l-ați alocat. În general, aceasta înseamnă că încercați să ștergeți memoria la același nivel de apeluri funcționale.
```
Prindeți o excepție pentru a șterge memoria când este necesar.

Nu uitați că o excepție poate apărea aproape în orice moment. Dacă intenționați să prindeți excepția și să continuați să operează (spre deosebire de a lăsa programul să se prăbușească), asigurați-vă că ați prins excepția și returnați toate blocurile de memorie în heap înainte ca indicii care le indică să iasă din domeniul de aplicare și memoria este pierdut.
Asigurați-vă că tipurile se potrivesc exact.

Asigurați întotdeauna că tipurile de indicatoare corespund tipului necesar. Nu reformatați un indicator fără un anumit motiv. Luați în considerare următoarele:
```
void fn (int * p); void myFunc () {char c = 'a'; char * pC = & c; fn ((int *) pC);}
```
Funcția de mai sus se compilează fără plângere, deoarece pointerul de caractere pC a fost reformat la un int * pentru a se potrivi cu declarația lui fn (int *); cu toate acestea, acest program aproape sigur nu va funcționa. Funcția fn () așteaptă un pointer la un număr întreg de 32 de biți și nu un caracter rinky-dink de 8 biți. Aceste tipuri de probleme sunt foarte greu de rezolvat.

Cum și când să faceți copii profunde în C ++

Clasele care alocă resurse în constructorul lor ar trebui să includă, în mod normal, un constructor de copii pentru a crea copii ale acestor resurse. Alocarea unui nou bloc de memorie și copierea conținutului originalului în acest nou bloc este cunoscută drept crearea unei copii profunde (spre deosebire de copia superioară implicită). Utilizați următorii pași pentru a determina cum și când să faceți copii profunde în C ++:

Faceți întotdeauna o copie profundă dacă constructorul alocă resurse.

În mod implicit, C ++ face așa numitele copii "superficiale" ale obiectelor atunci când le transmit la funcții sau ca rezultat al unei alocări. Trebuie să înlocuiți operatorii de copiere implicit de dimensiuni reduse cu echivalentul lor copie profundă pentru orice clasă care alocă resurse în constructor. Cea mai obișnuită resursă care devine alocată este memoria heap care este returnată de noul operator.

Întotdeauna includeți un destructor pentru o clasă care alocă resurse.
Dacă creați un constructor care alocă resurse, trebuie să creați un destructor care le restabilește. Fara exceptii.

Declarați întotdeauna destructorul virtual.
O eroare obișnuită este să uiți să-ți declarăm distrugătorul virtual. Programul va funcționa bine până când un programator nenumărate va veni și va moșteni din clasă. Programul pare să funcționeze, dar deoarece destructorul din clasa de bază nu poate fi invocat în mod corespunzător, memoria scade din programul dvs. ca o sită până când se blochează în cele din urmă. Această problemă este dificil de găsit.

includeți întotdeauna un constructor de copie pentru o clasă care alocă resurse.
Constructorul de copiere creează o copie corespunzătoare a obiectului curent, prin alocarea memoriei în afara heapului și copierea conținutului obiectului sursă.

Întotdeauna suprascrieți operatorul de atribuire pentru o clasă care alocă resurse.
Programatorii ar trebui să fie descurajați de operatorii superiori, însă operatorul de atribuire este o excepție. Ar trebui să înlocuiți operatorul de atribuire pentru orice clasă care alocă resurse în constructor.

Operatorul de atribuire ar trebui să facă trei lucruri:

Asigurați-vă că obiectul din stânga și din dreapta nu este același obiect. Cu alte cuvinte, asigurați-vă că programul de aplicație nu a scris ceva de genul (a = a). Dacă sunt, nu faceți nimic.

Invocați același cod ca și destructorul de pe obiectul din stânga pentru a returna resursele.

Invocați același cod ca un constructor de copie pentru a face o copie profundă a obiectului de mâna dreaptă în obiectul din stânga.

Dacă nu puteți face acest lucru, ștergeți constructorul de copiere și operatorul de atribuire astfel încât programul să nu poată face copii ale obiectului. Dacă nici nu puteți face acest lucru, deoarece compilatorul dvs. nu suportă caracteristica constructorului de ștergere C ++ 2011, creați un constructor gol și operatorul de atribuire și declarați-i protejați pentru a nu păstra alte clase să le folosească.