Begyndelse Programmering med C ++ for Dummies Cheat Sheet - dummies

Af Stephen R. Davis

C ++ er ikke et let programmeringssprog til at mestre. Kun gennem erfaring vil de myriade kombinationer af symboler begynde at virke naturlige for dig. Dette Cheat Sheet giver dig dog nogle solide tips om at lette overgangen fra C ++ nybegynder til C ++ guru: Kend hvordan man læser komplekse C + + udtryk; lære at undgå pegerproblemer; og find ud af, hvordan og hvornår man skal lave dybe kopier.

Sådan læses et komplekst C ++ Expression

C ++ er fyldt med små symboler, der hver især tilføjer betydningen af ​​udtryk. Reglerne for C ++ grammatik er så fleksible, at disse symboler kan kombineres i næsten uhåndterligt komplekse kombinationer. Udtryk i det enklere C-sprog kan blive så uanstændigt, at der tidligere var en årlig konkurrence for hvem der kunne skrive det mest uklare program, og hvem kunne forstå det.

Det er aldrig en god ide at forsøge at skrive kompleks kode, men du vil undertiden køre på tværs af udtryk i C ++, der er lidt forvirrende ved første øjekast. Brug blot følgende trin til at finde ud af dem:

1. Start med de mest indlejrede parenteser.

   Start med at kigge efter de yderste parenteser. Inden for dem, se efter indlejrede parenteser. Gentag processen, indtil du har arbejdet dig til det dybeste par parentes. Begynd at evaluere den pågældende subekspression først ved hjælp af følgende regler. Når du forstår det udtryk, skal du springe tilbage til næste niveau og gentage processen.

2. I hver paranteser evalueres hver operation i forrang.

   Den rækkefølge, som operatørerne vurderes, bestemmes af operatørens forrang i tabellen. Indirection kommer før multiplikation, som kommer før tilsætning dermed følgende tilføjer 1 plus 2 gange værdien spids til ved * ptr.

int i = 1 + 2 * * ptr;

Operatører i prædikorden

Forudgang	Operator	Betydning
1	() (unary)	Indkal en funktion
2	* og -> (unary)	Dereference a pointer
2	- (unary)	Returnerer det negative af dets argument
3	++ (unary)	Forøgelse
3 > - (unary)	Decrement	4
* (binær)	Multiplikation	4
/ (binær)	Division	4
% (binær)	Modulo	5
+ (binær)	Tilføjelse	5
- (binær)	Subtraktion	6
&& (binær)	Logisk OG	6
! !	Logisk ELLER	7
=, * =,% =, + =, - = (speciel)	Opgavetyper	Evaluer operationer med samme prioritet fra venstre mod højre (undtagen opgave, som går den anden vej).

1. De fleste operatører med samme forrang vurderer fra venstre til højre. Således tilføjer følgende 1 til 2 og tilføjer resultatet til 3:

   int i = 1 + 2 + 3;

   Evalueringsordningen for nogle operatører betyder ikke noget. For eksempel fungerer tilføjelsen det samme fra venstre mod højre som det gør fra højre til venstre. Evalueringsordningen gør meget forskel for nogle operationer som division. Følgende opdeler 8 ved 4 og deler resultatet med 2:
   

   int i = 8/4/2;

   Den største undtagelse til denne regel er opgaven, som evalueres fra højre til venstre:
   

   a = b = c;

   Dette tildeler c til b og resultatet til a.
   

   Evaluér underudtryk i ingen bestemt rækkefølge.

2. Overvej følgende udtryk:

   int i = f () + g () * h ();

   Multiplikation har højere prioritet, så man kan antage at funktionerne g () og h () kaldes før f (), men det er ikke tilfældet. Funktionsopkald har den højeste prioritet for alle, så alle tre funktioner kaldes før enten multiplikationen eller tilføjelsen udføres. (Resultaterne returneres fra g () og h () multipliceres og tilføjes derefter til de resultater, der returneres fra f ().)
   

   Den eneste gang, at den ordre, der fungerer, kaldes, gør en forskel, er, når funktionen har bivirkninger f.eks. åbning af en fil eller ændring af værdien af ​​en global variabel. Du bør absolut ikke skrive dine programmer, så de afhænger af denne type bivirkninger.

   Udfør kun typer konverteringer, når det er nødvendigt.

3. Du bør ikke foretage flere typer konverteringer end absolut nødvendigt. For eksempel har følgende udtryk mindst tre og muligvis fire typer konverteringer:

   float f = 'a' + 1;

   Karet 'a' skal fremmes til et int for at udføre tilføjelsen. Int'et konverteres derefter til en dobbelt og derefter ned konverteres til en enkelt præcisions float. Husk at al aritmetik udføres enten i int eller dobbelt. Du bør generelt undgå at udføre aritmetik på tegntyper og undgå ensartet præcision flyde helt.
   

   5 måder at undgå pegerproblemer i C ++

I C ++ er en

peger en variabel, som indeholder adressen på et objekt i computerens interne hukommelse. Brug disse trin for at undgå problemer med peger i C ++: Initialiser pegerne, når de er angivet.

1. Lad aldrig markørvariablerne ikke initialiseres - ting ville ikke være for dårlige, hvis uninitialiserede peger altid indeholdt tilfældige værdier - langt de fleste tilfældige værdier er ulovlige pointerværdier og vil få programmet til at gå ned, så snart de bliver brugt. Problemet er, at uninitialiserede variabler har tendens til at påregne værdien af ​​andre tidligere anvendte pegervariabler. Disse problemer er meget vanskelige at debug.

   Hvis du ikke ved, hvad der ellers skal initialiseres en peger, skal du initialisere den til nullptr. nullptr er garanteret at være en ulovlig adresse.

   Nul ud pointers, når du bruger dem.

2. På samme måde er altid nul en pointervariabel, når markøren ikke længere er gyldig, ved at tildele værdien nullptr. Dette er især tilfældet, når du returnerer en blok af hukommelse til bunken ved at slette; nul pegeren altid efter returnering af hukommelse.

   Alloker hukommelsen fra bunken og returner den til bunken på samme "niveau" for at undgå hukommelseslekkage.

3. Prøv altid at returnere en hukommelsesblok til bunken på samme niveau af abstraktion som du har tildelt det. Dette betyder generelt at forsøge at slette hukommelsen på samme niveau af funktionsopkald.

   Fang en undtagelse for at slette hukommelsen, når det er nødvendigt.

4. Glem ikke, at en undtagelse kan forekomme på næsten enhver tid. Hvis du har til hensigt at fange undtagelsen og fortsætte med at operere (i modsætning til at lade programmet falde), skal du sørge for, at du fanger undtagelsen og returnerer hukommelsesblokke til bunken, før de peger, der peger på dem, går uden for omfanget, og hukommelsen er faret vild.

   Sørg for, at typerne passer nøjagtigt sammen.

5. Sørg altid for, at typer af pointer matcher den ønskede type. Du må ikke omdanne en pointer uden nogen specifik grund. Overvej følgende:

   void fn (int * p); void myFunc () {char c = 'a'; char * pC = & c; fn ((int *) pC);}

Ovennævnte funktion kompilerer uden klage, da tegnpegeren pC er blevet omarbejdet til en int * for at matche erklæringen af ​​fn (int *); Men dette program vil næsten helt sikkert ikke fungere. Funktionen fn () forventer en pointer til et fuldt 32-bit heltal og ikke noget rinky-dink 8 bit char. Disse typer af problemer er meget vanskelige at sortere ud.

Hvordan og hvornår man laver dybe kopier i C ++

Klasser, der tildeler ressourcer i deres konstruktør, skal normalt indeholde en kopiekonstruktør for at lave kopier af disse ressourcer. Allokering af en ny blok af hukommelse og kopiering af indholdet af originalen til denne nye blok er kendt som oprettelse af en

dyb kopi (i modsætning til standard overfladisk kopi). Brug følgende trin til at bestemme, hvordan og hvornår du skal lave dybe kopier i C ++: Lav altid en dyb kopi, hvis konstruktøren allokerer ressourcer.

1. Som standard gør C ++ såkaldte "lavt" medlem-til-medlem kopier af objekter, når de overføres til funktioner eller som resultat af en opgave. Du skal erstatte standard overfladiske kopi operatører med deres dyb kopi ækvivalent for enhver klasse, der allokerer ressourcer i konstruktøren. Den mest almindelige ressource, der bliver tildelt, er hukommelse, der returneres af den nye operatør.

   Indsæt altid en destructor for en klasse, der allokerer ressourcer.

2. Hvis du opretter en konstruktør, der allokerer ressourcer, skal du oprette en destructor, der genopretter dem. Ingen undtagelser.

   Angiv altid destructor virtuel.

3. En fælles nybegynderfejl er at glemme at erklære din destructor virtuel. Programmet løber fint, indtil nogle intetanende programmør kommer sammen og arver fra din klasse. Programmet ser stadig ud til at fungere, men fordi destruktoren i baseklassen måske ikke påberåbes ordentligt, lækker hukommelsen fra dit program som en sigte, indtil den til sidst går i stykker. Dette problem er svært at finde.

   Indsæt altid en kopiekonstruktør for en klasse, der allokerer ressourcer.

4. Kopikonstruktøren opretter en ordentlig kopi af det aktuelle objekt ved at allokere hukommelsen ud af bunken og kopiere indholdet af kildeobjektet.

   Overstyr altid tildelingsoperatøren for en klasse, der allokerer ressourcer.

5. Programmører skal modløses af overordnede operatører, men overdragelsesoperatøren er en undtagelse. Du bør tilsidesætte opgaveoperatøren for enhver klasse, der allokerer ressourcer i konstruktøren.

   Opgaveoperatøren skal gøre tre ting:

   Kontroller, at venstre og højre håndobjekt ikke er det samme objekt. Med andre ord, vær sikker på, at applikationsprogrammeren ikke skrev noget som (a = a). Hvis de er, gør ingenting.

   1. Indkod den samme kode som destructoren på venstreobjektet for at returnere sine ressourcer.

   2. Indkod den samme kode som en kopikonstruktør for at lave en dyb kopi af den højre hånd i venstre håndobjekt.

   3. Hvis du ikke kan gøre det, skal du slette kopiekonstruktøren og tildelingsoperatøren, så programmet ikke kan lave kopier af din genstand.

6. Hvis du ikke engang kan gøre det, fordi din compiler ikke understøtter C ++ 2011 Delete Constructor-funktionen, skal du oprette en tom kopikonstruktør og opgaveoperatør og erklære dem beskyttet for at holde andre klasser i brug.