Invata C++

0.2 - INTRODUCERE ÎN LIMBAJELE DE PROGRAMARE.............................................................................
4
LIMBAJUL MAȘINII ..................................................................................................................................................................4
LIMBAJ DE ASAMBLARE.....................................................................................................................................................4
LIMBI LA NIVEL ÎNALT........................................................................................................................................................5
REGULI , BUNE PRACTICI ȘI AVERTISMENTE.................................................................................................................6
0.3 - INTRODUCERE ÎN C / C ++....................................................................................................................... 6
ÎNAINTE DE C ++, EXISTA C............................................................................................................................................6
C ++....................................................................................................................................................................................... 7
FILOZOFIA LUI C ȘI C ++.................................................................................................................................................7
Î: La ce este bun C ++?................................................................................................................................................7
Î: Trebuie să cunosc C înainte să fac aceste tutoriale?....................................................................................8
0.4 - INTRODUCERE ÎN DEZVOLTAREA C ++................................................................................................ 8
PASUL 1: DEFINIȚI PROBLEMA PE CARE DORIȚI SĂ O REZOLVAȚI ..........................................................................8
PASUL 2: S TABILIȚI CUM AVEȚI DE GÂND SĂ REZOLVAȚI PROBLEMA...................................................................8
PASUL 3: S CRIEȚI PROGRAMUL......................................................................................................................................9
0.5 - INTRODUCERE ÎN COMPILATOR, LINKER ȘI BIBLIOTECI.........................................................10
PASUL 4: COMPILAREA CODULUI SURSĂ...................................................................................................................10
PASUL 5: LEGAREA FIȘIERELOR DE OBIECT ȘI A BIBLIOTECILOR........................................................................11
PAȘII 6 ȘI 7: TESTAREA ȘI DEPANAREA......................................................................................................................12
MEDII DE DEZVOLTARE INTEGRATE (IDE)...................................................................................................................12
0.6 - INSTALAREA UNUI MEDIU DE DEZVOLTARE INTEGRAT (IDE)................................................12
VISUAL STUDIO (PENTRU WINDOWS )..........................................................................................................................13
COD :: BLOCURI (PENTRU LINUX SAU WINDOWS )...................................................................................................13
ID-URI MAC OSX..............................................................................................................................................................15
ALTE COMPILATOARE SAU PLATFORME........................................................................................................................15
Î: Pot folosi un compilator bazat pe web?...........................................................................................................15
Î: Pot folosi un compilator pentru linia de comandă (de exemplu, g ++ pe Linux)?.........................15
Î: Pot folosi alți editori de coduri sau ID-uri, precum Eclipse, Sublime, Notepad ++ sau Visual
Studio Code?....................................................................................................................................................................15
IDE DE EVITAT...................................................................................................................................................................15
CÂND LUCRURILE NU MERG BINE (DE ASEMENEA , CÂND IDE ÎNSEAMNĂ „NICI MĂCAR …”).......................16
0.7 - COMPILAREA PRIMULUI PROGRAM..................................................................................................... 16
PROIECTE.............................................................................................................................................................................16
PROIECTE PENTRU CONSOLE.........................................................................................................................................16
SPAȚII DE LUCRU / SOLUȚII............................................................................................................................................ 17
SCRIEREA PRIMULUI TĂU PROGRAM............................................................................................................................17
CREAREA UNUI PROIECT ÎN VISUAL STUDIO 2019.................................................................................................18
CREAREA UNUI PROIECT ÎN VISUAL STUDIO 2017 SAU MAI VECHI...................................................................21
EXPLORATORUL DE SOLUȚII VISUAL STUDIO............................................................................................................23
Î: Am primit eroarea C1010 ("eroare fatală C1010: sfârșitul neașteptat al fișierului în timp ce
căutați antetul precompilat. Ați uitat să adăugați„ #include "stdafx.h" 'la sursa dvs.? "). Ce
acum?.................................................................................................................................................................................24
CREAREA UNUI PROIECT ÎN COD :: BLOCURI............................................................................................................24
DACĂ UTILIZAȚI G ++ PE LINIA DE COMANDĂ...........................................................................................................27
DACĂ UTILIZAȚI ALTE IDE SAU UN COMPILATOR BAZAT PE WEB.........................................................................27
DACĂ COMPILAREA NU REUȘEȘTE................................................................................................................................28
DACĂ PROGRAMUL RULEAZĂ, DAR FEREASTRA CLIPEȘTE ȘI SE ÎNCHIDE IMEDIAT..........................................28
0.8 - CÂTEVA PROBLEME COMUNE C ++....................................................................................................... 29
PROBLEME GENERALE PE TERMEN DE RULARE........................................................................................................29
Î: Când executați un program, fereastra consolei clipește și se închide imediat................................29
Î: Am rulat programul meu și am obținut o fereastră, dar fără ieșire.....................................................29
Î: Programul meu compilează, dar nu funcționează corect. Ce fac?.........................................................29
PROBLEME GENERALE DE COMPILARE ÎN TIMP ...........................................................................................................29
Î: Când compilez programul meu, apar o eroare cu privire la simbolul extern nesoluționat _main
sau _WinMain @ 16......................................................................................................................................................29
Î: Încerc să folosesc funcționalitatea C ++ 11/14/17 / XX și nu funcționează....................................30
Î: Când încercați să utilizați cin, cout sau endl, compilatorul spune că cin, cout sau endl este un
„identificator nedeclarat”............................................................................................................................................30
Î: Când încercați să folosiți endl pentru a încheia o linie tipărită, compilatorul spune că end1
este un „identificator nedeclarat”............................................................................................................................30
PROBLEME CU VISUAL STUDIO.....................................................................................................................................30
Î: Când compilați cu Microsoft Visual C ++, primiți o eroare fatală C1010, cu un mesaj de
eroare de genul "c: \ vcprojects \ test.cpp (263): eroare fatală C1010: sfârșitul neașteptat al
fișierului în timp ce căutați directiva antet precompilată".............................................................................30
Î: Visual Studio prezintă următoarea eroare: "1MSVCRTD.lib (exe_winmain.obj): eroare
LNK2019: simbol extern nerezolvat _WinMain @ 16 referit în funcția" int __cdecl invoke_main
(void) "(? Invoke_main @@ YAHXZ)"...................................................................................................................31
Î: Când compilez programul meu, primesc avertismente despre „Nu pot găsi sau deschide
fișierul PDB”.....................................................................................................................................................................31
ALTCEVA.............................................................................................................................................................................. 31
Î: Am o altă problemă pe care nu-mi dau seama. Cum pot primi rapid un răspuns?.......................31
0.9 - CONFIGURAREA COMPILATORULUI: CREEAZĂ CONFIGURAȚII..............................................31
COMUTAREA ÎNTRE CONFIGURA ȚIILE DE CONSTRUIRE............................................................................................32
Pentru utilizatorii de Visual Studio..........................................................................................................................32
Pentru Cod :: Blochează utilizatorii........................................................................................................................32
0.10 - CONFIGURAREA COMPILATORULUI: EXTENSII COMPILATOARE........................................32
DEZACTIVAREA EXTENSIILOR COMPILATORULUI.......................................................................................................33
Pentru utilizatorii GCC / G ++..................................................................................................................................35
0.11 - CONFIGURAREA COMPILATORULUI: NIVELURI DE AVERTIZARE ȘI EROARE................35
Cea mai buna practica.................................................................................................................................................35
Cea mai buna practica.................................................................................................................................................35
CREȘTEREA NIVELULUI DE AVERTIZARE.....................................................................................................................35
TRATEAZĂ AVERTISMENTELE CA ERORI.......................................................................................................................38
0.12 - CONFIGURAREA COMPILATORULUI: ALEGEREA UNUI STANDARD DE LIMBĂ...............40
NUMELE DE COD PENTRU STANDARDELE DE LIMBĂ ÎN CURS................................................................................40
STABILIREA UNUI STANDARD LINGVISTIC ÎN VISUAL STUDIO...............................................................................40
STABILIREA UNUI STANDARD DE LIMBĂ ÎN COD: BLOCURI....................................................................................41
1.1 - DECLARAȚII ȘI STRUCTURA UNUI PROGRAM.................................................................................42
STABILIREA UNUI STANDARD DE LIMBĂ ÎN G ++......................................................................................................45
1.1 - DECLARAȚII ȘI STRUCTURA UNUI PROGRAM.................................................................................46
CAPITOLUL INTRODUCERE..............................................................................................................................................46
DECLARA ŢII ......................................................................................................................................................................... 46
FUNCȚIILE ȘI FUNCȚIA PRINCIPALĂ (MAIN)................................................................................................................46
DISECȚIE BUNĂ LUME!.....................................................................................................................................................47
ERORI DE SINTAXĂ ȘI SINTAXĂ......................................................................................................................................48
1.2 - COMENTARII.................................................................................................................................................. 49
COMENTARII CU O SINGURĂ LINIE................................................................................................................................49
COMENTARII CU MAI MULTE LINII ....................................................................................................................................50
UTILIZAREA CORECTĂ A COMENTARIILOR..................................................................................................................51
COMENTAREA CODULUI...................................................................................................................................................52
Bacsis..................................................................................................................................................................................53
1.3 - INTRODUCERE ÎN VARIABILE................................................................................................................ 54
DATE (DATA).......................................................................................................................................................................54
OBIECTE ȘI VARIABILE .....................................................................................................................................................54
INSTANTARE VARIABILĂ................................................................................................................................................... 55
TIPURI DE DATE.................................................................................................................................................................55
DEFINIREA MAI MULTOR VARIABILE ..............................................................................................................................55
1.4 - ALOCARE ȘI INIȚIALIZARE VARIABILĂ............................................................................................57
ALOCARE VARIABILĂ .........................................................................................................................................................57
COPIERE ȘI INIȚIALIZARE DIRECTĂ...............................................................................................................................58
INIȚIALIZARE UNIFORMĂ ÎN C ++ 11...........................................................................................................................58
Î: C ++ oferă copiere, inițializare directă și uniformă și alocare copie. Există o misiune directă
sau uniformă?..................................................................................................................................................................59
Î: Când ar trebui să inițializez cu {0} vs. {}?...................................................................................................59
INIȚIALIZAREA MAI MULTOR VARIABILE.......................................................................................................................59
1.5 - INTRODUCERE ÎN IOSTREAM: COUT, CIN ȘI ENDL.......................................................................60
BIBLIOTECA IOSTREAM.................................................................................................................................................... 60
std :: cout.......................................................................................................................................................................60
std :: endl........................................................................................................................................................................62
std :: endl vs '\ n'........................................................................................................................................................63
std :: cin...........................................................................................................................................................................63
1.6 - VARIABILE NEINITIALIZATE ȘI COMPORTAMENT NEDEFINIT...............................................65
VARIABILELE INIȚIALIZATE.............................................................................................................................................66
COMPORTAMENT NEDEFINIT...........................................................................................................................................67
1.7 - CUVINTE CHEIE ȘI IDENTIFICATORI DE DENUMIRE...................................................................68
CUVINTE CHEIE..................................................................................................................................................................68
1.8 - INTRODUCERE ÎN LITERALE ȘI OPERATORI...................................................................................71

LITERALI.............................................................................................................................................................................. 72
OPERATORII......................................................................................................................................................................... 72
ÎNLĂNȚUIREA OPERATORILOR.........................................................................................................................................73
1.9 - INTRODUCERE ÎN EXPRESII................................................................................................................... 73
EXPRESII..............................................................................................................................................................................73
ENUNȚURI DE EXPRESIE..................................................................................................................................................74
1.10 - DEZVOLTAREA PRIMULUI PROGRAM................................................................................................75
ÎNMULȚIȚI CU 2..................................................................................................................................................................76
SOLUȚIA NU TOCMAI BUNĂ.............................................................................................................................................78
CEA MAI BUNĂ SOLUȚIE.................................................................................................................................................. 78
SOLUȚIA PREFERATĂ........................................................................................................................................................79
1.X - CAPITOLUL 1 REZUMAT ȘI TEST........................................................................................................... 80
REZUMAT RAPID................................................................................................................................................................ 80
2.1 - INTRODUCERE ÎN FUNCȚII...................................................................................................................... 82

UN EXEMPLU DE FUNCȚIE DEFINITĂ DE UTILIZATOR...............................................................................................83
FUNCȚIILE DE APELARE DE MAI MULTE ORI...............................................................................................................84
FUNCȚII CARE APELEAZĂ FUNCȚII CARE APELEAZĂ FUNCȚII.................................................................................84
FUNCȚIILE IMBRICATE NU SUNT ACCEPTATE ..............................................................................................................85
2.2 - VALORILE RETURNĂRII FUNCȚIEI....................................................................................................... 87

VALORI DE RETURNARE...................................................................................................................................................88
FIXAREA PROGRAMULUI NOSTRU DE PROVOCARE....................................................................................................89
VALORILE RETURULUI VID (VOID).................................................................................................................................89
REVENIND LA PRINCIPAL.................................................................................................................................................90
CÂTEVA NOTE SUPLIMENTARE DESPRE VALORILE DE RETUR................................................................................90
REUTILIZAREA FUNCȚIILOR............................................................................................................................................91
2.3 - INTRODUCERE ÎN PARAMETRII ȘI ARGUMENTELE FUNCȚIEI.................................................96
PARAMETRII ȘI ARGUMENTELE FUNCȚIEI...................................................................................................................97
CUM FUNCȚIONEAZĂ PARAMETRII ȘI ARGUMENTELE...............................................................................................98
FIXAREA PROGRAMULUI NOSTRU DE PROVOCARE....................................................................................................99
UTILIZAREA VALORILOR DE RETURNARE CA ARGUMENTE......................................................................................99
UN AVERTISMENT DESPRE ORDINEA DE EVALUARE A ARGUMENTULUI FUNCȚIEI..........................................100
CUM FUNCȚIONEAZĂ PARAMETRII ȘI VALORILE DE RETUR...................................................................................100
Mai multe exemple......................................................................................................................................................101
0.2 - Introducere în limbajele de programare

DE ALEX, PE 27 MAI 2007 | MODIFICAT ULTIMA DATĂ DE NASCARDRIVER PE 11 DECEMBRIE 2019
Calculatoarele moderne sunt incredibil de rapide și devin mai rapide tot timpul. Cu toate acestea, cu
această viteză vin câteva constrângeri semnificative: Calculatoarele înțeleg doar nativ doar un set
foarte limitat de comenzi și trebuie să li se spună exact ce trebuie să facă.
Un program de calculator (de asemenea, numit în mod obișnuit o aplicație ) este un set de
instrucțiuni pe care computerul le poate efectua pentru a îndeplini o anumită sarcină. Procesul de
creare a unui program se numește programare . Programatorii creează în mod obișnuit programe
prin producerea codului sursă (scurtat în mod obișnuit la cod ), care este o listă de comenzi
introduse într-unul sau mai multe fișiere text.
Colecția de componente fizice ale computerului care alcătuiesc un computer și execută programe se
numește hardware . Când un program de calculator este încărcat în memorie și hardware-ul
execută secvențial fiecare instrucțiune, aceasta se numește rularea sau executarea programului.
Limbajul mașinii
CPU-ul unui computer nu este capabil să vorbească C ++. Setul limitat de instrucțiuni pe care un
procesor le poate înțelege direct se numește codul mașinii (sau limbajul mașinii sau un set de
instrucțiuni ).
Iată un exemplu de instrucțiuni de limbaj de mașină: 10110000 01100001
Când au fost inventate computerele pentru prima dată, programatorii trebuiau să scrie programe
direct în limbajul mașinii, ceea ce era un lucru foarte dificil și consumat de timp.
Modul în care aceste instrucțiuni sunt organizate este în afara domeniului de aplicare al acestei
introduceri, dar este interesant să notăm două lucruri. În primul rând, fiecare instrucțiune este
compusă dintr-o secvență de 1 și 0. Fiecare individ 0 sau 1 se numește cifră binară sau bit pentru
scurt. Numărul de biți care alcătuiesc o singură comandă variază - de exemplu, unele procesoare
procesează instrucțiuni care au întotdeauna 32 de biți, în timp ce unele alte CPU (cum ar fi familia
x86, pe care probabil le utilizați) au instrucțiuni care pot fi un lungime variabilă.
În al doilea rând, fiecare set de cifre binare este interpretat de către CPU într-o comandă pentru a
face o lucrare foarte specifică, cum ar fi compararea acestor două numere sau introducerea acestui
număr în acea locație de memorie . Cu toate acestea, deoarece procesoare diferite au seturi de
instrucțiuni diferite, instrucțiunile care au fost scrise pentru un tip de procesor nu au putut fi utilizate
pe un procesor care nu a împărțit același set de instrucțiuni. Acest lucru a însemnat că, în general,
programele nu erau portabile (utilizabile fără reelaborare majoră) la diferite tipuri de sistem și
trebuiau redactate din nou.
Limbaj de asamblare
Deoarece limbajul mașinii este atât de greu pentru oameni să citească și să înțeleagă, limbajul de
asamblare a fost inventat. Într-un limbaj de asamblare, fiecare instrucțiune este identificată printr-o
prescurtare scurtă (mai degrabă decât un set de biți) și pot fi folosite nume și alte numere.
Iată aceeași instrucțiune ca mai sus în limbajul de asamblare: mov al, 061h
Acest lucru face ca asamblarea să fie mult mai ușor de citit și scris decât limbajul mașinii. Cu toate
acestea, CPU nu poate înțelege limbajul de asamblare direct. În schimb, programul de asamblare
trebuie tradus în limbajul mașinii înainte de a putea fi executat de computer. Acest lucru se
realizează folosind un program numit asamblator . Programele scrise în limbile de asamblare tind
să fie foarte rapide, iar asamblarea este folosită și astăzi când viteza este critică.
Cu toate acestea, ansamblul are încă unele dezavantaje. În primul rând, limbile de asamblare
necesită încă o mulțime de instrucțiuni pentru a face chiar și sarcini simple. În timp ce instrucțiunile
individuale în sine sunt oarecum citibile uman, înțelegerea a ceea ce face un întreg program poate fi
dificilă (este ca și cum ai încerca să înțelegi o propoziție privind fiecare scrisoare individual). În al
doilea rând, limbajul de asamblare nu este încă foarte portabil - un program scris în asamblare
pentru un procesor probabil nu va funcționa pe hardware care folosește un set de instrucțiuni diferit
și ar trebui să fie rescris sau modificat pe larg.
Limbi la nivel înalt

Pentru a rezolva problemele de lizibilitate și portabilitate, au fost dezvoltate noi limbaje de
programare precum C, C ++, Pascal (și mai târziu, limbi precum Java, Javascript și Perl). Aceste
limbi se numesc limbi la nivel înalt , deoarece sunt concepute pentru a permite programatorului să
scrie programe fără a fi nevoie să fie la fel de preocupat de ce tip de computer va fi rulat.
Iată aceeași instrucțiune ca mai sus în C / C ++: a = 97;
La fel ca programele de asamblare, programele scrise în limbi de nivel înalt trebuie traduse într-un
format pe care computerul îl poate înțelege înainte de a putea fi rulate. Există două modalități
principale: realizarea și interpretarea.
Un compilator este un program care citește codul sursă și produce un program executabil de sine
stătător, care poate fi apoi rulat. După ce codul dvs. a fost transformat într-un executabil, nu aveți
nevoie de compilator pentru a rula programul. La început, compilatoarele au fost primitive și au
produs cod lent, neoptimizat. Cu toate acestea, de-a lungul anilor, compilatoarele au devenit foarte
bune la producerea de coduri rapide și optimizate și, în unele cazuri, pot face o treabă mai bună
decât pot fi oamenii în limbajul de asamblare!
Iată o reprezentare simplificată a procesului de compilare:
Întrucât programele C ++ sunt în general compilate, vom explora în scurt timp mai multe
compilatoare.
Un interpret este un program care execută direct instrucțiunile din codul sursă, fără a fi necesar ca
acestea să fie compilate într-un prim executabil. Interpreții tind să fie mai flexibili decât compilatorii,
dar sunt mai puțin eficienți atunci când rulează programe, deoarece procesul de interpretare trebuie
făcut de fiecare dată când programul este rulat. Aceasta înseamnă că interpretul este necesar de
fiecare dată când este rulat programul.
Iată o reprezentare simplificată a procesului de interpretare:

Lectură opțională
O bună comparație a avantajelor compilatorilor și interpretilor poate fi găsită aici .
Majoritatea limbilor pot fi compilate sau interpretate, însă, în mod tradițional, sunt compilate limbi
precum C, C ++ și Pascal, în timp ce limbaje „script” precum Perl și Javascript tind să fie
interpretate. Unele limbi, cum ar fi Java, folosesc un amestec dintre cele două.
Limbile la nivel înalt au multe proprietăți de dorit.
În primul rând, limbile la nivel înalt sunt mult mai ușor de citit și de scris, deoarece comenzile sunt
mai apropiate de limbajul natural pe care îl folosim în fiecare zi. În al doilea rând, limbile de nivel
înalt necesită mai puține instrucțiuni pentru a îndeplini aceeași sarcină ca și limbile de nivel inferior,
făcând programele mai concis și mai ușor de înțeles. În C ++ puteți face ceva ca a = b * 2 +
5;într-o singură linie. În limbajul de asamblare, aceasta ar lua 5 sau 6 instrucțiuni diferite.
În al treilea rând, programele pot fi compilate (sau interpretate) pentru multe sisteme diferite și nu
trebuie să schimbați programul pentru a rula pe diferite CPU (pur și simplu recompilați pentru acel
procesor). Ca exemplu:
Există două excepții generale la portabilitate. Primul este că multe sisteme de operare, cum ar fi
Microsoft Windows, conțin funcții specifice platformei pe care le puteți utiliza în codul dvs. Acestea
pot face mult mai ușor să scrieți un program pentru un anumit sistem de operare, dar în detrimentul
portabilității. În aceste tutoriale, vom evita orice cod specific platformei.
Unele compilatoare acceptă, de asemenea, extensii specifice compilatorului - dacă le utilizați,

programele dvs. nu vor putea fi compilate de alți compilatori care nu acceptă aceleași extensii fără
modificări. Vom vorbi mai multe despre acestea mai târziu, după ce ați instalat un compilator.
Reguli, bune practici și avertismente

Pe măsură ce parcurgem aceste tutoriale, vom evidenția multe puncte importante din următoarele
trei categorii:
Regulă
Regulile sunt instrucțiuni pe care trebuie să le faceți, după cum solicită limba. Nerespectarea unei
reguli va duce în general la funcționarea programului.
Cea mai buna practica
Cele mai bune practici sunt lucruri pe care ar trebui să le faci, deoarece acest mod de a face lucrurile
este în general considerat un standard sau foarte recomandat. Adică, fie că toată lumea o face în
acest fel (și dacă veți face altfel, veți face ceva pe care oamenii nu îl așteaptă), sau este superior
alternativelor.
Avertizare
Avertismentele sunt lucruri pe care nu ar trebui să le faci, deoarece, în general, vor duce la rezultate
neașteptate.
0.3 - Introducere în C / C ++
DE ALEX, PE 27 MAI 2007 | MODIFICAT ULTIMA DATĂ DE NASCARD RIVER PE 18 DECEMBRIE 2019
Înainte de C ++, exista C

Limbajul C a fost dezvoltat în 1972 de Dennis Ritchie la laboratoarele Bell Telephone, în principal ca
limbaj de programare a sistemelor (un limbaj cu care să scrie sisteme de operare). Obiectivele
principale ale lui Ritchie erau să producă un limbaj minimalist, ușor de compilat, să permită accesul
eficient la memorie, să producă cod eficient și să fie de sine stătător (nu depindea de alte
programe). Pentru un limbaj la nivel înalt, acesta a fost conceput pentru a oferi programatorului
mult control, încurajând în același timp independența platformei (hardware și sistem de operare)
(adică codul nu trebuia rescris pentru fiecare platformă).
C a sfârșit să fie atât de eficient și de flexibil încât în 1973, Ritchie și Ken Thompson au rescris
majoritatea sistemului de operare Unix folosind C. Multe sisteme de operare anterioare au fost scrise
în asamblare. Spre deosebire de asamblare, care produce programe care pot rula doar pe anumite
procesoare, C are o portabilitate excelentă, permițând unificării lui Unix pe mai multe tipuri diferite
de computere și grăbind adoptarea sa. C și Unix și-au legat averea, iar popularitatea lui C a fost în
parte legată de succesul Unix ca sistem de operare.
În 1978, Brian Kernighan și Dennis Ritchie au publicat o carte numită „Limbajul de programare
C”. Această carte, cunoscută drept K&R (după numele de familie ale autorilor), a furnizat o
specificație informală pentru limbă și a devenit un standard de facto. Când este necesară o
portabilitate maximă, programatorii ar respecta recomandările din K&R, deoarece majoritatea
compilatoarelor la acea vreme au fost implementate la standardele K&R.
În 1983, American National Standards Institute (ANSI) a format un comitet pentru a stabili un
standard formal pentru C. În 1989 (comisiile au nevoie pentru a face orice), au terminat și au lansat
standardul C89, mai cunoscut ca ANSI C. În 1990 Organizația Internațională de Standardizare (ISO)
a adoptat ANSI C (cu câteva modificări minore). Această versiune de C a devenit cunoscută sub
numele de C90. Compilatoarele au devenit în cele din urmă conforme cu ANSI C / C90, iar
programele care doresc portabilitate maximă au fost codate la acest standard.
În 1999, comitetul ANSI a lansat o nouă versiune de C, numită C99. C99 a adoptat multe
caracteristici care deja și-au croit drum în compilatoare ca extensii sau au fost implementate în C +
+.
C ++
C ++ (pronunțat vezi plus plus) a fost dezvoltat de Bjarne Stroustrup la Bell Labs ca o extensie la C,
începând cu 1979. C ++ adaugă multe caracteristici noi limbajului C și este poate cel mai bine
gândit ca un superset de C, deși acesta este nu este strict adevărat (deoarece C99 a introdus câteva
caracteristici care nu există în C ++). Afirmația lui C ++ față de faimă rezultă în primul rând din
faptul că este un limbaj orientat pe obiecte. În ceea ce privește ce este un obiect și cum se
diferențiază de metodele de programare tradiționale, bine, vom acoperi asta în capitolul 8
(programare de bază orientată pe obiect).
C ++ a fost standardizat în 1998 de către comitetul ISO (asta înseamnă că comitetul ISO a ratificat
un document care descrie limba C ++, pentru a ajuta la asigurarea tuturor compilatoarelor
respectând același set de standarde). O actualizare minoră a fost lansată în 2003 (numită C ++ 03).
De atunci au fost făcute trei actualizări majore la limbajul C ++ (C ++ 11, C ++ 14 și C ++ 17,

ratificate în 2011, 2014 și 2017), fiecare adăugând funcționalitate suplimentară. C ++ 11 a adăugat,
în special, un număr imens de noi capacități, iar în acest moment este considerată pe scară largă
noua linie de bază. Din momentul scrierii, C ++ 20 este în lucru, promițând să aducă și mai multe
capabilități noi. Actualizările viitoare la limbă sunt așteptate la fiecare trei ani.
Fiecare versiune formală a limbii este denumită standard de limbă (sau specificație lingvistică ).
Filozofia lui C și C ++
Filozofia de bază a designului C și C ++ poate fi rezumată la „încredere în programator” - care este
atât minunat, cât și periculos. C ++ este proiectat pentru a permite programatorului un grad ridicat
de libertate de a face ceea ce își doresc. Totuși, acest lucru înseamnă că limbajul de multe ori nu vă
va împiedica să faceți lucruri care nu au sens, pentru că va presupune că faceți acest lucru din
anumite motive pe care nu le înțelege. Există destul de multe capcane în care noii programatori vor
cădea probabil dacă nu sunt conștienți. Acesta este unul dintre principalele motive pentru care să știi
ce nu ar trebui să faci în C / C ++ este aproape la fel de important ca să știi ce ar trebui să faci.
Î: La ce este bun C ++?
C ++ excelează în situațiile în care este nevoie de o performanță ridicată și un control precis asupra
memoriei și a altor resurse. Iată câteva tipuri comune de aplicații care, cel mai probabil, ar fi scrise
în C ++:
 Jocuri video
 Sisteme în timp real (de exemplu, pentru transport, fabricație, etc.)
 Aplicații financiare de înaltă performanță (de exemplu, tranzacționare de înaltă frecvență)
 Aplicații și simulări grafice
 Productivitate / aplicații de birou
 Software încorporat
 Prelucrare audio și video
Î: Trebuie să cunosc C înainte să fac aceste tutoriale?
Nu! Este perfect bine să începeți cu C ++ și vă vom învăța tot ceea ce trebuie să știți (inclusiv
capcanele de evitat) pe parcurs.
După ce cunoașteți C ++, ar trebui să fie destul de ușor să înveți C standard dacă ai vreodată
nevoie. În zilele noastre, C este folosit mai ales pentru cazuri de utilizare de nișă: cod care rulează
pe dispozitive încorporate, atunci când trebuie să interacționezi cu alte limbi care pot interfața doar
cu C, etc. Pentru majoritatea celorlalte cazuri, C ++ este recomandat.
0.4 - Introducere în dezvoltarea C ++

DE ALEX, PE 27 MAI 2007 | MODIFICAT ULTIMA DATĂ DE ALEX LA 19 DECEMBRIE 2019
Înainte de a putea scrie și executa primul nostru program C ++, trebuie să înțelegem mai detaliat
cum se dezvoltă programele C ++. Iată un grafic care conține o abordare simplistă:
Pasul 1: Definiți problema pe care dori ți s ă o rezolva ți.
Acesta este pasul „ce”, în care vă dați seama ce problemă intenționați să rezolvați. Crearea ideii
inițiale pentru ceea ce ați dori să programați poate fi cel mai ușor pas sau cel mai greu. Dar
conceptual, este cel mai simplu. Tot ce ai nevoie este o idee care poate fi bine definită și ești
pregătit pentru următorul pas.
Iată câteva exemple:
 "Vreau să scriu un program care să-mi permită să introduc multe numere, apoi să calculez
media."
 „Vreau să scriu un program care generează un labirint 2d și să permită utilizatorului să
navigheze prin acesta. Utilizatorul câștigă dacă ajunge la sfârșit. "
 „Vreau să scriu un program care să citească într-un fișier al prețurilor acțiunilor și să prezice
dacă stocul va crește sau va scădea.”
Pasul 2: Stabiliți cum aveți de gând s ă rezolva ți problema.

Acesta este pasul „cum”, în care stabiliți cum aveți de gând să rezolvați problema cu care ați venit la
pasul 1. Este, de asemenea, pasul cel mai neglijat în dezvoltarea de software. Punctul crucial al
problemei este că există multe moduri de a rezolva o problemă - cu toate acestea, unele dintre
aceste soluții sunt bune, iar unele dintre ele sunt proaste. Prea des, un programator își va face o
idee, se va așeza și va începe imediat codarea unei soluții. Acest lucru generează adesea o soluție
care intră în categoria proastă.
De obicei, soluțiile bune au următoarele caracteristici:
 Sunt simple (nu sunt prea complicate sau confuze).

 Sunt bine documentate (mai ales în jurul oricărei presupuneri sau limitări).
 Sunt construite modular, astfel încât piesele pot fi reutilizate sau schimbate ulterior fără a
afecta alte părți ale programului.
 Sunt robuste și pot recupera sau pot da mesaje de eroare utile atunci când se întâmplă ceva
neașteptat.
Când te așezi și începi să codifici imediat, te gândești de obicei la „Vreau să fac _this_”, astfel încât
să implementezi soluția care te duce cel mai rapid acolo. Acest lucru poate duce la programe fragile,
greu de modificat sau extins mai târziu sau care au o mulțime de erori (defecte tehnice).
Ca o paranteza...
Termenul bug a fost folosit pentru prima dată de Thomas Edison încă din anii 1870! Cu toate
acestea, termenul a fost popularizat în anii 1940, când inginerii au găsit o molie reală blocată în
hardware-ul unui computer timpuriu, provocând un scurtcircuit. Atât cartea de jurnal în care a fost
raportată eroarea, cât și molia fac parte acum din Muzeul de Istorie al Smithsonianului. Poate fi
vizualizat aici .
Studiile au arătat că doar 20% din timpul programatorului este petrecut de fapt pentru a scrie
programul inițial. Celălalt 80% este cheltuit pentru întreținere, care poate consta
în depanare (eliminarea erorilor), actualizări pentru a face față modificărilor din mediu (de
exemplu, pentru a rula pe o nouă versiune de sistem de operare), îmbunătățiri (modificări minore
pentru a îmbunătăți capacitatea de utilizare sau capabilitatea) sau îmbunătățiri interne (pentru a
crește fiabilitatea sau mentenabilitatea).
În consecință, merită să vă petreceți puțin timp în față (înainte de a începe codificarea) gândindu-vă
la cea mai bună modalitate de a aborda o problemă, ce presupuneri faceți și cum puteți planifica
viitorul, pentru a vă salva. mult timp și probleme pe drum.
Vom vorbi mai multe despre cum să proiectăm eficient soluții la probleme într-o lecție viitoare.
Pasul 3: Scrieți programul

Pentru a scrie programul, avem nevoie de două lucruri: în primul rând, avem nevoie de cunoașterea
unui limbaj de programare - pentru asta sunt aceste tutoriale! În al doilea rând, avem nevoie de un
editor. Este posibil să scrieți un program folosind orice editor doriți, chiar și ceva la fel de simplu ca
notepad-ul Window-ului sau Vi sau pic-ul lui Unix. Cu toate acestea, vă îndemnăm puternic să
utilizați un editor care este conceput pentru codificare. Nu vă faceți griji dacă nu aveți încă
unul. Vom acoperi în scurt timp modul de instalare a unui editor de cod.
Un editor tipic proiectat pentru codificare are câteva funcții care facilitează mult mai ușor
programarea, inclusiv:
1) Numerotarea liniei. Numerotarea liniilor este utilă atunci când compilatorul ne dă o eroare,
deoarece va fi indicată o eroare tipică a compilatorului: unele coduri / mesaje de eroare, linia
64 . Fără un editor care arată numerele de linie, găsirea liniei 64 poate fi o problemă reală.
2) Sublinierea și colorarea sintaxei. Sublinierea și colorarea sintaxei schimbă culoarea diferitelor

părți ale programului pentru a facilita identificarea diferitelor componente ale programului. Iată un
exemplu de program C ++, cu numerotarea liniei și sublinierea sintaxei:
1 #include <iostream>
2
3 int main()
4{
5 std::cout << "Colored text!";
6 return 0;
7}
Exemplele pe care le arătăm în acest tutorial vor avea întotdeauna atât numerotarea liniei, cât și
sublinierea sintaxei pentru a le face mai ușor de urmărit.
3) Un font lipsit de ambiguitate. Fonturile care nu au programare fac adesea greu să distingă între
numărul 0 și litera O, sau între numărul 1, litera l (litere mici L) și litera I (majuscule i). Un font bun
de programare va diferenția aceste simboluri pentru a vă asigura că unul nu este folosit accidental în
locul celuilalt.
În C ++, programele dvs. vor fi de obicei numite name.cpp , unde numele este înlocuit cu numele
ales de dvs. pentru program (ex. Calculator, hi-lo, etc ...). Cpp extensia spune compilatorului (și tu)
că acesta este un fișier de cod sursă ++ C , care conține instrucțiuni de C ++. Rețineți că unii
utilizează extensia .cc în loc de .cpp, dar vă recomandăm să utilizați .cpp.
Denumiți fișierele dvs. code name.cpp , unde numele este un nume ales, iar .cpp este extensia care
indică că fișierul este un fișier sursă C ++.
De asemenea, rețineți că multe programe complexe C ++ au mai multe fișiere .cpp. Deși
majoritatea programelor pe care le creați inițial vor avea doar un singur fișier .cpp, este posibil să
scrieți programe individuale care au zeci sau sute de fișiere .cpp.
După ce ne-am scris programul, următorii pași sunt să-l transformăm în ceva pe care să-l rulăm și
apoi să vedem dacă funcționează! Vom discuta despre acești pași (4-7) în lecția următoare.
0.5 - Introducere în compilator, linker și biblioteci

DE ALEX PE 18 SEPTEMBRIE 2018 | MODIFICAT ULTIMA DATĂ DE ALEX PE 13 NOIEMBRIE 2019
Continuând discuția noastră despre această diagramă din lecția anterioară ( 0.4 - Introducere în
dezvoltarea C ++ ):
Să discutăm pașii 4-7.
Pasul 4: Compilarea codului sursă

Pentru a compila un program C ++, folosim un compilator C ++. Compilatorul C ++ parcurge
secvențial fiecare fișier cod sursă (.cpp) din programul dvs. și îndeplinește două sarcini importante:
În primul rând, verifică codul dvs. pentru a vă asigura că respectă regulile limbajului C ++. Dacă nu,
compilatorul vă va da o eroare (și numărul de linie corespunzător) pentru a vă ajuta să identificați
ceea ce are nevoie de remediere. Procesul de compilare va fi de asemenea anulat până la
remedierea erorii.
În al doilea rând, traduce codul sursă C ++ într-un fișier de limbaj de mașină numit fișier
obiect . Fișierele obiect sunt de obicei denumite name.o sau name.obj , unde numele este același
nume ca fișierul .cpp din care a fost produs.
Dacă programul dvs. ar avea 3 fișiere .cpp, compilatorul va genera 3 fișiere obiect:
Compilatoarele C ++ sunt disponibile pentru multe sisteme de operare diferite. Vom discuta despre
instalarea unui compilator în scurt timp, deci nu este nevoie să o facem acum.
Pasul 5: Legarea fi șierelor de obiect și a bibliotecilor

După ce compilatorul creează unul sau mai multe fișiere obiect, atunci un alt program
numit linker începe. Treaba linkerului este de trei ori:
În primul rând, să luați toate fișierele obiect generate de compilator și să le combinați într-un singur
program executabil.
În al doilea rând, pe lângă faptul că poate conecta fișiere obiect, linkerul este, de asemenea, capabil
să conecteze fișiere de bibliotecă. Un fișier de bibliotecă este o colecție de cod precompilat care a
fost „ambalat” pentru reutilizare în alte programe.
Limba de bază C ++ este de fapt destul de mică și concisă (și veți învăța o mare parte din ea în
aceste tutoriale). Cu toate acestea, C ++ vine și cu o bibliotecă extinsă numită Biblioteca
standard C ++ (de obicei scurtată la biblioteca standard ) care oferă funcționalitate suplimentară
pe care o puteți folosi în programele dvs. Una dintre cele mai utilizate părți ale bibliotecii standard C
++ este biblioteca iostream, care conține funcționalitate pentru imprimarea textului pe un monitor și
obținerea introducerii tastaturii de la un utilizator. Aproape toate programele scrise C ++ utilizează
biblioteca standard într-o anumită formă, așa că este foarte comun ca biblioteca standard să fie
conectată la programele tale. Majoritatea linkerilor se vor conecta automat în biblioteca standard
imediat ce utilizați orice parte a acesteia, deci, în general, nu este ceva de care trebuie să vă faceți
griji.
De asemenea, puteți face legătura opțional în alte biblioteci. De exemplu, dacă aveți de gând să
scrieți un program care a redat sunete, probabil că nu ați dori să scrieți propriul cod pentru a citi în
fișierele de sunet de pe disc, verificați dacă acestea sunt valide sau dacă vă dați seama cum să rotați
datele sunetului. la sistemul de operare sau hardware pentru a reda difuzorul - asta ar fi mult de
muncă! În schimb, probabil că descărcați o bibliotecă care știa deja să facă acele lucruri și să o
utilizați. Vom vorbi despre cum să faceți legătura în biblioteci (și să vă creați propriul!) Din anexă.
În al treilea rând, linkerul se asigură că toate dependențele de fișiere încrucișate sunt rezolvate
corect. De exemplu, dacă definiți ceva într-un fișier .cpp, apoi îl utilizați într-un alt fișier .cpp,
linkerul le conectează pe cele două. Dacă linkerul nu este în măsură să conecteze o referință la ceva
cu definiția sa, veți primi o eroare de linker și procesul de conectare va anula.
Odată ce linkerul a terminat de conectat toate fișierele de obiect și biblioteci (presupunând că totul
merge bine), veți avea un fișier executabil pe care îl puteți rula apoi!
Pentru cititorii avansați
Pentru proiecte complexe, unele medii de dezvoltare folosesc un makefile , care este un fișier care
descrie cum să construiască un program (de exemplu, care să compileze și să facă legătura, sau să
proceseze altfel în diferite moduri). Cărți întregi au fost scrise despre cum să scrieți și să întrețineți
makefiles și pot fi un instrument incredibil de puternic. Cu toate acestea, deoarece makefiles nu fac
parte din limbajul principal C ++ și nici nu trebuie să le utilizați pentru a continua, nu le vom discuta
ca parte a acestei serii de tutorial.
Pașii 6 și 7: Testarea și depanarea

Aceasta este partea amuzantă (sperăm)! Sunteți capabil să rulați executabilul dvs. și să vedeți dacă
produce ieșirea pe care o așteptați!
Dacă programul dvs. rulează, dar nu funcționează corect, atunci este timpul ca unele debugging să
își dea seama ce nu este în regulă. Vom discuta despre modul în care îți testezi programele și cum
să le depanezi mai detaliat în curând.
Medii de dezvoltare integrate (IDE)
Rețineți că pașii 3, 4, 5 și 7 implică toate softuri (editor, compilator, linker, depanator). În timp ce
puteți utiliza programe separate pentru fiecare dintre aceste activități, un pachet software cunoscut
sub numele de mediu de dezvoltare integrată (IDE) include și integrează toate aceste caracteristici
împreună. Vom discuta despre IDE și vom instala unul, în secțiunea următoare.
0.6 - Instalarea unui mediu de dezvoltare integrat

(IDE)
DE ALEX PE 28 MAI 2007 | MODIFICAT ULTIMA DATĂ DE NASCARD RIVER LA 20 DECEMBRIE 2019
Un mediu de dezvoltare integrat (IDE) este o aplicație software care conține toate lucrurile de
care aveți nevoie pentru a vă dezvolta, compila, conecta și depana programele.
Cu un ID tipic C ++, obțineți un editor de coduri care realizează numerotarea liniei și evidențierea
sintaxei. Multe (dar nu toate) ID-uri includ un compilator C ++ și un linker, cu care IDE va ști să
interfețe cu scopul de a converti codul sursă într-un fișier executabil. Și atunci când trebuie să
depanați programul, puteți utiliza debuggerul integrat.
În plus, IDE-urile conțin de obicei o serie de alte funcții utile de editare, cum ar fi ajutor integrat,
completare de nume, formatare automată și, uneori, un sistem de control al versiunii. Deci, în timp
ce puteți face toate aceste lucruri separat, este mult mai ușor să instalați un IDE și să le faceți
accesibile pe toate dintr-o singură interfață.
Deci, haideți să instalăm unul! Următoarea întrebare evidentă este: „care?”. Multe ID-uri sunt
gratuite (în preț) și puteți instala mai multe IDE-uri dacă doriți, deci nu trebuie luată „o decizie
greșită” aici. Vă vom recomanda câteva dintre preferatele noastre de mai jos.
Dacă aveți ceva alte IDE în minte, este în regulă. Conceptele pe care vi le prezentăm în aceste
tutoriale ar trebui să funcționeze în general pentru orice IDE modern decent. Cu toate acestea,
diverse IDE folosesc diferite denumiri, machete, mapări de chei, etc., așa că este posibil să fiți
nevoit să căutați în IDE pentru a găsi funcționalitatea echivalentă.
Bacsis
Veți dori să instalați un IDE care are un compilator capabil C ++ 11, deoarece acest tutorial
presupune C ++ 11 ca nivel de bază al funcționalității. Unele lecții acoperă suplimentar subiectele
introduse în C ++ 14/17/20.
Visual Studio (pentru Windows)

Dacă vă dezvoltați pe o mașină Windows (așa cum sunt majoritatea dintre voi) și spațiul pe disc și
dimensiunea de descărcare nu reprezintă o constrângere, atunci vă recomandăm cu încredere
Comunitatea Visual Studio . Când executați programul de instalare, veți ajunge în cele din urmă
la un ecran care vă întreabă ce volum de muncă doriți să instalați. Alegeți dezvoltarea desktop cu C
++ . Dacă nu faceți acest lucru, atunci capabilitățile C ++ nu vor fi disponibile.
Opțiunile implicite selectate în partea dreaptă a ecranului ar trebui să fie bine, dar vă rugăm să vă
asigurați că este selectat Windows 10 SDK . Windows 10 SDK poate fi utilizat pe versiuni mai vechi
de Windows, deci nu vă faceți griji dacă tot rulați Windows 7 sau 8.
Dacă spațiul de disc și / sau dimensiunea descărcărilor reprezintă o provocare, atunci vă
recomandăm Microsoft Visual Studio Express 2017 gratuit pentru desktop Windows , pe care îl
puteți găsi în partea de jos a paginii.
Cod :: Blocuri (pentru Linux sau Windows)

Dacă vă dezvoltați pe Linux (sau vă dezvoltați pe Windows, dar doriți să scrieți programe pe care le
puteți transporta cu ușurință la Linux), vă recomandăm Cod :: Blocuri . Cod :: Blocks este un IDE
gratuit, open source, multiplă platformă, care va rula atât pe Linux cât și pe Windows.
Pentru utilizatorii Windows
Asigurați-vă că obțineți versiunea Code :: Blocks care are MinGW pachet (ar trebui să fie cel al cărui
nume de fișier se termină în mingw-setup.exe ). Aceasta va instala MinGW, care include un port
Windows al compilatorului GCC C ++:
Pentru utilizatorii Linux
Unele instalații Linux pot lipsi dependențe necesare pentru a rula sau compila programe cu Code ::
Blocks.
Utilizatorii Linux bazati pe Debian (cum ar fi cei de pe Mint sau Ubuntu) ar putea avea nevoie să
instaleze pachetul esențial pentru construire . Pentru a face acest lucru de la linia de comandă
de terminal, tastați: sudo apt-get install build-essential.
Utilizatorii Arch Linux ar putea avea nevoie să instaleze baza devel-ului , care poate fi efectuat prin
intermediul pacman -Syu base-devel.
Utilizatorii de pe alte variante Linux vor trebui să stabilească care sunt managerul lor de pachete și
pachetele echivalente.
Când lansați Code :: Blocks pentru prima dată, puteți obține un dialog de detectare automată a
Compilatorilor . Dacă o faceți, asigurați-vă că GNU GCC Compiler este setat ca compilator implicit și
apoi selectați butonul OK .
Rețineți că, în mod implicit, Codul :: Blocurile nu pot activa funcțiile C ++ 11 (sau mai
noi). Acoperim cum să-l activăm în lecția 0.12 - Configurarea compilatorului: Alegerea unui
standard de limbă .
Î: Primesc o eroare „Nu pot găsi compilatorul executabil în căile de căutare configurate
pentru compilatorul GNU GCC”
Încercați următoarele:
1. Dacă sunteți pe Windows, asigurați-vă că ați descărcat versiunea Code :: Blocks WITH
MinGW. Este cel cu „mingw” în nume.
2. Încercați să mergeți la setări, compilator și alegeți „resetați la valorile prestabilite”.
3. Încercați să accesați setările, compilatorul, fila executabilă a cablurilor de instrumente și

asigurați-vă că „Directorul de instalare al compilatorului” este setat în directorul MinGW (de
ex. C: \ Program Files (x86) \ CodeBlocks \ MinGW).
4. Încercați să faceți o dezinstalare completă, apoi reinstalați.
5. Încercați un compilator diferit.
ID-uri Mac OSX

Opțiunile populare pentru Mac includ Xcode (dacă este disponibil pentru dvs.) sau Eclipse . Eclipse
nu este configurat pentru a utiliza C ++ în mod implicit și va trebui să instalați componentele
opționale C ++.
Deși Visual Studio pentru Mac a fost lansat, din august 2018 nu acceptă C ++, așa că în acest
moment nu îl putem recomanda.
Alte compilatoare sau platforme

Î: Pot folosi un compilator bazat pe web?
Da, pentru unele lucruri. În timp ce IDE-ul dvs. se descarcă (sau dacă nu sunteți sigur că doriți să
vă angajați să instalați unul), puteți continua acest tutorial folosind un compilator bazat pe web, cum
ar fi cel de la TutorialsPoint .
Compilatoarele bazate pe web sunt potrivite pentru antrenamente și exerciții simple. Cu toate
acestea, sunt în general destul de limitate în funcționalitate - mulți nu vă vor permite să salvați
proiecte, să creați executabile sau să vă depanați efectiv programele. Vei dori să migrezi la un IDE
complet când poți.
Î: Pot folosi un compilator pentru linia de comandă (de exemplu, g ++ pe Linux)?
Da, dar nu o recomandăm pentru începători. Va trebui să-ți găsești propriul editor și să cauți cum
să-l folosești în altă parte. Utilizarea unui depanator de linie de comandă nu este la fel de ușor ca un
depanator integrat și va îngreuna depurarea programelor.
Î: Pot folosi alți editori de coduri sau ID-uri, precum Eclipse, Sublime, Notepad ++ sau
Visual Studio Code?
Da, dar nu o recomandăm pentru începători. Există numeroase editori de coduri și ID-uri grozave
care pot fi configurate pentru a accepta o mare varietate de limbi și vă permit să amestecați și să
potriviți pluginuri pentru a vă personaliza experiența oricât doriți. Cu toate acestea, mulți dintre
acești editori și ID-uri necesită o configurație suplimentară pentru a compila programe C ++ și
există multe care pot merge greșit în timpul acestui proces. Pentru începători, vă recomandăm ceva
care funcționează din cutie, astfel încât să puteți petrece mai mult timp învățând codul și mai puțin
timp încercând să vă dați seama de ce editorul dvs. de cod nu funcționează corect cu compilatorul
sau debuggerul.
IDE de evitat
Vă recomandăm să evitați următoarele IDE, deoarece acestea nu mai sunt acceptate sau întreținute
în mod activ:
 Borland Turbo C ++
 Dev C ++
Dacă este posibil, utilizați un IDE care primește actualizări periodice și corecții de erori, și care va fi
actualizat pentru a încorpora noi caracteristici de limbă în timp.
Când lucrurile nu merg bine (de asemenea, când IDE înseamn ă

„Nici măcar…”)
Instalațiile IDE par să provoace ponderea lor corectă a problemelor. Instalarea ar putea eșua în
totalitate (sau instalarea poate funcționa, dar IDE va avea probleme atunci când încercați să o
utilizați din cauza unei probleme de configurare). Dacă întâmpinați astfel de probleme, încercați să
dezinstalați IDE (dacă a fost instalat în primul rând), reporniți aparatul, dezactivați-vă temporar
antivirusul sau anti-malware și încercați din nou instalarea.
Dacă mai întâmpinați probleme în acest moment, aveți două opțiuni. Opțiunea mai ușoară este să
încercați un IDE diferit. Cealaltă opțiune este să remediați problema. Din păcate, cauzele erorilor de
instalare și configurare sunt variate și specifice software-ului IDE în sine și nu suntem în măsură să
vă sfătuim în mod eficient cu privire la rezolvarea unor astfel de probleme. În acest caz, vă
recomandăm să copiați mesajul de eroare sau problema pe care o aveți într-o căutare Google și să
încercați să găsiți o postare pe forum în altă parte, din partea unui suflet sărac care inevitabil a
întâmpinat aceeași problemă. Adesea, vor exista sugestii cu privire la lucrurile pe care le puteți
încerca să remediați problema.
Trecând peste
Odată ce IDE-ul dvs. este instalat (care poate fi unul dintre cei mai dificili pași dacă lucrurile nu
merg așa cum este de așteptat) sau dacă mergeți temporar cu un compilator bazat pe web, sunteți
gata să vă scrieți primul program!
0.7 - Compilarea primului program

DE ALEX PE 28 MAI 2007 | MODIFICAT ULTIMA DATĂ DE NASCARD RIVER PE 22 DECEMBRIE 2019
Înainte de a putea scrie primul nostru program, trebuie să învățăm cum să creăm noi programe în
cadrul Mediului nostru de Dezvoltare Integrată (IDE). În această lecție, vom acoperi cum să faci asta
și vei compila și executa primul tău program!
proiecte
Pentru a scrie un program C ++ în interiorul unui IDE, începem de obicei prin crearea unui nou
proiect (vă vom arăta cum să faceți acest lucru într-un pic). Un proiect este un container care
conține toate fișierele dvs. de cod sursă, imagini, fișiere de date, etc ... care sunt necesare pentru a
produce un executabil (sau biblioteca, site-ul, etc ...) pe care îl puteți rula sau utiliza. De asemenea,
proiectul salvează diverse setări IDE, compilator și linker, precum și amintirea locului în care ați
părăsit, astfel încât atunci când redeschideți proiectul mai târziu, starea IDE poate fi restaurată în
orice loc. Când alegeți să compilați programul dvs., toate fișierele .cpp din proiect vor fi compilate și
legate.
Fiecare proiect corespunde unui program. Când sunteți gata să creați un al doilea program, va trebui
fie să creați un proiect nou, fie să rescrieți codul într-un proiect existent (dacă nu doriți să îl
păstrați). Fișierele de proiect sunt în general specifice IDE, astfel încât un proiect creat pentru un
IDE va trebui să fie recreat într-un IDE diferit.
Creați un nou proiect pentru fiecare program nou pe care îl scrieți.
Proiecte pentru console

Când creați un proiect nou, vi se va cere în general ce tip de proiect doriți să creați. Toate proiectele
pe care le vom crea în acest tutorial vor fi proiecte de consolă. Un proiect de consolă înseamnă că
vom crea programe care pot fi rulate de pe consola Windows, Linux sau Mac.
Iată o captură de ecran a consolei Windows:

În mod implicit, aplicațiile de consolă nu au o interfață grafică de utilizator (GUI), imprimă text pe
consolă, citesc intrarea de la tastatură și sunt compilate în fișiere executabile de sine
stătătoare. Acest lucru este perfect pentru învățarea C ++, deoarece menține complexitatea la
minimum și asigură că lucrurile funcționează pe o mare varietate de sisteme.
Nu vă faceți griji dacă nu ați folosit niciodată o consolă înainte sau nu știți cum să o accesați. Vom
compila și lansa programele noastre prin IDE-urile noastre (care vor invoca consola atunci când este
necesar).
Spații de lucru / solu ții

Când creați un nou proiect pentru programul dvs., multe ID-uri vor adăuga automat proiectul dvs.
într-un „spațiu de lucru” sau „o soluție” (termenul variază în funcție de IDE). Un spațiu de lucru sau
o soluție este un container care poate reține unul sau mai multe proiecte conexe. De exemplu, dacă
scriai un joc și vrei să ai un executabil separat pentru un singur jucător și multiplayer, ar trebui să
creezi două proiecte. Nu ar avea sens ca ambele proiecte să fie complet independente - până la
urmă, ele fac parte din același joc. Cel mai probabil, fiecare ar fi configurat ca un proiect separat
într-un singur spațiu de lucru / soluție.
Deși puteți adăuga mai multe proiecte la o singură soluție, în general vă recomandăm să creați un
spațiu de lucru sau o soluție nouă pentru fiecare program, în special în timp ce învățați. Este mai
simplu și există șanse mai mici de a nu merge ceva.
Scrierea primului t ău program

În mod tradițional, primii programatori de programe scriu într-un nou limbaj este infamul program
de salut mondial și nu vom privi de această experiență! Ne vei mulțumi mai târziu. Poate.
Avertizare
Începând cu această lecție, veți vedea multe exemple de cod C ++ prezentate. Majoritatea acestor
exemple vor arăta astfel:
2
3 int main()
4{
5 std::cout << "Hello, world!";
6 return 0;
7}
Dacă selectați codul din aceste exemple cu mouse-ul și apoi îl copiați / lipiți în IDE-ul dvs., puteți
obține și numerele de linie (în funcție de modul în care ați făcut selecția). Dacă da, va trebui să
eliminați manual numerele de linie înainte de a compila.
Crearea unui proiect în Visual Studio 2019

Când executați Visual Studio 2019, ar trebui să vedeți o fereastră de dialog care arată astfel:
Selectați Creați un proiect nou .
Vei vedea apoi un dialog care arată astfel:

Dacă ați deschis deja un proiect anterior, puteți accesa acest dialog prin meniul Fișier> Nou>
Proiect .
Selectați Windows Desktop Wizard și faceți clic pe Next . Dacă nu vedeți acest lucru, atunci ați uitat
probabil să alegeți să instalați dezvoltarea Desktop cu sarcină de lucru C ++ atunci când ați instalat
Visual Studio. În acest caz, reveniți la lecția 0.6 - Instalarea unui mediu integrat de dezvoltare
(IDE) și reinstalați-vă Visual Studio așa cum este indicat (notă: în loc să efectuați o reinstalare
completă, puteți rula programul de instalare Visual Studio și modificați instalarea existentă pentru a
adăuga volumul de lucru C ++).
În continuare, veți vedea un dialog care arată astfel:
Înlocuiți numele de proiect existent cu HelloWorld.
Este recomandat să verificați și soluția Loc și proiectul din același director , deoarece acest lucru
reduce numărul de subdirecții care se creează cu fiecare proiect.
Faceți clic pe Create pentru a continua.
În cele din urmă, veți vedea un ultim dialog:

Asigurați-vă că tipul aplicației este setat ca aplicație Console (.exe) și că opțiunea Antetul
precompilat nu este selectată. Apoi faceți clic pe OK .
Ați creat acum un proiect! Salt la secțiunea Explorator de soluții Visual Studio de mai jos pentru
a continua.
Crearea unui proiect în Visual Studio 2017 sau mai vechi

Pentru a crea un proiect nou în Visual Studio 2017 sau mai vechi, accesați meniul Fișier> Nou>
Proiect . Va apărea o casetă de dialog care arată astfel:
În primul rând, asigurați-vă că Visual C ++ este listat în partea stângă. Dacă nu vedeți Visual C ++ ,
atunci ați uitat probabil să alegeți să instalați dezvoltarea Desktop cu sarcină de lucru C ++ atunci
când ați instalat Visual Studio. În acest caz, reveniți la lecția 0.6 - Instalarea unui mediu integrat
de dezvoltare (IDE) și reinstalați-vă Visual Studio așa cum este indicat (notă: mai degrabă, faceți
o reinstalare completă, puteți rula programul de instalare Visual Studio și puteți modifica instalarea
existentă pentru a adăuga C ++ volum de muncă).
Dacă utilizați Visual Studio 2017 v15.3 sau mai nou, sub Visual C ++ , selectați Windows Desktop și
apoi selectați Windows Desktop Wizard în fereastra principală.
Dacă nu vedeți Windows Desktop ca o opțiune, probabil că utilizați o versiune mai veche a Visual
Studio. E in regula. În schimb, alegeți Win32 și apoi Win32 Console Application în fereastra
principală.
Mai jos, în câmpul Nume , introduceți numele programului dvs. (înlocuiți numele existent
cu HelloWorld). În câmpul Locație, puteți selecta opțional o altă locație în care va fi plasat proiectul
dvs. Implicit este bine deocamdată.
Faceți clic pe OK . Dacă utilizați o versiune mai veche de Visual Studio, Win32 Application Wizard se
va lansa. Apăsați Următorul .
În acest moment, ar trebui să vedeți un dialog de asistență care arată așa ceva (versiunile mai vechi
de Visual Studio folosesc un stil diferit, dar au cele mai multe opțiuni):
Asigurați-vă că debifați antetul precompilat .
Apoi faceți clic pe OK sau Finalizare . Acum proiectul dvs. este creat!
Exploratorul de solu ții Visual Studio

În partea stângă sau dreaptă a ferestrei, ar trebui să vedeți o fereastră intitulată Solution
Explorer . În această fereastră, Visual Studio a creat o soluție pentru dvs. ( Soluția
„HelloWorld” ). În cadrul acestuia, cu numele cu caractere aldine, este noul tău proiect
( HelloWorld ). În cadrul proiectului, Visual Studio a creat o serie de fișiere pentru dvs.,
inclusiv HelloWorld.cpp (sub articolul din arborele Fișiere sursă ). Este posibil să vedeți și alte
fișiere .cpp sau .h, pe care le puteți ignora deocamdată.
În editorul de text, veți vedea că Visual Studio a deschis deja HelloWorld.cpp și a creat unele coduri
pentru dvs. Selectați și ștergeți tot codul și tastați / copiați următoarele în IDE-ul dvs.:
2
3 int main()
4{
6 return 0;
7}
Pentru a compila programul dvs., apăsați F7 (dacă acest lucru nu funcționează, încercați Ctrl-Shift-
B ) sau accesați meniul Build> Soluție Build . Dacă totul merge bine, ar trebui să vedeți următoarele
în fereastra de ieșire:
1> ------ Construit început: Proiect: HelloWorld, Configurare: Debug Win32 ------
1> HelloWorld.cpp
1> HelloWorld.vcxproj -> c: \ users \ alex \ documents \ visual studio 2017 \
Proiecte \ HelloWorld \ Debug \ HelloWorld.exe
========== Construire: 1 a reușit, 0 eșuat, 0 actualizat, 0 sărit ==========
Aceasta înseamnă că compilarea dvs. a avut succes!
Î: Am primit eroarea C1010 ("eroare fatală C1010: sfârșitul neașteptat al fișierului în timp
ce căutați antetul precompilat. Ați uitat să adăugați„ #include "stdafx.h" 'la sursa
dvs.? "). Ce acum?
Ați uitat să dezactivați anteturile precompilate atunci când ați creat proiectul. Recreați proiectul dvs.
(conform instrucțiunilor de mai sus ) și asigurați-vă că dezactivați anteturile precompilate.
Pentru a rula programul compilat, apăsați Ctrl-F5 sau accesați meniul Debug și alegeți Start fără
debugging . Veți vedea următoarele:
Acesta este rezultatul programului tău! Felicitări, ai compilat și rulează primul tău program!
Crearea unui proiect în Cod :: blocuri

Pentru a crea un proiect nou, accesați meniul Fișier> Nou> Proiect . Va apărea o casetă de dialog
care arată astfel:
Selectați aplicația Console și apăsați butonul Go (sau Creare) .
Dacă vedeți un dialog de asistent pentru aplicații de consolă, apăsați Următorul , asigurați-vă că C +
+ este selectat și apăsați din nou Următorul .
Acum vi se va cere să denumiți proiectul dvs. Titlul proiectului HelloWorld. Îl puteți salva oriunde
doriți. Pe Windows, vă recomandăm să îl salvați într-un subdirector al unității C, cum ar
fi C:\CBProjects.
Este posibil să vedeți un alt dialog care vă întreabă ce configurații doriți să fie activate. Valorile
implicite ar trebui să fie bine aici, așa că selectați Finalizare .
Acum noul dvs. proiect a fost creat.
În partea stângă a ecranului, ar trebui să vedeți o fereastră Management ,

cu fila Proiecte selectată. În fereastra respectivă, veți vedea un folder de spațiu de lucru ,
cu proiectul HelloWorld în interiorul acestuia:
În cadrul proiectului HelloWorld , extindeți folderul Surse și faceți dublu clic pe „main.cpp”. Veți
vedea că a fost deja scris un program mondial de salut.
Înlocuiți-l pe unul cu următoarele:
2
3 int main()
4{
6 return 0;
7}
Pentru a vă construi proiectul, apăsați Ctrl-F9 sau accesați meniul Construire> Construire . Dacă
totul merge bine, ar trebui să vedeți următoarele să apară în fereastra jurnalului de construire:
-------------- Construire: Debug în HelloWorld (compilator: GNU GCC Compiler)

---------------
mingw32-g ++. exe -Wall -fexceptions -g -std = c ++ 14 -c C: \ CBProjects \
HelloWorld \ main.cpp -o obj \ Debug \ main.o
mingw32-g ++. exe -o bin \ Debug \ HelloWorld.exe obj \ Debug \ main.o
Fișierul de ieșire este bin \ Debug \ HelloWorld.exe cu dimensiunea 1,51 MB
Procesul încheiat cu starea 0 (0 minut (i), 0 secundă)
0 eroare (e), 0 avertizare (0) (0 minute), 0 secundă (e)
Aceasta înseamnă că compilarea dvs. a avut succes!
Pentru a rula programul compilat, apăsați Ctrl-F10 sau accesați meniul Build> Run . Veți vedea ceva
similar cu următoarele:
Acesta este rezultatul programului tău!
Pentru utilizatorii Linux
Utilizatorii Linux ar putea avea nevoie să instaleze pachetele suplimentare înainte de compilarea
Codului: blocurile. Vă rugăm să consultați instrucțiunile de instalare Code :: Blocks din lecția 0.6 -
Instalarea unui mediu de dezvoltare integrat (IDE) pentru mai multe informații.
Dacă utilizați g ++ pe linia de comand ă

În acest caz, nu este necesar să creați un proiect. Pur și simplu lipiți următoarele într-un fișier text
numit HelloWorld.cpp și salvați fișierul:
2
3 int main()
4{
6 return 0;
7}
Din linia de comandă, tastați:
g++ -o HelloWorld HelloWorld.cpp
Aceasta va compila și conecta HelloWorld.cpp. Pentru a o rula, introduceți:
HelloWorld(sau posibil ./HelloWorld) și veți vedea rezultatele programului.
Dacă utilizați alte IDE sau un compilator bazat pe web

Va trebui să vă dați seama cum puteți face următoarele:
1) Creați un proiect de consolă (doar IDE)
2) Adăugați un fișier .cpp la proiect (doar IDE, dacă unul nu este creat automat pentru dvs.)
3) Lipiți următorul cod în fișier:
2
3 int main()
4{
6 return 0;
7}
4) Compilați proiectul
5) Rulați proiectul
Dacă compilarea nu reu șe ște

E în regulă, inspiră adânc. Probabil o putem repara. :)
Mai întâi, uită-te la mesajul de eroare pe care ti l-a dat compilatorul. Cel mai adesea, va conține un
număr de linie care indică ce linie a fost în eroare. Examinați atât acea linie cât și liniile din jurul
acesteia și asigurați-vă că nu există dactilografii sau greșeli. De asemenea, asigurați-vă că nu
includeți numerele de linie în codul dvs.
În al doilea rând, priviți întrebările și întrebările din lecția 0.8 - Câteva probleme comune C ++ ,
deoarece problema dvs. poate fi abordată acolo.
În al treilea rând, citiți comentariile de mai jos - este posibil ca cineva să fi întâmpinat aceeași
problemă.
În cele din urmă, dacă toate cele de mai sus nu reușesc, încercați să căutați mesajul dvs. de eroare
pe Google. Este probabil că altcineva a mai întâlnit acest lucru înainte și și-a dat seama cum să-l
repar.
Dacă programul ruleaz ă, dar fereastra clipe ște și se închide

imediat
Unele IDE nu întrerup automat ecranul consolei după ce programul a terminat de
executat. Programul dvs. rulează, dar fereastra de ieșire se închide înainte de a putea vedea
rezultatele.
Dacă acesta este cazul IDE-ului dvs., următorii doi pași vor rezolva problema dvs.:
Mai întâi, adăugați sau asigurați-vă că următoarele linii sunt aproape de partea de sus a programului
dvs. (utilizatorii de Visual Studio, asigurați-vă că aceste linii apar după #include „pch.h” sau
#include „stdafx.h”, dacă există)
2 #include <limits>
În al doilea rând, adăugați următorul cod la sfârșitul funcției principale () (chiar înainte de declarația
de returnare):
std::cin.clear(); // reset any error flags

1
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // ignorați caracterele din bufferul de intrare
2
până găsim o linie nouă
3
std::cin.get(); // get one more char from the user
Acest lucru va determina programul dvs. să aștepte ca utilizatorul să apese o tastă înainte de a
continua, ceea ce vă va oferi timp să examinați ieșirea programului dvs. înainte ca IDE să închidă
fereastra consolei.
Alte soluții, cum ar fi system("pause")soluția recomandată în mod obișnuit , pot funcționa doar pe
anumite sisteme de operare și ar trebui evitate.
Este posibil ca antivirusul sau anti-malware să blocheze execuția programului. În acest caz, încercați
să dezactivați temporar scanerele și vedeți dacă problema se rezolvă.
Pentru utilizatorii de Visual Studio
Visual Studio nu se va întrerupe la sfârșitul unei aplicații de consolă dacă este rulat cu depanare
(Meniu Debug> Start Debugging). Dacă doriți ca acesta să se întrerupă, puteți utiliza soluția de cod
de mai sus, sau puteți rula programul dvs. fără depanare (Meniu Debug> Începeți fără depanare).
Concluzie
Felicitări, ai făcut-o prin cea mai grea parte a acestui tutorial (instalarea IDE și compilarea primului
program)!
Nu vă faceți griji dacă nu înțelegeți ce fac toate liniile diferite din programul Hello World. Vom
analiza și explica fiecare linie în detaliu la începutul capitolului următor.
0.8 - Câteva probleme comune C ++

DE ALEX PE 16 DECEMBRIE 2007 | MODIFICAT ULTIMA DATĂ DE NASCARD RIVER LA 24 DECEMBRIE
2019
În această secțiune, vom aborda unele dintre problemele comune pe care noii programatori par să le
întâmpine cu o probabilitate destul de mare. Aceasta nu este menită să fie o listă cuprinzătoare de
probleme de compilare sau execuție, ci mai degrabă o listă pragmatică de soluții la probleme foarte
de bază. Dacă aveți sugestii pentru alte probleme care ar putea fi adăugate la această listă, postați-
le în secțiunea de comentarii de mai jos.
Probleme generale pe termen de rulare

Î: Când executați un program, fereastra consolei clipește și se închide imediat.
Mai întâi, adăugați sau asigurați-vă că următoarele linii sunt aproape de partea de sus a programului
dvs. (utilizatorii de Visual Studio, asigurați-vă că aceste linii apar după #include „pch.h” sau
#include „stdafx.h”, dacă există)
2 #include <limits>
În al doilea rând, adăugați următorul cod la sfârșitul funcției principale () (chiar înainte de declarația
de returnare):
std::cin.clear(); // reset any error flags
1
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // ignore any characters in the input buffer
2
until we find an enter character
3
std::cin.get(); // get one more char from the user
Acest lucru va determina programul dvs. să aștepte utilizatorul să apese o tastă înainte de a
continua, ceea ce vă va oferi timp pentru a examina ieșirea programului dvs. înainte ca sistemul
dvs. de operare să închidă fereastra consolei.
Alte soluții, cum ar fi soluția de sistem („pauză”) sugerată în mod obișnuit pot funcționa doar pe
anumite sisteme de operare și ar trebui evitate.
Versiunile mai vechi de Visual Studio s-ar putea să nu se întrerupă atunci când programul este rulat
în modul Start With Debugging (F5) . Încercați să rulați în modul Start fără depanare (Ctrl-F5) .
Î: Am rulat programul meu și am obținut o fereastră, dar fără ieșire.
Scanerul dvs. de virus sau anti-malware pot bloca execuția. Încercați să îl dezactivați temporar și
vedeți dacă acesta este problema.
Î: Programul meu compilează, dar nu funcționează corect. Ce fac?
Debug-l! Există sfaturi despre cum să vă diagnosticați și să depanați programele mai târziu în
capitolul 3.
Probleme generale de compilare în timp

Î: Când compilez programul meu, apar o eroare cu privire la simbolul extern nesoluționat
_main sau _WinMain @ 16
Acest lucru înseamnă că compilatorul dvs. nu vă poate găsi funcția principală (). Toate programele
trebuie să includă o funcție principală.
Există câteva lucruri de verificat:

a) Codul dvs. include o funcție numită principală?
b) Este corect ortografia principală?
c) Când compilați programul dvs., vedeți că fișierul care conține funcția main () este compilat? Dacă
nu, fie mutați funcția principală () la una care este, fie adăugați fișierul la proiectul dvs. (consultați
lecția 2.8 - Programe cu mai multe fișiere de cod pentru mai multe informații despre cum se
face acest lucru).
d) Ați creat un proiect de consolă? Încercați să creați un nou proiect de consolă.
Î: Încerc să folosesc funcționalitatea C ++ 11/14/17 / XX și nu funcționează
Dacă compilatorul dvs. este vechi, este posibil să nu accepte aceste completări mai recente la
limbă. În acest caz, actualizați compilatorul.
Pentru IDE / compilatoare moderne, este posibil ca compilatorul dvs. să fie implicit la un standard de
limbă mai vechi. Acoperim modul de schimbare a standardului dvs. de limbă în lecția 0.12 -
Configurarea compilatorului: Alegerea unui standard de limbă .
Î: Când încercați să utilizați cin, cout sau endl, compilatorul spune că cin, cout sau endl
este un „identificator nedeclarat”
În primul rând, asigurați-vă că ați inclus următoarea linie în partea de sus a fișierului:
În al doilea rând, asigurați-vă că fiecare utilizare a cin, cout și endl sunt prefixate de „std ::”. De
exemplu:
1 std::cout << "Hello world!" << std::endl;
Dacă acest lucru nu rezolvă problema, atunci este posibil ca compilatorul să fie depășit sau
instalarea să fie coruptă. Încercați să reinstalați și / sau să faceți upgrade la cea mai recentă
versiune a compilatorului.
Î: Când încercați să folosiți endl pentru a încheia o linie tipărită, compilatorul spune că
end1 este un „identificator nedeclarat”
Asigurați-vă că nu greșești litera L (litere mici L) în endl pentru numărul 1. endl este toate
literele. Asigurați-vă că editorul dvs. utilizează un font care clarifică diferențele dintre literele
minuscule L, majuscule i și numărul 1. De asemenea, majusculele o și numărul zero pot fi ușor
confundate în multe fonturi care nu sunt programabile.
Probleme cu Visual Studio

Î: Când compilați cu Microsoft Visual C ++, primiți o eroare fatală C1010, cu un mesaj de
eroare de genul "c: \ vcprojects \ test.cpp (263): eroare fatală C1010: sfârșitul
neașteptat al fișierului în timp ce căutați directiva antet precompilată"
Această eroare apare atunci când compilatorul Microsoft Visual C ++ este setat să folosească
anteturi precompilate, dar unul (sau mai multe) din fișierele dvs. de cod C ++ nu #include
„stdafx.h” sau #include „pch.h” ca primă linie a codului. fișier.
Soluția noastră sugerată este de a dezactiva anteturile precompilate, pe care le arătăm cum se face
în lecția 0.7 - Compilarea primului program .
Dacă doriți să mențineți anteturile precompilate activate, pentru a remedia această problemă, pur și
simplu localizați fișierul (ești) care produce eroarea (în eroarea de mai sus, test.cpp este vinovatul)
și adăugați următoarea linie în partea de sus a fișierele):
1 #include "pch.h"
Versiunile mai vechi de Visual Studio folosesc „stdafx.h” în loc de „pch.h”, așa că dacă pch.h nu
rezolvă problema, încercați stdafx.h.
Rețineți că pentru programele cu mai multe fișiere, fiecare fișier de cod C ++ trebuie să înceapă cu
această linie.
Alternativ, puteți dezactiva anteturile precompilate.

Î: Visual Studio prezintă următoarea eroare: "1MSVCRTD.lib (exe_winmain.obj): eroare
LNK2019: simbol extern nerezolvat _WinMain @ 16 referit în funcția" int __cdecl
invoke_main (void) "(? Invoke_main @@ YAHXZ)"
Probabil ați creat o aplicație grafică Windows, mai degrabă decât o aplicație de consolă. Recreați
proiectul dvs. și asigurați-vă că îl creați ca un proiect Windows Console (sau Win32) .
Î: Când compilez programul meu, primesc avertismente despre „Nu pot găsi sau deschide
fișierul PDB”
Acesta este un avertisment, nu o eroare, deci nu ar trebui să afecteze programul dvs. Cu toate
acestea, este enervant. Pentru ao remedia, accesați meniul Debug -> Opțiuni și Setări -> Simboluri
și verificați „Microsoft Symbol Server”.
Altceva
Î: Am o altă problemă pe care nu-mi dau seama. Cum pot primi rapid un răspuns?
Pe măsură ce avansați prin material, veți avea, fără îndoială, întrebări sau veți avea probleme
neașteptate. Ce să faci în continuare depinde de problema ta. Dar, în general, puteți încerca câteva
lucruri.
În primul rând, întreabă Google . Găsiți o modalitate bună de a vă exprima întrebarea și de a face
o căutare Google. Dacă ați primit un mesaj de eroare, inserați mesajul exact în google folosind
ghilimele.
Șansele sunt că cineva a pus deja aceeași întrebare și vă așteaptă un răspuns.
În cazul în care nu reușește, întreabă un consiliu de întrebări și întrebări . Există site-uri web
concepute pentru programarea întrebărilor și răspunsurilor, cum ar fi Stack Overflow . Încercați să
postați întrebarea acolo. Nu uitați să fiți detalii despre problema dvs. și să includeți toate informațiile
relevante, cum ar fi sistemul de operare pe care îl utilizați și ce IDE utilizați.
0.9 - Configurarea compilatorului: Creează

configurații
DE ALEX PE 17 FEBRUARIE 2015 | MODIFICAT ULTIMA DATĂ DE ALEX LA 17 NOIEMBRIE 2019
O configurație de construire (numită și țintă de construire ) este o colecție de setări de proiect

care determină modul în care IDE-ul dvs. va construi proiectul. Configurația de construire include,
de obicei, lucruri precum ceea ce va fi numit executabilul, ce directoare IDE va căuta în alte fișiere
de coduri și biblioteci, dacă păstrați sau eliminați informațiile de depanare, cât de mult trebuie să
faceți compilatorul să vă optimizeze programul etc. , veți dori să lăsați aceste setări la valorile lor
implicite, dacă nu aveți un motiv specific pentru a schimba ceva.
Când creezi un nou proiect în IDE-ul tău, majoritatea IDE-urilor vor configura două configurații de
construire diferite pentru tine: o configurație de lansare și o configurație de depanare.
Configurația de depanare este conceput pentru a vă ajuta să depana programul, și este ,

în general , cel pe care îl va folosi atunci când scrieți programe. Această configurație dezactivează
toate optimizările și include informații de depanare, ceea ce face ca programele dvs. să fie mai mari
și mai lente, dar mult mai ușor de depanat. În mod implicit, configurația de depanare este selectată
ca configurație activă. Vom vorbi mai multe despre tehnicile de depanare într-o lecție ulterioară.
Configurația de eliberare este proiectat pentru a fi utilizat atunci când eliberarea programul
pentru public. Această versiune este de obicei optimizată pentru dimensiuni și performanțe și nu
conține informații suplimentare de depanare. Deoarece configurația de lansare include toate
optimizările, acest mod este util și pentru testarea performanței codului dvs. (ceea ce vă vom arăta
cum să faceți mai târziu în seria de tutorial).
Când programul Hello World (din lecția 0.7 - Compilarea primului program ) a fost creat folosind
Visual Studio, executabilul produs în configurația de depanare a fost de 65kb, în timp ce executabilul
încorporat în versiunea de lansare a fost de 12kb. Diferența se datorează în mare măsură
informațiilor suplimentare de depanare păstrate în compilarea depanare.
Deși puteți să vă creați propriile configurații de compilare personalizate, rar veți avea un motiv
pentru care nu doriți să comparați două versiuni realizate folosind setări diferite ale compilatorului.
Utilizați configurația de creare a debugului atunci când dezvoltați programele. Când sunteți gata să
eliberați executabilul către alții sau doriți să testați performanța, utilizați configurația de compilare
a lansării .
Comutarea între configura țiile de construire

Există mai multe modalități de a comuta între depanare și versiune în Visual Studio. Cel mai simplu
mod este să setați selecția dvs. direct din meniul derulant Configurații soluții din Opțiunile barei de
instrumente standard :
Setați-l pe Debug deocamdată.
Puteți accesa, de asemenea, dialogul managerului de configurare selectând meniul Build>

Configuration Manager și puteți modifica configurația soluției active .
Pentru Cod :: Blochează utilizatorii
În Cod :: blocuri, ar trebui să vedeți un element numit Build Target în bara de instrumente
Compiler :
Setați-l pe Debug deocamdată.
0.10 - Configurarea compilatorului: Extensii

compilatoare
DE ALEX PE 19 SEPTEMBRIE 2018 | MODIFICAT ULTIMA DATĂ DE NASCARD RIVER LA 20 DECEMBRIE
2019
Standardul C ++ definește reguli despre modul în care programele ar trebui să se comporte în

circumstanțe specifice. Și în cele mai multe cazuri, compilatorii vor respecta aceste reguli. Cu toate
acestea, mulți compilatori își implementează propriile modificări ale limbii, adesea pentru a
îmbunătăți compatibilitatea cu alte versiuni ale limbii (de exemplu, C99) sau din motive
istorice. Aceste comportamente specifice compilatorului se numesc extensii ale compilatorului .
Scrierea unui program care folosește o extensie a compilatorului vă permite să scrieți programe
incompatibile cu standardul C ++. În general, programele care utilizează extensii non-standard nu
vor fi compilate cu alte compilatoare (care nu acceptă aceleași extensii) sau, în caz contrar, pot să
nu funcționeze corect.
Frustrant, extensiile compilatorului sunt adesea activate în mod implicit. Acest lucru este nociv în
special pentru noii cursanți, care ar putea crede că un anumit comportament care funcționează face
parte din standardul oficial C ++, când de fapt compilatorul lor este pur și simplu permisiv.
Deoarece extensiile compilatorului nu sunt niciodată necesare și fac ca programele dvs. să nu fie
conforme cu standardele C ++, vă recomandăm să opriți extensiile compilatorului.
Dezactivați extensiile compilatorului pentru a vă asigura că programele dvs. (și practicile de codare)
rămân conforme cu standardele C ++ și vor funcționa pe orice sistem.
Dezactivarea extensiilor compilatorului
Pentru a dezactiva extensiile compilatorului, faceți clic dreapta pe numele proiectului
în fereastra Exploratorul soluțiilor , apoi alegeți Proprietăți :
Din dialogul de proiect , asigurați-vă mai întâi că câmpul de configurare este setat la Toate
configurațiile .
Apoi, faceți clic pe fila C / C ++> Limbă și setați Dezactivați extensiile limbii pe Da (/ Za) .
Dezactivați extensiile compilatorului din meniul Setări> Compilator> fila stegulețe Compilator , apoi
găsiți și verificați opțiunea -pedantic-erori .
Pentru utilizatorii GCC / G ++
Puteți dezactiva extensiile compilatorului adăugând steagul -pedantic-erori la linia de comandă de

compilare.
Un memento
Aceste setări sunt aplicate pe bază de proiect. Trebuie să le setați de fiecare dată când creați un
proiect nou sau să creați un proiect de șablon cu setările respective o dată și să îl utilizați pentru a
crea proiecte noi.
0.11 - Configurarea compilatorului: niveluri de

avertizare și eroare
DE ALEX PE 19 SEPTEMBRIE 2018 | MODIFICAT ULTIMA DATĂ DE NASCARDRIVER PE 27 DECEMBRIE
2019
Când scrieți programele dvs., compilatorul va verifica dacă ați respectat regulile limbajului C ++
(presupunând că ați dezactivat extensiile compilatorului, conform lecției 0.10 - Configurarea
compilatorului: extensii compilator ).
Dacă ați făcut ceva care încalcă definitiv regulile limbii, în timpul compilării compilatorul va emite
o eroare , furnizând atât numărul de linie care conține eroarea, cât și un text despre ceea ce era de
așteptat față de ceea ce a fost găsit. Eroarea reală poate fi pe acea linie sau pe o linie
precedentă. După ce ați identificat și corectat linia / eronele de cod, puteți încerca să compilați din
nou.
În alte cazuri, compilatorul poate găsi un cod care pare că ar putea fi în eroare, dar compilatorul nu
poate fi sigur (amintiți-vă deviza: „aveți încredere în programator”). În astfel de cazuri, compilatorul
poate opta să emită un avertisment . Avertismentele nu opresc compilarea, dar notifică
programatorului că ceva pare amis.
Nu lăsați avertismentele să se strângă. Rezolvați-le pe măsură ce le întâlniți (ca și cum ar fi erori).
În cele mai multe cazuri, avertismentele pot fi rezolvate fie prin remedierea erorii pe care este
evidențiat avertismentul, fie prin rescrierea liniei de cod care generează avertismentul astfel încât
avertizarea să nu mai fie generată.
În cazuri rare, poate fi necesar să-i spui explicit compilatorului să nu genereze un anumit
avertisment pentru linia de cod în cauză. C ++ nu acceptă o modalitate oficială de a face acest
lucru, dar multe compilatoare individuale (inclusiv Visual Studio și GCC) oferă soluții (prin directive
#pragma neportabile) pentru a dezactiva temporar avertismentele.
În mod implicit, majoritatea compilatoarelor vor genera doar avertismente cu privire la cele mai
evidente probleme. Cu toate acestea, puteți solicita compilatorului dvs. să fie mai asertiv cu privire
la furnizarea de avertismente pentru lucrurile pe care le consideră ciudate.
Rotiți-vă nivelul maxim de avertizare, mai ales în timp ce învățați. Te va ajuta să identifici posibile
probleme.
Creșterea nivelului de avertizare

Pentru a crește nivelul de avertizare, faceți clic dreapta pe numele proiectului

configurațiile .
Apoi selectați C / C ++> General tab și un set de nivel de avertizare la Nivel 4 (/ W4) :
Notă: Nu alegeți EnableAllWarnings (/ Wall) sau veți fi îngropat în avertismentele generate de
biblioteca standard C ++.
Din meniul Setări> Compilator> fila Setări compilator , găsiți și verificați opțiunile corelate cu -
Wall , -Weffc ++ și -Wextra :
Apoi accesați fila Altele opțiuni de compilare și adăugați -Wsign-conversie în zona de editare a
textului:
Notă: Parametrul -Werror este explicat mai jos.

Adăugați următoarele stegulețe la linia de comandă: -Wall -Weffc ++ -Wextra -Wsign-conversion
Tratează avertismentele ca erori

De asemenea, este posibil să spuneți compilatorului dvs. să trateze toate avertismentele ca și cum
ar fi erori (caz în care, compilatorul va opri compilarea dacă găsește avertismente). Aceasta este o
modalitate bună de a pune în aplicare recomandarea de a repara toate avertismentele (dacă nu
aveți autodisciplină, pe care majoritatea dintre noi le facem).
Pentru a trata avertismentele ca erori, faceți clic dreapta pe numele proiectului

configurațiile .
Apoi selectați fila C / C ++> General și setați Tratarea avertizărilor ca erori pe Da (/ WX) .
Din meniul Setări> Compilator> fila Opțiuni de compilare , adăugați -Werror în zona de editare a
textului:
Adăugați următorul steag la linia de comandă: -Werror

0.12 - Configurarea compilatorului: alegerea unui
standard de limbă
DE ALEX PE 12 NOIEMBRIE 2019 | MODIFICAT ULTIMA DATĂ DE NASCARDRIVER PE 28 DECEMBRIE
2019
Cu multe versiuni diferite de C ++ disponibile (C ++ 98, C ++ 03, C ++ 11, C ++ 14, C ++ 17,

etc ...) cum știe compilatorul care să folosească? În general, un compilator va alege un standard la
standard (adesea nu cel mai recent standard lingvistic). Dacă doriți să utilizați un standard diferit, va
trebui să configurați IDE / compilator pentru a face acest lucru.
Numele de cod pentru standardele de limb ă în curs

Rețineți că standardele lingvistice sunt denumite după anii în care au fost finalizați (de exemplu, C +
+ 17 a fost finalizată în 2017).
Cu toate acestea, atunci când este convenit un nou standard lingvistic, nu este clar în ce an va avea
loc finalizarea. În consecință, standardele de limbă în curs sunt date nume de cod, care sunt apoi
înlocuite cu numele reale la finalizarea standardului. De exemplu, C ++ 11 a fost numit c ++ 1x
în timp ce a fost lucrat. Este posibil să vedeți în continuare numele de cod utilizate în locuri (în
special pentru viitoarea versiune a standardului de limbă, care nu va avea încă un nume final).
Iată o mapare a numelor de cod cu numele finale:
 c ++ 1x = C ++ 11
 c ++ 1y = C ++ 14
 c ++ 1z = C ++ 17
 c ++ 2a = C ++ 20
De exemplu, dacă vedeți c++1z, acesta este sinonim cu standardul de limbă C ++ 17.
Stabilirea unui standard lingvistic în Visual Studio

Începând cu momentul scrierii, Visual Studio 2019 prestabilită funcțiile C ++ 14, ceea ce nu permite
utilizarea unor funcții mai noi introduse în C ++ 17 (și C ++ 20), unele dintre acestea fiind acoperite
în lecțiile viitoare. .
Pentru a utiliza aceste funcții mai noi, va trebui să activați un standard de limbă mai nou. Din
păcate, în prezent, nu există nicio modalitate de a face acest lucru la nivel global - trebuie să faceți
acest lucru pe bază de proiect de proiect.
Pentru a face acest lucru, deschideți-vă proiectul, apoi accesați meniul Proiect> (numele aplicației
dvs.) Proprietăți, apoi deschideți Proprietăți de configurare> C / C ++> Limbă .
De acolo, puteți seta standardul de limbă C ++ pe versiunea de C ++ pe care doriți să o utilizați.

Din momentul scrierii, vă recomandăm să selectați „Standardul ISO C ++ 17 (/ std: c ++ 17)”, care
este cel mai recent standard stabil.
Dacă doriți să experimentați cu capabilități din următorul standard de limbă C ++ 20, alegeți „ISO C
++ Ultimele (/ std: c ++ ultimul)”. Rețineți că asistența poate fi măcinată sau buggy.
Stabilirea unui standard de limb ă în Cod: blocuri

Cod :: Blocurile pot fi implicite la un standard pre-C ++ 11 de limbă. Veți dori cu siguranță să
verificați și să vă asigurați că este activat un standard lingvistic mai modern.
Vestea bună este că Code :: Blocks permite setarea standardului dvs. de limbă la nivel global, astfel
încât să îl puteți seta o singură dată (mai degrabă decât pentru fiecare proiect). Pentru aceasta,
accesați meniul Setări> Compilator :
Apoi, găsiți caseta sau casetele etichetate Have g ++ urmați standardul lingvistic C ++ XX ISO C +
+ [-std = c ++ XX] , unde XX este 11, 14 sau un alt număr mai mare (consultați elementele din
caseta roșie de mai jos de exemplu):
Verificați cel mai mare număr (în imaginea de mai sus, aceasta este opțiunea C ++ 14 din caseta
roșie).
Versiunea dvs. de Cod :: Blocurile pot avea, de asemenea, suport pentru viitoarele (sau doar
versiuni) ale versiunii C ++. Dacă da, acestea vor fi etichetate Aveți g ++ urmați standardul de
limbă ISO C ++ [CST + XX] ( denumit C ++ YY) [-std = c ++ XX] (consultați caseta albastră de mai
sus). Puteți verifica opțional aceste opțiuni dacă doriți să activați funcțiile adăugate în versiunea
respectivă, dar rețineți că asistența poate fi incompletă (de exemplu, unele funcții pot lipsi).
Consultați lista din partea de sus a lecției pentru o listă de nume de cod la mapări de standarde
lingvistice.
De exemplu, dacă doriți să activați funcțiile C ++ 17 și setările dvs. nu au o opțiune C ++ 17,

căutați -std=c++1z(numele de cod pentru C ++ 17).
În mod alternativ, puteți accesa fila Altele opțiuni de compilare și tastați -std = c ++ 17 .
1.1 - Declarații și structura unui program

DE ALEX PE 30 MAI 2007 | MODIFICAT ULTIMA DATĂ DE NASCARDRIVER LA 31 DECEMBRIE 2019
Capitolul introducere
Bine ați venit la primul capitol primar al acestor tutoriale C ++!
În acest capitol, vom arunca o primă privire asupra mai multor subiecte care sunt esențiale pentru
fiecare program C ++. Deoarece există destul de multe subiecte de abordat, vom acoperi cele mai
multe la un nivel destul de puțin adânc (doar suficient pentru a ne apropia). Scopul acestui capitol
este de a vă ajuta să înțelegeți modul în care sunt construite programe de bază C ++. Până la
sfârșitul capitolului, veți putea scrie propriile programe simple.
În capitolele viitoare, vom revizui majoritatea acestor subiecte și le vom explora mai detaliat. Vom
introduce, de asemenea, concepte noi care se bazează pe acestea.
Pentru a menține gestionarea lungimilor lecției, subiectele pot fi împărțite pe mai multe lecții
ulterioare. Dacă simți că un concept important nu este acoperit într-o lecție, este posibil să fie
acoperit în lecția următoare.
declaraţii
Un program de calculator este o secvență de instrucțiuni care spun computerului ce trebuie să
facă. O declarație este un tip de instrucțiune care determină programul să efectueze unele acțiuni .
Declarațiile sunt de departe cel mai comun tip de instrucțiune într-un program C ++. Acest lucru se
datorează faptului că sunt cea mai mică unitate independentă de calcul în limbajul C ++. În această
privință, ele acționează la fel cum fac propozițiile în limbajul natural. Când vrem să transmitem o
idee unei alte persoane, de obicei scriem sau vorbim în propoziții (nu în cuvinte sau în silabe
aleatorii). În C ++, când dorim ca programul nostru să facă ceva, de obicei scriem declarații.
Cele mai multe (dar nu toate) afirmații în C ++ se termină cu punct și virgulă. Dacă vedeți o linie
care se termină într-un punct și virgulă, este probabil o afirmație.
Într-un limbaj la nivel înalt, cum ar fi C ++, o singură declarație poate fi compilată în multe
instrucțiuni de limbaj mașină.
Există multe tipuri diferite de declarații în C ++:
1. Declarații
2. Declarații de salt
3. Enunțuri de expresie
4. Declarații compuse
5. Declarații de selecție (condiționale)
6. Declarații de iterație (bucle)
7. Încercați blocuri
Până când treceți cu această serie de tutorial, veți înțelege care sunt toate acestea!
Funcțiile și funcția principal ă

În C ++, instrucțiunile sunt de obicei grupate în unități numite funcții. O funcție este o colecție de
declarații care se execută secvențial. Pe măsură ce înveți să-ți scrii propriile programe, vei putea să-
ți creezi propriile funcții și să amesteci și să asortezi declarații în orice fel dorești (îți vom arăta cum
ar fi într-o lecție viitoare).
Regulă
Fiecare program C ++ trebuie să aibă o funcție specială numită principală (toate litere mici). Când
programul este rulat, execuția începe cu prima instrucțiune din interiorul funcției principale și apoi
continuă secvențial.
De obicei, programele se termină (termină rularea) atunci când ultima instrucțiune din
funcția principală este executată (deși pot avorta devreme în unele circumstanțe).
Funcțiile sunt de obicei scrise pentru a face o lucrare specifică. De exemplu, o funcție numită „max”
poate conține instrucțiuni care să indice care dintre două numere este mai mare. O funcție numită
„calcula grad” poate calcula nota unui student dintr-un set de scoruri de test. Vom vorbi mult mai
multe despre funcții în curând, deoarece sunt instrumentul de organizare cel mai des utilizat într-un
program.
Nota autorului
Când discutați funcții, este destul de comună scurtarea de a adăuga o pereche de paranteze la
sfârșitul numelui funcției. De exemplu, dacă vedeți termenul principal () sau doSomething () , acesta
este scurt pentru funcțiile numite principal sau respectiv doSomething . Acest lucru ajută la
diferențierea funcțiilor de alte tipuri de obiecte (cum ar fi variabile) fără a fi nevoie să scrieți
cuvântul „funcție” de fiecare dată.
Disecție Bună lume!
Acum că aveți o scurtă înțelegere despre ce sunt afirmațiile și funcțiile, să revenim la programul
nostru „Hello world” și să aruncăm o privire la nivel înalt la fiecare linie în detaliu.
2
3 int main()
4{
5 std::cout << "Hello world!";
6 return 0;
7}
Linia 1 este un tip special de linie numit directivă preprocesor. Această directivă a preprocesorului
indică faptul că am dori să folosim conținutul bibliotecii iostream, care este partea bibliotecii
standard C ++ care ne permite să citim și să scriem text din / către consolă. Avem nevoie de
această linie pentru a putea folosi std :: cout de pe linia 5. Excluderea acestei linii ar duce la o
eroare de compilare pe linia 5, întrucât compilatorul nu ar ști altfel ce este std :: cout.
Linia 2 este goală și este ignorată de compilator. Această linie există doar pentru a ajuta programul
să fie mai lizibil pentru oameni (prin separarea directivei #include preprocesor și a părților ulterioare
ale programului).
Linia 3 spune compilatorului că vom scrie (defini) o funcție numită principal . După cum ați aflat mai
sus, fiecare program C ++ trebuie să aibă o funcție principală sau nu va reuși să compileze.
Liniile 4 și 7 spun compilatorului care linii fac parte din funcția principală . Totul dintre bretonul
ondulat de deschidere de pe linia 4 și bretonul ondulat de închidere de pe linia 7 este considerat
parte a funcției principale . Aceasta se numește corpul funcției.
Linia 5 este prima declarație din funcția principală și este prima declarație care se va executa atunci
când vom rula programul nostru. std :: cout (care înseamnă „ieșire de caractere”) și <<operatorul ne
permite să trimitem scrisori sau numere către consolă pentru a fi ieșite. În acest caz, îi trimitem
textul „Hello world!”, Care va fi transmis către consolă. Această afirmație creează ieșirea vizibilă a
programului.
Linia 6 este o declarație de retur. Când un program executabil termină rularea, programul trimite o
valoare înapoi la sistemul de operare pentru a indica dacă a rulat cu succes sau nu. Această
declarație de returnare particulară returnează valoarea 0 sistemului de operare, ceea ce înseamnă
„totul a mers bine!”. Aceasta este ultima declarație din programul care se execută.
Toate programele pe care le scriem vor urma acest șablon general sau o variantă a acestuia.
Nota autorului
Dacă părțile (sau toate) din explicația de mai sus sunt confuze, acest lucru este de așteptat în acest
moment. Acest lucru a fost doar pentru a oferi o imagine de ansamblu rapidă. Lecțiile ulterioare vor
săpa în toate subiectele de mai sus, cu o mulțime de explicații și exemple suplimentare.
Puteți compila și rula acest program singur și veți vedea că acesta transmite următoarele către
consolă:
Salut Lume!
Dacă aveți probleme cu compilarea sau executarea acestui program, consultați lecția 0.8 - Câteva
probleme comune C ++ .
Erori de sintax ă și sintax ă

În limba engleză, propozițiile sunt construite în conformitate cu reguli gramaticale specifice pe care
probabil le-ați învățat în clasă de engleză în școală. De exemplu, propozițiile normale se termină
într-o perioadă. Regulile care guvernează modul de construire a propozițiilor într-un limbaj se
numește sintaxă . Dacă uitați perioada și executați două propoziții împreună, aceasta este o
încălcare a sintaxei limbii engleze.
C ++ are și o sintaxă: reguli despre modul în care programele dvs. trebuie construite pentru a putea
fi considerate valide. Când compilați programul dvs., compilatorul este responsabil să se asigure că
programul respectă sintaxa de bază a limbajului C ++. Dacă încălcați o regulă, compilatorul se va
plânge atunci când încercați să compilați programul dvs. și vă vor emite o eroare de sintaxă .
Să vedem ce se întâmplă dacă omitem punct și virgulă de pe linia 5 a programului „Hello world”,
astfel:
2
3 int main()
4{
5 std::cout << "Hello world!"
6 return 0;
7}
Simțiți-vă liber să compilați acest program prost format.
Visual Studio produce următoarea eroare (compilatorul dvs. poate genera un mesaj de eroare cu
formulare diferită):
c: \ vcprojects \ test1.cpp (6): eroare C2143: eroare de sintaxă: lipsește ';'

înainte de „întoarcere”
Acest lucru vă spune că aveți o eroare de sintaxă pe linia 6: compilatorul aștepta o virgulă înainte de
instrucțiunea de returnare, dar nu a găsit una. Deși compilatorul vă va spune ce linie de cod a fost
compilată când a întâlnit eroarea de sintaxă, omisiunea poate fi de fapt pe o linie anterioară. În
acest caz, eroarea este de fapt la sfârșitul liniei 5 (compilatorul nu a descoperit problema până la
linia 6).
Erorile de sintaxă sunt frecvente atunci când scrii un program. Din fericire, acestea sunt de obicei
simple pentru a găsi și repara, deoarece compilatorul vă va indica, în general, chiar la ei. Compilarea
unui program se va finaliza numai după rezolvarea tuturor erorilor de sintaxă.
Puteți încerca să ștergeți caractere sau chiar linii întregi din programul „Hello world” pentru a vedea
diferite tipuri de erori care sunt generate. Încercați să restaurați punct și virgulă lipsă la sfârșitul
liniei 5, apoi ștergeți liniile 1, 3 sau 4 și vedeți ce se întâmplă.
Fara titlu
Acest lucru va funcționa dacă compilatorul dvs. are suport C ++ 17. Dacă utilizați o versiune mai
veche a funcțiilor Code :: Blocks și C ++ 17 nu par să funcționeze, actualizați compilatorul.
Stabilirea unui standard de limb ă în g ++

Fara titlu
Pentru GCC / G ++, puteți trece steagurile compilatorului -std = c ++ 11, -std = c ++ 14, -std = c
++ 17, sau -std = c ++ 2a pentru a activa C ++ 11/14 / Respectiv suport 17 / 2a.
1.1 - Declarații și structura unui program

DE ALEX PE 30 MAI 2007 | MODIFICAT ULTIMA DATĂ DE NASCARDRIVER LA 31 DECEMBRIE 2019
Capitolul introducere
Bine ați venit la primul capitol primar al acestor tutoriale C ++!
În acest capitol, vom arunca o primă privire asupra mai multor subiecte care sunt esențiale pentru
fiecare program C ++. Deoarece există destul de multe subiecte de abordat, vom acoperi cele mai
multe la un nivel destul de puțin adânc (doar suficient pentru a ne apropia). Scopul acestui capitol
este de a vă ajuta să înțelegeți modul în care sunt construite programe de bază C ++. Până la
sfârșitul capitolului, veți putea scrie propriile programe simple.
În capitolele viitoare, vom revizui majoritatea acestor subiecte și le vom explora mai detaliat. Vom
introduce, de asemenea, concepte noi care se bazează pe acestea.
Pentru a menține gestionarea lungimilor lecției, subiectele pot fi împărțite pe mai multe lecții
ulterioare. Dacă simți că un concept important nu este acoperit într-o lecție, este posibil să fie
acoperit în lecția următoare.
declaraţii
Un program de calculator este o secvență de instrucțiuni care spun computerului ce trebuie să
facă. O declarație este un tip de instrucțiune care determină programul să efectueze unele acțiuni .
Declarațiile sunt de departe cel mai comun tip de instrucțiune într-un program C ++. Acest lucru se
datorează faptului că sunt cea mai mică unitate independentă de calcul în limbajul C ++. În această
privință, ele acționează la fel cum fac propozițiile în limbajul natural. Când vrem să transmitem o
idee unei alte persoane, de obicei scriem sau vorbim în propoziții (nu în cuvinte sau în silabe
aleatorii). În C ++, când dorim ca programul nostru să facă ceva, de obicei scriem declarații.
Cele mai multe (dar nu toate) afirmații în C ++ se termină cu punct și virgulă. Dacă vedeți o linie
care se termină într-un punct și virgulă, este probabil o afirmație.
Într-un limbaj la nivel înalt, cum ar fi C ++, o singură declarație poate fi compilată în multe
instrucțiuni de limbaj mașină.
Există multe tipuri diferite de declarații în C ++:
1. Declarații
2. Declarații de salt
3. Enunțuri de expresie
4. Declarații compuse
5. Declarații de selecție (condiționale)
6. Declarații de iterație (bucle)
7. Încercați blocuri
Până când treceți cu această serie de tutorial, veți înțelege care sunt toate acestea!
Funcțiile și funcția principal ă (main)
În C ++, instrucțiunile sunt de obicei grupate în unități numite funcții. O funcție este o colecție de
declarații care se execută secvențial. Pe măsură ce înveți să-ți scrii propriile programe, vei putea să-
ți creezi propriile funcții și să amesteci și să asortezi declarații în orice fel dorești (îți vom arăta cum
ar fi într-o lecție viitoare).
Regulă
Fiecare program C ++ trebuie să aibă o funcție specială numită principală (main) (toate litere
mici). Când programul este rulat, execuția începe cu prima instrucțiune din interiorul
funcției principale și apoi continuă secvențial.
De obicei, programele se termină (termină rularea) atunci când ultima instrucțiune din
funcția principală este executată (deși pot avorta devreme în unele circumstanțe).
Funcțiile sunt de obicei scrise pentru a face o lucrare specifică. De exemplu, o funcție numită „max”
poate conține instrucțiuni care să indice care dintre două numere este mai mare. O funcție numită
„calcula grad” (calculateGrad) poate calcula nota unui student dintr-un set de scoruri de test. Vom
vorbi mult mai multe despre funcții în curând, deoarece sunt instrumentul de organizare cel mai des
utilizat într-un program.
Nota autorului
Când discutați funcții, este destul de comună scurtarea de a adăuga o pereche de paranteze la
sfârșitul numelui funcției. De exemplu, dacă vedeți termenul principal () sau doSomething () , acesta
este scurt pentru funcțiile numite principal sau respectiv doSomething . Acest lucru ajută la
diferențierea funcțiilor de alte tipuri de obiecte (cum ar fi variabile) fără a fi nevoie să scrieți
cuvântul „funcție” de fiecare dată.
Disecție Bună lume!

Acum că aveți o scurtă înțelegere despre ce sunt afirmațiile și funcțiile, să revenim la programul
nostru „Hello world” și să aruncăm o privire la nivel înalt la fiecare linie în detaliu.
2
3 int main()
4{
5 std::cout << "Hello world!";
6 return 0;
7}
Linia 1 este un tip special de linie numit directivă preprocesor. Această directivă a
preprocesorului indică faptul că am dori să folosim conținutul bibliotecii iostream (stream = curent,
in/out curent), care este partea bibliotecii standard C ++ care ne permite să citim și să scriem text
din / către consolă. Avem nevoie de această linie pentru a putea folosi std :: cout de pe linia 5.
Excluderea acestei linii ar duce la o eroare de compilare pe linia 5, întrucât compilatorul nu ar ști
altfel ce este std :: cout.
Linia 2 este goală și este ignorată de compilator. Această linie există doar pentru a ajuta programul
să fie mai lizibil pentru oameni (prin separarea directivei #include preprocesor și a părților ulterioare
ale programului).
Linia 3 spune compilatorului că vom scrie (defini) o funcție numită principal (main). După cum ați
aflat mai sus, fiecare program C ++ trebuie să aibă o funcție principală (main) sau nu va reuși să
compileze.
Liniile 4 și 7 spun compilatorului care linii fac parte din funcția principală . Totul dintre bretonul
ondulat de deschidere de pe linia 4 și bretonul ondulat de închidere de pe linia 7 este considerat
parte a funcției principale . Aceasta se numește corpul funcției.
Linia 5 este prima declarație din funcția principală (main) și este prima declarație care se va
executa atunci când vom rula programul nostru. std :: cout (care înseamnă „ieșire de caractere”)
și <<operatorul ne permite să trimitem scrisori (text) sau numere către consolă pentru a fi ieșite. În
acest caz, îi trimitem textul „Hello world!”, Care va fi transmis către consolă. Această afirmație
creează ieșirea vizibilă a programului.
Linia 6 este o declarație de retur (return = intoarcere). Când un program executabil termină
rularea, programul trimite o valoare înapoi la sistemul de operare pentru a indica dacă a rulat cu
succes sau nu. Această declarație de returnare particulară returnează valoarea 0 sistemului de
operare, ceea ce înseamnă „totul a mers bine!”. Aceasta este ultima declarație din programul care
se execută.
Toate programele pe care le scriem vor urma acest șablon general sau o variantă a acestuia.
Nota autorului
Dacă părțile (sau toate) din explicația de mai sus sunt confuze, acest lucru este de așteptat în acest
moment. Acest lucru a fost doar pentru a oferi o imagine de ansamblu rapidă. Lecțiile ulterioare vor
săpa în toate subiectele de mai sus, cu o mulțime de explicații și exemple suplimentare.
Puteți compila și rula acest program singur și veți vedea că acesta transmite următoarele către
consolă:
Salut Lume!
Dacă aveți probleme cu compilarea sau executarea acestui program, consultați lecția 0.8 - Câteva
probleme comune C ++ .
Erori de sintax ă și sintax ă

În limba engleză, propozițiile sunt construite în conformitate cu reguli gramaticale specifice pe care
probabil le-ați învățat în clasă de engleză în școală. De exemplu, propozițiile normale se termină
într-o perioadă. Regulile care guvernează modul de construire a propozițiilor într-un limbaj se
numește sintaxă . Dacă uitați perioada și executați două propoziții împreună, aceasta este o
încălcare a sintaxei limbii engleze.
C ++ are și o sintaxă: reguli despre modul în care programele dvs. trebuie construite pentru a putea
fi considerate valide. Când compilați programul dvs., compilatorul este responsabil să se asigure că
programul respectă sintaxa de bază a limbajului C ++. Dacă încălcați o regulă, compilatorul se va
plânge atunci când încercați să compilați programul dvs. și vă vor emite o eroare de sintaxă .
Să vedem ce se întâmplă dacă omitem punct și virgulă de pe linia 5 a programului „Hello world”,
astfel:
2
3 int main()
4{
5 std::cout << "Hello world!"
6 return 0;
7}
Simțiți-vă liber să compilați acest program prost format.
Visual Studio produce următoarea eroare (compilatorul dvs. poate genera un mesaj de eroare cu
formulare diferită):
c: \ vcprojects \ test1.cpp (6): eroare C2143: eroare de sintaxă: lipsește ';'

înainte de „întoarcere”
Acest lucru vă spune că aveți o eroare de sintaxă pe linia 6: compilatorul aștepta o virgulă înainte de
instrucțiunea de returnare, dar nu a găsit una. Deși compilatorul vă va spune ce linie de cod a fost
compilată când a întâlnit eroarea de sintaxă, omisiunea poate fi de fapt pe o linie anterioară. În
acest caz, eroarea este de fapt la sfârșitul liniei 5 (compilatorul nu a descoperit problema până la
linia 6).
Erorile de sintaxă sunt frecvente atunci când scrii un program. Din fericire, acestea sunt de obicei
simple pentru a găsi și repara, deoarece compilatorul vă va indica, în general, chiar la ei. Compilarea
unui program se va finaliza numai după rezolvarea tuturor erorilor de sintaxă.
Puteți încerca să ștergeți caractere sau chiar linii întregi din programul „Hello world” pentru a vedea
diferite tipuri de erori care sunt generate. Încercați să restaurați punct și virgulă lipsă la sfârșitul
liniei 5, apoi ștergeți liniile 1, 3 sau 4 și vedeți ce se întâmplă.
Timp de testare
Următorul chestionar este menit să vă consolideze înțelegerea materialului prezentat mai sus.
Intrebarea 1
Ce este o declaratie (statement)?
O declarație este o instrucțiune dintr-un program de computer care spune computerului să

efectueze o acțiune.
Intrebarea 2
Ce este o funcție?
O funcție este o colecție de declarații care se execută secvențial.
Întrebarea nr. 3
Care este numele funcției pe care trebuie să o aibă toate programele?
Principal (main)
Întrebarea nr. 4
Când este executat un program, de unde începe execuția?
Execuția începe cu prima declarație din funcția principală (main).
Întrebarea nr. 5
Cu ce simbol sunt des încheiate afirmațiile din C ++?
Semicolon ( ;)
Întrebarea # 6
Ce este o eroare de sintaxă?
O eroare de sintaxă este o eroare de compilare care apare la data de compilare când programul
dvs. încalcă regulile gramaticale ale limbajului C ++.
Întrebarea # 7
Ce este biblioteca standard C ++?
Lecția de revizuire 0,5 - Introducere în compilator, linker și biblioteci
Un fișier de bibliotecă este o colecție de cod precompilat care a fost „ambalat” pentru reutilizare
în alte programe. Biblioteca standard C ++ este o bibliotecă care se livrează cu C ++. Conține
funcționalități suplimentare pe care să le utilizați în programele dvs.
1.2 - Comentarii
DE ALEX PE 30 MAI 2007 | MODIFICAT ULTIMA DATĂ DE ALEX PE 12 IUNIE 2019
Un comentariu este o notă care poate fi citită de programator, care este introdusă direct în codul
sursă al programului. Comentariile sunt ignorate de compilator și sunt destinate numai utilizării
programatorului.
În C ++ există două stiluri diferite de comentarii, ambele îndeplinind același scop: de a ajuta
programatorii să documenteze codul într-un fel.
Comentarii cu o singur ă linie
//Simbolul începe un comentariu C ++ o singură linie, care spune compilatorului să ignore totul , de
la // simbol la capătul liniei. De exemplu:
1 std::cout << "Hello world!"; // Everything from here to the end of the line is ignored
De obicei, comentariul cu o singură linie este utilizat pentru a face un comentariu rapid despre o
singură linie de cod.
1 std::cout << "Hello world!\n"; // std::cout lives in the iostream library

2 std::cout << "It is very nice to meet you!\n"; // these comments make the code hard to read
3 std::cout << "Yeah!\n"; // especially when lines are different lengths
Dacă aveți comentarii la dreapta unei linii, puteți face atât codul cât și comentariul greu de citit, în
special dacă linia este lungă. Dacă liniile sunt destul de scurte, comentariile pot fi aliniate pur și
simplu (de obicei la un tab stop), astfel:
1 std::cout << "Hello world!\n"; // std::cout lives in the iostream library

2 std::cout << "It is very nice to meet you!\n"; // this is much easier to read
3 std::cout << "Yeah!\n"; // don't you think so?
Cu toate acestea, dacă liniile sunt lungi, plasarea de comentarii la dreapta vă poate face liniile cu
adevărat lungi. În acest caz, comentariile cu o singură linie sunt adesea plasate deasupra liniei pe
care o comentează:
1 // std::cout lives in the iostream library

2 std::cout << "Hello world!\n";
3
4 // this is much easier to read
5 std::cout << "It is very nice to meet you!\n";
6
7 // don't you think so?
8 std::cout << "Yeah!\n";
Nota autorului
Declarațiile de mai sus reprezintă primele noastre întâlniri cu fragmente de cod. Deoarece
fragmentele nu sunt programe complete, nu pot fi compilate de unul singur. Mai degrabă, există
pentru a demonstra concepte specifice într-o manieră concisă.
Dacă doriți să compilați un fragment, va trebui să îl transformați într-un program complet pentru a
putea fi compilat. De obicei, programul respectiv va arăta astfel:
2
3 int main()
4{
5 // Replace this line with the snippet of code you'd like to compile
6
7 return 0;
8}
Comentarii cu mai multe linii

/*Și */perechea de simboluri denota un stil C multi-line comentariu. Totul dintre simboluri este
ignorat.
1 /* This is a multi-line comment.

2 This line will be ignored.
3 So will this one. */
Deoarece totul dintre simboluri este ignorat, veți vedea uneori programatorii care „înfrumusețează”
comentariile lor din mai multe linii:
1 /* This is a multi-line comment.

2 * the matching asterisks to the left
3 * can make this easier to read
4 */
Comentariile în stil multi-linie nu pot fi cuibărite. În consecință, următoarele rezultate vor avea
rezultate neașteptate:
1 /* This is a multi-line /* comment */ this is not inside the comment */

2 // The above comment ends at the first */, not the second */
Când compilatorul încearcă să compileze acest lucru, va ignora totul, de la primul / * la primul
* /. Deoarece acest lucru nu se află în interiorul comentariului * / nu este considerat parte a
comentariului, compilatorul va încerca să-l compileze. Aceasta va duce inevitabil la o eroare de
compilare.
Acesta este un loc în care utilizarea unui evidențiator de sintaxă poate fi cu adevărat utilă, întrucât
colorarea diferită pentru comentariu ar trebui să clarifice ceea ce este considerat parte a
comentariului sau nu.
Avertizare
Nu folosiți comentarii cu mai multe linii în interiorul altor comentarii cu mai multe linii. Înfășurarea
comentariilor cu o singură linie într-un comentariu cu mai multe linii este în regulă.
Utilizarea corectă a comentariilor

De obicei, comentariile trebuie utilizate pentru trei lucruri. Pentru o anumită bibliotecă, program sau
funcție, comentariile sunt utilizate cel mai bine pentru a descrie ce face biblioteca, programul sau
funcția. Acestea sunt plasate de obicei în partea de sus a fișierului sau a bibliotecii, sau imediat
înainte de funcție. De exemplu:
1 // This program calculates the student's final grade based on his test and homework scores.
1 // This function uses newton's method to approximate the root of a given equation.
1 // The following lines generate a random item based on rarity, level, and a weight factor.
Toate aceste comentarii oferă cititorului o idee bună despre ce bibliotecă, program sau funcție
încearcă să îndeplinească fără a fi necesar să se uite la codul propriu-zis. Utilizatorul (eventual
altcineva sau dacă încercați să reutilizați codul pe care l-ați scris deja) poate spune dintr-o privire
dacă codul este relevant pentru ceea ce încearcă să realizeze. Acest lucru este deosebit de important
atunci când lucrează ca parte a unei echipe, unde nu toată lumea va fi familiarizată cu tot codul.
În al doilea rând, în cadrul unei biblioteci, program sau funcții descrise mai sus, comentariile pot fi
utilizate pentru a descrie modul în care codul își va îndeplini obiectivul.
1 /* To calculate the final grade, we sum all the weighted midterm and homework scores
2 and then divide by the number of scores to assign a percentage. This percentage is
3 used to calculate a letter grade. */
1 // To generate a random item, we're going to do the following:
2 // 1) Put all of the items of the desired rarity on a list
3 // 2) Calculate a probability for each item based on level and weight factor
4 // 3) Choose a random number
5 // 4) Figure out which item that random number corresponds to
6 // 5) Return the appropriate item
Aceste comentarii oferă utilizatorului o idee despre modul în care codul își va îndeplini obiectivul,
fără a fi necesar să înțeleagă ce face fiecare linie individuală de cod.
La nivel de declarație, comentariile ar trebui utilizate pentru a descrie de ce codul face ceva. Un
comentariu rău explică ce face codul. Dacă vreodată scrieți un cod atât de complex, care are nevoie
de un comentariu pentru a explica ce face o declarație, probabil că trebuie să rescrieți declarația, nu
să o comentați.
Iată câteva exemple de comentarii cu linii proaste și comentarii cu declarații bune.
Comentariu incorect:
1 // Set sight range to 0

2 sight = 0;
Motiv: Putem vedea deja că vederea este setată la 0 analizând afirmația

Comentariu bun:
1 // The player just drank a potion of blindness and can not see anything
2 sight = 0;
Motiv: Acum știm de ce vederea jucătorului este setată pe 0
Comentariu incorect:
1 // Calculate the cost of the items

2 cost = quantity * 2 * storePrice;
Motiv: Putem vedea că acesta este un calcul al costurilor, dar de ce se înmulțește cantitatea cu 2?
Comentariu bun:
1 // We need to multiply quantity by 2 here because they are bought in pairs

2 cost = quantity * 2 * storePrice;
Motiv: Acum știm de ce această formulă are sens.
Programatorii trebuie adesea să ia o decizie grea între rezolvarea unei probleme într-un fel sau
soluționarea ei într-un alt mod. Comentariile sunt o modalitate excelentă de a vă reaminti (sau de a
spune altcuiva) motivul pentru care ați luat o decizie în loc de alta.
Comentarii bune:
1 // We decided to use a linked list instead of an array because

2 // arrays do insertion too slowly.
1 // We're going to use Newton's method to find the root of a number because
2 // there is no deterministic way to solve these equations.
În cele din urmă, comentariile ar trebui să fie scrise într-un mod care să aibă sens pentru cineva
care habar nu are ce face codul. Adesea, un programator va spune „Este evident ce face asta! Nu
am cum să uit de asta ”. Ghici ce? Este nu evident, și va fi uimit cât de repede ati uitat. :) Voi (sau
altcineva) vă vom mulțumi mai târziu că ați scris ce, cum și de ce codul dvs. în limbajul
uman. Citirea liniilor de cod individuale este ușoară. Înțelegerea obiectivului pe care urmează să-l
îndeplinească nu este.
Comentați-vă codul în mod liberal și scrieți-vă comentariile ca și cum ar vorbi cu cineva care habar
nu are ce face codul. Nu presupuneți că vă veți aminti de ce ați făcut alegeri specifice.
Nota autorului
Pe tot restul acestei serii de tutorial, vom folosi comentarii în blocurile de coduri pentru a vă atrage
atenția asupra unor lucruri specifice sau pentru a vă ajuta să ilustrăm modul în care lucrurile
funcționează (asigurând în același timp programele). Cititorii Astute vor observa că, conform
standardelor de mai sus, majoritatea acestor comentarii sunt oribile. :) Pe măsură ce citiți restul
tutoriale, rețineți că comentariile servesc un scop educațional intenționat, nu încercând să
demonstrați cum arată comentariile bune.
Comentarea codului
Convertirea unuia sau a mai multor linii de cod într-un comentariu se numește comentarea codului
tău. Aceasta oferă o modalitate convenabilă de a exclude (temporar) părți din codul dvs. de a fi
incluse în programul compilat.
Pentru a comenta o singură linie de cod, pur și simplu folosiți comentariul în stil // pentru a
transforma temporar o linie de cod într-un comentariu:
Necomentat:
1 std::cout << 1;
Comentat:
1 // std::cout << 1;
Pentru a comenta un bloc de cod, utilizați // pe mai multe linii de cod sau comentariul / * * / în stil
pentru a transforma temporar blocul de cod într-un comentariu.
Necomentat:
1 std::cout << 1;
2 std::cout << 2;
3 std::cout << 3;
Comentat:
1 // std::cout << 1;
2 // std::cout << 2;
3 // std::cout << 3;
sau
1 /*
2 std::cout << 1;
3 std::cout << 2;
4 std::cout << 3;
5 */
Există câteva motive pentru care ar putea dori să faceți acest lucru:
1) Lucrezi la o nouă bucată de cod care nu va fi compilată încă și trebuie să rulezi

programul. Compilatorul nu vă permite să rulați dacă există erori ale compilatorului. Comentând
codul care nu va compila va permite programului să compileze, astfel încât să puteți rula. Când
sunteți gata, puteți decomanda codul și puteți continua să lucrați la acesta.
2) Ați scris un cod nou care să compileze, dar nu funcționează corect și nu aveți timp să îl remediați
până mai târziu. Comentariul codului rupt va asigura că codul rupt nu se execută și va cauza
probleme până când puteți remedia.
3) Pentru a găsi sursa unei erori. Dacă un program nu produce rezultatele dorite (sau se
prăbușește), uneori poate fi util să dezactivați părți din codul dvs. pentru a vedea dacă puteți izola
ceea ce face ca acesta să nu funcționeze corect. Dacă comentați una sau mai multe linii de cod și
programul dvs. începe să funcționeze așa cum vă așteptați (sau nu se mai prăbușește), șansele sunt
orice ați comentat ultima dată a făcut parte din problemă. Puteți cerceta de ce aceste linii de cod
cauzează problema.
4) Doriți să înlocuiți o bucată de cod cu o altă bucată de cod. În loc să ștergi doar codul inițial, poți
să-l comentezi și să-l lași acolo pentru referință, până când ești sigur că noul tău cod funcționează
corect. După ce sunteți sigur că noul dvs. cod funcționează, puteți elimina vechiul cod
comentat. Dacă nu poți să-ți funcționeze noul cod, poți oricând să ștergi noul cod și să dezarhivezi
codul vechi pentru a reveni la ceea ce ai avut înainte.
Comentarea codului este un lucru obișnuit de făcut în timpul dezvoltării, astfel încât multe IDE oferă
suport pentru comentarea unei secțiuni evidențiate de cod. Modul în care accesați această
funcționalitate variază în funcție de IDE.
Puteți să comentați sau să decomentați o selecție prin meniul Editare> Avansat> Selecție comentarii
(sau Selecție dezcomentare).
Puteți să comentați sau să decomentați o selecție prin meniul Editare> Comentariu (sau
Uncomment, sau Comutați comutare sau oricare dintre celelalte instrumente de comentarii).
Bacsis
Dacă utilizați întotdeauna comentarii cu o singură linie pentru comentariile dvs. normale, atunci
puteți utiliza întotdeauna comentarii cu mai multe linii pentru a comenta codul dvs. fără
conflict. Dacă utilizați comentarii cu mai multe linii pentru a vă documenta codul, atunci codul de
comentarii cu ajutorul comentariilor poate deveni mai dificil.
Dacă aveți nevoie să comentați un bloc de cod care conține comentarii cu mai multe linii, puteți, de
asemenea, să luați în considerare utilizarea directivei #i 0 preprocesor, pe care o discutăm în
lecția 2.10 - Introducere în preprocesor .
rezumat
 La biblioteca, programul sau funcția, utilizați comentarii pentru a descrie ce .
 În interiorul bibliotecii, programului sau funcției, utilizați comentarii pentru a descrie cum .
 La nivel de declarație, utilizați comentarii pentru a descrie de ce .
1.3 - Introducere în variabile

DE ALEX PE 30 MAI 2007 | MODIFICAT ULTIMA DATĂ DE ALEX LA 8 IULIE 2019
Date (Data)
În lecția 1.1 - Enunțuri și structura unui program , ați aflat că majoritatea instrucțiunilor dintr-
un program sunt declarații și că enunțurile sunt grupate în funcții. Aceste declarații efectuează
acțiuni care (sperăm) generează orice rezultat a fost proiectat pentru a produce programul.
Dar cum produc efectiv rezultatele programelor? Aceștia fac acest lucru prin manipularea (citirea,
schimbarea și scrierea) datelor. În calcul, datele sunt orice informații care pot fi mutate, procesate
sau stocate de un computer.
Informații cheie
Programele sunt colecții de instrucțiuni care manipulează datele pentru a produce un rezultat dorit.
Un program poate achiziționa date cu care să funcționeze în mai multe moduri: dintr-un fișier sau
bază de date, printr-o rețea, de la utilizatorul care furnizează introducerea pe o tastatură sau de la
programator, introducând datele direct în codul sursă al programului însuși. În programul „Hello
World” din lecția menționată mai sus, textul „Hello world!” A fost introdus direct în codul sursă al
programului, oferind date pentru utilizarea programului. Programul manipulează apoi aceste date
trimițându-le pe monitor pentru a fi afișate.
Datele de pe un computer sunt de obicei stocate într-un format care este eficient pentru stocare sau
procesare (și astfel nu poate fi citit de oameni). Astfel, atunci când este compilat programul „Hello
World”, textul „Hello world!” Este transformat într-un format mai eficient pentru programul de
utilizat (binar, despre care vom discuta într-o lecție viitoare).
Obiecte și variabile
Toate computerele au memorie, numită memorie RAM (scurtă pentru memorie cu acces aleatoriu),
care este disponibilă pentru utilizarea programelor dvs. Vă puteți gândi la RAM ca la o serie de
căsuțe poștale care pot fi utilizate pentru a reține date în timpul rulării programului. O singură
bucată de date, stocată în memorie undeva, se numește valoare .
În unele limbaje de programare mai vechi (cum ar fi Apple Basic), puteți accesa direct aceste căsuțe
poștale (o afirmație ar putea spune ceva de genul pentru a obține valoarea stocată în căsuța poștală
numărul 7532 ).
În C ++, accesul direct la memorie nu este permis. În schimb, accesăm memoria indirect printr-un
obiect. Un obiect este o regiune de stocare (de obicei memorie) care are o valoare și alte proprietăți
asociate (pe care le vom acoperi în lecțiile viitoare). Când un obiect este definit, compilatorul
stabilește automat unde va fi plasat obiectul în memorie. Drept urmare, mai degrabă decât say go,
obțineți valoarea stocată în căsuța poștală numărul 7532 , putem spune, mergeți să obțineți
valoarea stocată de acest obiect, iar compilatorul știe unde se află în memorie să caute acea
valoare. Aceasta înseamnă că ne putem concentra pe utilizarea obiectelor pentru a stoca și recupera
valorile și nu trebuie să ne facem griji cu privire la locul în care sunt amplasate de fapt.
Obiectele pot fi denumite sau fără nume (anonime). Un obiect numit se numește variabilă , iar
numele obiectului se numește identificator . În programele noastre, majoritatea obiectelor create
de noi vor fi variabile.
Nota autorului
În programarea generală, termenul obiect se referă de obicei la o variabilă, structură de date în

memorie sau funcție. În C ++, termenul obiect are o definiție mai restrânsă care exclude funcțiile.
Instantare variabilă
Pentru a crea o variabilă, folosim un fel de declarație specială numită definiție (vom clarifica ulterior
diferența dintre o declarație și o definiție).
Iată un exemplu de definire a unei variabile numită x:
1 int x; // defineste o variabila numita x, de tip int
În momentul compilării, atunci când compilatorul vede această afirmație, își face o notă în sine că
definim o variabilă, dându-i numele x și că este de tip int (mai mult pe tipuri într-un moment). Din
acel moment înainte (cu unele limitări despre care vom vorbi într-o lecție viitoare), ori de câte ori
compilatorul vede identificatorul x , va ști că facem referire la această variabilă.
Când programul este rulat (numit runtime ), variabila va fi instanțiată. Instantiation este un
cuvânt fantezist care înseamnă că obiectul va fi creat și atribuit o adresă de memorie. Variabilele
trebuie inițiate înainte de a putea fi utilizate pentru a stoca valori. De exemplu, să spunem că
variabila x este instanțiată la locația de memorie 140. Ori de câte ori programul folosește variabila x,
acesta va accesa valoarea în locația de memorie 140. Un obiect instantanat este numit uneori și
o instanță .
Tipuri de date
Până în prezent, am acoperit că variabilele sunt o regiune numită de stocare care poate stoca o
valoare a datelor (modul în care datele sunt stocate exact este un subiect pentru o lecție
viitoare). Un tip de date (mai des numit doar un tip ) spune compilatorului ce tip de valoare (de
exemplu, un număr, o literă, un text, etc ...) variabila va stoca.
În exemplul de mai sus, variabila noastră x a fost dată tip int , ceea ce înseamnă că variabila x va
reprezenta o valoare întreagă. Un număr întreg este un număr care poate fi scris fără o
componentă fracțională, cum ar fi 4, 27, 0, -2 sau -12. Pe scurt, putem spune că x este o variabilă
întreagă .
În C ++, tipul unei variabile trebuie cunoscut în timp de compilare (când programul este
compilat), iar acest tip nu poate fi schimbat fără recompilarea programului. Aceasta înseamnă că o
variabilă întreagă poate reține doar valori întregi. Dacă doriți să stocați un alt tip de valoare, va
trebui să utilizați o altă variabilă.
Integrele sunt doar unul dintre numeroasele tipuri pe care C ++ le acceptă. Din motive ilustrative,
iată un alt exemplu de definire a unei variabile utilizând tipul de date dublu :
1 double width; // define a variable named width, of type double, defineste o variabila numita width
(latime), de tipul dubl
C ++ vă permite, de asemenea, să vă creați propriile tipuri definite de utilizator. Este ceva ce vom
face mult în lecțiile viitoare și face parte din ceea ce face C ++ puternic.
Pentru aceste capitole introductive, ne vom adăuga cu variabile întregi, deoarece sunt conceptual
simple, dar vom explora multe dintre celelalte tipuri C ++ care trebuie oferite în curând.
Definirea mai multor variabile

Este posibil să definiți mai multe variabile de același tip într-o singură instrucțiune prin separarea
numelor cu virgulă. Următoarele 2 fragmente de cod sunt efectiv aceleași:
1 int a;
2
int b;
este la fel ca:
1 int a, b;
Când definiți mai multe variabile în acest fel, există două greșeli comune pe care noii programatori
tind să le facă (nici grave, deoarece compilatorul le va prinde și le va cere să le rezolvați):
Prima greșeală este aceea de a da fiecărei variabile un tip atunci când definești variabile în
succesiune.
1 int a, int b; // gresit (compiler error)
3 int a, b; // corect
A doua greșeală este să încercați să definiți variabile de diferite tipuri în aceeași afirmație, ceea ce
nu este permis. Variabilele de diferite tipuri trebuie definite în enunțuri separate.
int a, double b; // wrong (compiler error)

1
2
int a; double b; // correct (but not recommended)
3
4
// correct and recommended (easier to read)
5
6 int a;
7
double b;
Deși limba vă permite să faceți acest lucru, evitați să definiți mai multe variabile într-o singură
afirmație (chiar dacă sunt de același tip). În schimb, definiți fiecare variabilă într-o instrucțiune
separată (apoi folosiți un comentariu cu o singură linie pentru a documenta la ce este utilizată)
rezumat
În C ++, folosim variabile pentru a accesa memoria. Variabilele au un identificator, un tip și o
valoare (și alte atribute care nu sunt relevante aici). Tipul unei variabile este utilizat pentru a
determina cum trebuie interpretată valoarea în memorie.
În lecția următoare, vom analiza cum să oferim valori variabilelor noastre și cum să le folosim
efectiv.
Timp de testare
Intrebarea 1
Ce este datele?
Datele sunt orice secvență de simboluri (numere, litere etc.) care pot fi interpretate pentru a
însemna ceva.
Intrebarea 2
Care este o valoare?
O valoare este o singură bucată de date stocate în memorie.
Întrebarea nr. 3
Ce este o variabilă?
O variabilă este o regiune numită de memorie.
Întrebarea nr. 4
Ce este un identificator?
Un identificator este numele la care este accesată o variabilă.
Întrebarea nr. 5
Ce este un tip?
Un tip spune programului cum să interpreteze o valoare în memorie.
Întrebarea n. 6
Ce este un număr întreg?
Un număr întreg este un număr care poate fi scris fără o componentă fracțională.
1.4 - Alocare și inițializare variabilă
În lecția anterioară ( 1.3 - Introducere în variabile ), am abordat cum să definim o variabilă pe
care o putem folosi pentru a stoca valori. În această lecție, vom explora cum să punem valorile în
variabile și să le folosim.
Ca memento, iată un fragment scurt care alocă mai întâi o singură variabilă întreagă numită x , apoi
alocă alte două variabile întregi numite y și z :
1 int x; // define an integer variable named x, defineste o variabila numita x de tip intreg
2
int y, z; // defineste 2 variabile intregi, numite y si z
Alocare variabilă
După ce o variabilă a fost definită, îi puteți da o valoare (într-o declarație separată)
folosind operatorul = . Acest proces se numește alocare copie (sau doar atribuire ) pe scurt.
1 int width; // defineste o variabila de tip intreg, numita width (latime)

2
3
width = 5; // copiați alocarea valorii 5 în variabila (width) lățime
4
// acum variabila width (latime) are valoarea 5
Alocarea copiei (assignement) este numită astfel deoarece copiază valoarea din partea dreaptă
a operatorului = la variabila din partea stângă a operatorului. = Operatorul se numește operatorul
de atribuire .
Iată un exemplu în care folosim misiunea (assignment) de două ori:
2
3 int main()
4 {
5 int width;
6 width = 5; // copy assignment of value 5 into variable width
7
8 // variable width now has value 5
9
10 width = 7; // change value stored in variable width to 7
11
12 // variable width now has value 7
13
14 return 0;
15 }
Când alocăm valoarea 7 la lățimea variabilă , valoarea 5 care a existat anterior este
suprascrisă. Variabilele normale pot ține o singură valoare simultan.
Avertizare
Una dintre cele mai frecvente greșeli pe care le fac noi programatori este să confunde operatorul de
atribuire (=) cu operatorul de egalitate (==). Atribuirea (=) este utilizată pentru a atribui o valoare
unei variabile. Egalitatea (==) este utilizată pentru a testa dacă doi operanzi sunt egali ca valoare.
Copiere și inițializare direct ă

Un dezavantaj al alocării este că necesită cel puțin două declarații: una pentru a defini variabila și
alta pentru a atribui valoarea.
Aceste două etape pot fi combinate. Când o variabilă este definită, puteți furniza, de asemenea, o
valoare inițială pentru variabilă. Aceasta se numește inițializare .
C ++ acceptă trei moduri de bază de inițializare a unei variabile. În primul rând, putem
face inițializarea copiilor folosind un semn egal:
1 int width = 5; // copie initializarea valorii 5 in variabila width

La fel ca alocarea copiei, aceasta copiază valoarea din partea dreaptă a echivalentului cu variabila
creată pe partea stângă.
În al doilea rând, putem face o inițializare directă folosind paranteza.
1 int width( 5 ); // initializare directa a valorii 5 in variabila width

Pentru tipurile simple de date (cum ar fi numere întregi), copierea și inițializarea directă sunt în
esență aceleași. Dar pentru unele tipuri avansate, inițializarea directă poate performa mai bine decât
inițializarea copiilor. Înainte de C ++ 11, inițializarea directă a fost recomandată peste inițializarea
copiilor, în majoritatea cazurilor, din cauza impulsului de performanță.
Inițializare uniform ă în C ++ 11
Din păcate, inițializarea directă nu poate fi folosită pentru toate tipurile de inițializare. În încercarea
de a furniza un mecanism de inițializare mai consecvent, C ++ 11 a adăugat o nouă sintaxă pentru
inițializare directă numită inițializare brățară (numită și inițializare uniformă ) care utilizează
bretele cret:
1 int width{ 5 }; // initializarea bratara (uniforma) a valorii 5 in variabila widht

Inițializarea unei variabile cu bretele goale indică inițializarea zero. Inițializarea zero
inițializează, în general, variabila la zero (sau goală, dacă acest lucru este mai potrivit pentru un
anumit tip).
1 int width{}; // zero initialization to value 0, (initializare 0 la valoarea zero)

Inițializarea uniformă are avantajul suplimentar de a interzice conversiile „restrângeri”. Aceasta
înseamnă că dacă încercați să utilizați inițializarea uniformă pentru a inițializa o variabilă cu o
valoare pe care nu o poate ține în siguranță, compilatorul va arunca un avertisment sau o
eroare. De exemplu:
1 int width{ 4.5 }; // error: o variabila de tip intreg (int) nu poate tine o valoare non-intreg
În fragmentul de mai sus, încercăm să alocăm un număr (4.5) care are o parte fracționată (partea .
5) unei variabile întregi (care poate reține doar numere fără părți fracționate). Copierea și
inițializarea directă ar scădea partea fracționată, rezultând inițializarea valorii 4
în lățimea variabilă . Cu toate acestea, cu inițializarea uniformă, acest lucru va determina
compilatorul să emită o eroare (ceea ce este, în general, un lucru bun, deoarece pierderea datelor
este rar dorită).
Inițializează-ți întotdeauna variabilele după creare. Puteți găsi în cele din urmă cazuri în care doriți
să ignorați aceste sfaturi dintr-un motiv specific (de exemplu, o secțiune critică de performanță a
codului care folosește o mulțime de variabile) și este în regulă, atât timp cât alegerea se face în mod
deliberat.
Pentru mai multe discuții pe această temă, Bjarne Stroustrup (creatorul C ++) și Herb Sutter
(expert C ++) fac ei înșiși această recomandare aici .
Dacă utilizați un compilator compatibil C ++ 11, favorizați inițializarea uniformă.
Nota autorului
Multe dintre exemplele din această serie de tutoriale au fost scrise înainte de existența inițializării
uniforme și, prin urmare, mai folosesc copierea sau inițializarea directă. Lucrăm la actualizarea
acestor date. Vă rugăm să iertați lipsa noastră de respectare a celor mai bune practici în acest sens.
Î: C ++ oferă copiere, inițializare directă și uniformă și alocare copie. Există o misiune

directă sau uniformă?
Nu, C ++ nu acceptă o sintaxă de atribuire directă sau uniformă.
În C ++ 11, a fost adăugată atribuirea mutării, dar folosește aceeași sintaxă ca și alocarea
copiei. Acoperim atribuirea mișcărilor din capitolul despre indicatoare inteligente.
Î: Când ar trebui să inițializez cu {0} vs. {}?
Utilizați o valoare de inițializare explicită dacă utilizați efectiv acea valoare.
1 int x { 0 }; // initializare explicita la valoare 0

2
std::cout << x; // folosim acea valoare zero
Utilizați inițializarea zero dacă valoarea este temporară și va fi înlocuită.
1 int x{}; // initializare zero

2
std::cin >> x; // inlocuim imediat acea valoare (zero)
Inițializarea mai multor variabile

În ultima secțiune, am observat că este posibilă definirea mai multor variabile de același tip într-o
singură instrucțiune prin separarea numelor cu virgulă:
1 int a, b;
De asemenea, am observat că cele mai bune practici sunt evitarea acestei sintaxe în totalitate. Cu
toate acestea, din moment ce s-ar putea să întâlniți un alt cod care folosește acest stil, este totuși
util să vorbim puțin mai mult despre el, dacă nu aveți alt motiv decât să consolidați unele dintre
motivele pe care ar trebui să le evitați.
Puteți inițializa mai multe variabile definite pe aceeași linie:
1 int a = 5, b = 6; // initializare copiere

2 int c( 7 ), d( 8 ); // initializare directa
3
int e{ 9 }, f{ 10 }; // initializare uniforma (de preferat)
Din păcate, există o problemă comună care poate apărea atunci când programatorul încearcă din
greșeală să inițialeze ambele variabile utilizând o singură declarație de inițializare:
1 int a, b = 5; // gresit (a nu a fost initializata, ca variabila!)

2
3 int a = 5, b = 5; // corect
În afirmația de sus, variabila „a” va fi lăsată neinițializată, iar compilatorul se poate plânge sau
nu. Dacă nu, acesta este un mod minunat de a face programul dvs. să se prăbușească intermitent și
să producă rezultate sporadice. Vom discuta mai multe despre ce se întâmplă dacă utilizați în scurt
timp variabile neinitializate.
Cel mai bun mod de a ne aminti că acest lucru este greșit este să ia în considerare cazul inițializării
directe sau a inițializării uniforme:
1 int a, b( 5 );
2 int c, d{ 5 };
Acest lucru face să pară ceva mai clar că valoarea 5 este utilizată doar pentru inițializarea
variabilei b sau d , nu a sau c .
Timp de testare
Intrebarea 1
Care este diferența dintre inițializare și atribuire?
Initializarea ofera unei valori o variabila la momentul crearii. Atribuirea (Alocarea) conferă unei
variabile o valoare la un moment dat după crearea ei.
Intrebarea 2
Ce formă de inițializare ar trebui să utilizați (presupuneți că compilatorul dvs. este conform C ++

11)
Initializare uniforma.
1.5 - Introducere în iostream: cout, cin și endl
În această lecție, vom vorbi mai multe despre std :: cout, pe care l-am folosit în Hello
World! program pentru a scoate textul Hello World! la consolă. De asemenea, vom explora cum să
obținem informații de la utilizator, pe care le vom folosi pentru a face programele noastre mai
interactive.
Biblioteca iostream
Biblioteca iostream face parte din C ++ biblioteca standard , care se ocupă cu intrare de bază și
de ieșire. Vom folosi funcționalitatea din această bibliotecă pentru a obține intrare de la tastatură și
date de ieșire în consolă. Partea io a iostream înseamnă pentru intrare / ieșire .
Pentru a utiliza funcționalitatea definită în biblioteca iostream , trebuie să

includem antetul iostream în partea de sus a oricărui fișier de cod care utilizează conținutul definit
în iostream , ca atare:
2
3 // rest of code that uses iostream functionality here
std :: cout
Iostream Biblioteca conține câteva variabile predefinite pentru noi de a utiliza. Unul dintre cele mai
utile este std :: cout , care ne permite să trimitem date către consolă pentru a fi tipărite ca
text. cout înseamnă „ieșire de caractere”.
Ca amintire, iată programul nostru de tip Hello World :
#include <iostream> // for std::cout

1
2 int main()
3
4 {
5
6
std::cout << "Hello world!"; // print Hello world! to console
7
8
return 0;
}
În acest program, am inclus iostream, astfel încât să avem acces la std :: cout . În
cadrul funcției noastre principale , folosim std :: cout , împreună cu operatorul de inserare (<<) ,
pentru a trimite textul Hello lume! la consola care urmează să fie tipărită.
std :: cout nu poate tipări doar text, ci poate imprima și numere:

1
2 int main()
3
4 {
5
6
std::cout << 4; // print 4 to console
7
8
return 0;
}
Acest lucru produce rezultatul:
Poate fi, de asemenea, utilizat pentru a tipări valoarea variabilelor:

1
2
3
int main()
4 {
5
6
int x{ 5 }; // define integer variable x, initialized with value 5
7 std::cout << x; // print value of x (5) to console
8
return 0;
}
Acest lucru produce rezultatul:
Pentru a imprima mai mult de un lucru pe aceeași linie, operatorul de inserare (<<) poate fi
folosit de mai multe ori într-o singură declarație pentru a concatena (conecta împreună) mai
multe piese de ieșire. De exemplu:

1
2
3 int main()
4 {
5
6
std::cout << "Hello" << " world!";
7 return 0;
}
Acest program imprimă:
Salut Lume!
Iată un alt exemplu în care tipărim atât textul, cât și valoarea unei variabile în aceeași afirmație:

1
2 int main()
3
4 {
5
6
int x{ 5 };
7 std::cout << "x is equal to: " << x;
8
return 0;
}
Acest program imprimă:
x este egal cu: 5
std :: endl
La ce vă așteptați să imprime acest program?

1
2 int main()
3
4 {
5
6
std::cout << "Hi!";
7 std::cout << "My name is Alex.";
8
return 0;
}
S-ar putea să fiți surprins de rezultat:
Buna! Numele meu este Alex.
Declarațiile de ieșire separate nu duc la linii de ieșire separate pe consolă.
Dacă dorim să tipărim linii de ieșire separate către consolă, trebuie să spunem consolei când să
mutați cursorul pe linia următoare.
O modalitate de a face acest lucru este de a folosi std :: endl . La ieșirea cu std :: cout , std ::
endl tipărește un caracter newline în consolă (determinând cursorul să meargă la începutul liniei
următoare). În acest context, endl înseamnă „linie finală”.
De exemplu:
#include <iostream> // for std::cout and std::endl

1
2 int main()
3{
4
5 std::cout << "Hi!" << std::endl; // std::endl will cause the cursor to move to the
6 next line of the console
7 std::cout << "My name is Alex." << std::endl;
8
9
return 0;
}
Aceasta imprimă:
Bună!
Numele meu este Alex.
Bacsis
În programul de mai sus, al doilea std :: endl nu este necesar din punct de vedere tehnic,
deoarece programul se încheie imediat după aceea. Cu toate acestea, servește două scopuri utile: în
primul rând, ajută la indicarea faptului că linia de ieșire este o „gândire completă”. În al doilea rând,
dacă mai târziu vrem să adăugăm declarații de ieșire suplimentare, nu trebuie să modificăm codul
existent. Putem doar să le adăugăm.
std :: endl vs '\ n'

Folosirea std :: endl poate fi un pic ineficientă, deoarece face de fapt două lucrări: mută cursorul pe
linia următoare și „înroșește” ieșirea (asigură-te că va apărea imediat pe ecran). Atunci când scrii
text pe consolă folosind std :: cout, std :: cout de obicei șterge ieșirea (și, dacă nu, de obicei, nu
contează), astfel încât std :: endl flush este rar important.
Din această cauză, utilizarea caracterului „\ n” este de obicei preferată în loc. Caracterul '\ n'
mută cursorul pe linia următoare, dar nu face efectul redundant, astfel încât să funcționeze mai
bine. De asemenea, caracterul „\ n” tinde să fie mai ușor de citit, deoarece este atât mai scurt, cât
și poate fi încorporat în textul existent.
Iată un exemplu care folosește „\ n” în două moduri diferite:
1
2 int main()
3{
4
5 int x{ 5 };
6 std::cout << "x is equal to: " << x << '\n'; // Using '\n' standalone
7
8 std::cout << "And that's all, folks!\n"; // Using '\n' embedded into a double-
9 quoted piece of text (note: no single quotes when used this way)
return 0;
}
Aceasta imprimă:
x este egal cu: 5

Și asta e tot, oameni buni!
Rețineți că atunci când „\ n” este folosit de unul singur pentru a muta cursorul pe linia următoare,
este nevoie de ghilimele unice. Când este încorporat într-un text care este are ghilimele duble ” ”,
nu sunt necesare ghilimelele unice.
Vom acoperi ceea ce „\ n” este mai detaliat când vom ajunge la lecția despre caractere ( 4.11 -
Chars ).
Preferați „\ n” pentru std :: endl atunci când trimiteți text către consolă.
Avertizare
„\ n” folosește o versiune inversă (la fel ca toate caracterele speciale din C ++), nu o tăiere
înainte. Folosirea unei tăieturi înainte (de ex. '/ N') poate duce la un comportament neașteptat.
std :: cin
std :: cin este o altă variabilă predefinită care este definită în biblioteca iostream . În timp ce
std :: cout imprimă date către consolă folosind operatorul de inserare (<<),
std :: cin (care înseamnă „intrare de caractere”) citește intrarea de la tastatură

folosind operatorul de extracție (>>) . Intrarea trebuie stocată într-o variabilă pentru a fi
utilizată.
#include <iostream> // for std::cout and std::cin
1 int main()
2
3
{
4 std::cout << "Enter a number: "; // ask user for a number
5 int x{ }; // define variable x to hold
6 user input (and zero-initialize it)
7
8 std::cin >> x; // get number from keyboard
9 and store it in variable x
10 std::cout << "You entered " << x << '\n';
return 0;
}
Încercați să compilați acest program și să-l executați singur. Când rulați programul, linia 5 va
imprima „Introduceți un număr:„. Când codul va ajunge la linia 7, programul vă va aștepta să
introduceți intrare. După ce introduceți un număr (și apăsați Enter), numărul pe care îl introduceți
va fi atribuit variabilei x . În sfârșit, pe linia 8, programul va imprima „Ați introdus” urmat de
numărul pe care tocmai l-ați introdus.
De exemplu (am introdus 4):
Introduceți un număr: 4
Ai intrat pe 4
Acesta este un mod ușor de a obține introducerea tastaturii de la utilizator și îl vom folosi în multe
dintre exemplele noastre care urmează. Rețineți că nu este necesar să folosiți '\ n' atunci când
acceptați introducerea, deoarece utilizatorul va trebui să apese pe tasta Enter pentru a primi
intrarea lor, iar acest lucru va muta cursorul la linia următoare.
Dacă ecranul dvs. se închide imediat după introducerea unui număr, consultați lecția 0.8 -
Câteva probleme comune C ++ pentru o soluție.
Există unele dezbateri cu privire la necesitatea inițializării unei variabile imediat înainte de a-i da o
valoare furnizată de utilizator printr-o altă sursă (de exemplu, std :: cin), deoarece valoarea oferită
de utilizator va suprascrie doar valoarea de inițializare. În conformitate cu recomandarea noastră
anterioară pentru ca variabilele să fie întotdeauna inițializate, cea mai bună practică este inițializarea
mai întâi a variabilei.
Vom discuta despre modul în care std :: cin gestionează intrările nevalide într-o lecție viitoare
( 5.10 - std :: cin, extragere și abordarea de introducere de text nevalide ).
Biblioteca Cost + iostream nu oferă o modalitate de a accepta introducerea tastaturii fără ca

utilizatorul să fie nevoit să apese Enter . Dacă acest lucru doriți, va trebui să utilizați o bibliotecă
terță parte. Pentru aplicațiile de consolă, recomandăm biblioteca pdcurses . Multe biblioteci
grafice pentru utilizatori au propriile lor funcții pentru a face acest tip de lucru.
rezumat
Programatorii noi amestecă adesea std :: cin, std :: cout, operatorul de inserare (<<) și operatorul
de extracție (>>). Iată un mod ușor de reținut:
 std :: cin și std :: cout merg mereu pe partea stângă a afirmației.
 std :: cout este folosit pentru a ieși o valoare (cout = ieșire de caractere)
 std :: cin este folosit pentru a obține o valoare de intrare (cin = intrare de caractere)
 << este folosit cu std :: cout și arată direcția în care se mișcă datele (dacă std :: cout
reprezintă consola, datele de ieșire se mută de la variabilă la consolă). std::cout << 4
moves the value of 4 to the console
 >> este folosit cu std :: cin și arată direcția în care se mișcă datele (dacă std :: cin
reprezintă tastatura, datele de intrare se mută de la tastatură la variabilă).
std::cin >> x moves the value the user entered from the keyboard into x
Vom vorbi mai multe despre operatorii din lecția 1.8 - Introducere în literale și
operatori .
Timp de testare
Intrebarea 1
Luați în considerare următorul program pe care l-am folosit mai sus:
1 #include <iostream> // for std::cout and std::cin
2
3 int main()
4 {
5 std::cout << "Enter a number: "; // ask user for a number
6 int x{}; // define variable x to hold user

input
7
std::cin >> x; // get number from keyboard and
8 store it in variable x
9 std::cout << "You entered " << x << '\n';
1 return 0;
0 }
Programul se așteaptă să introduceți o valoare întreagă, deoarece variabila x în care va fi introdusă
intrarea utilizatorului este o variabilă întreagă.
Rulați acest program de mai multe ori și descrieți ce se întâmplă atunci când introduceți următoarele
tipuri de input:
a) O scrisoare, cum ar fi h
x este 0.
b) Un număr cu o componentă fracțională. Încercați numerele cu componente fracționale mai mici

de 0,5 și mai mari de 0,5 (de exemplu, 3.2 și 3.7 ).
Componenta fracțională este scăzută.
c) Un număr întreg negativ mic, cum ar fi -3
Acest lucru merge bine.
d) Un cuvânt, cum ar fi Hello
x este 0.
e) Un număr foarte mare (cel puțin 3 miliarde)
Obțineți un număr aparent aleatoriu.

Ultima sugestie poate fi deosebit de surprinzătoare. Incearca-l! Acest lucru se întâmplă deoarece x
poate reține doar numere până la o anumită dimensiune. După aceea, „se revărsă”. Vom discuta
despre revărsare într-o lecție viitoare.
1.6 - variabile neinitializate și comportament

nedefinit
Variabilele inițializate
Spre deosebire de unele limbaje de programare, C / C ++ nu inițializează majoritatea variabilelor la
o anumită valoare (cum ar fi zero) automat. Astfel, atunci când compilatorului i se atribuie o locație
de memorie de către compilator, valoarea implicită a acelei variabile este orice valoare (gunoi) se
întâmplă să fie deja în acea locație de memorie! O variabilă căreia nu i s-a dat o valoare cunoscută
(de obicei prin inițializare sau alocare) se numește variabilă neinițializată .
Nota autorului
Mulți cititori se așteaptă ca termenii „inițializați” și „neiniționați” să fie opuși stricți, dar nu sunt
destul de mulți! Initializare inseamna ca obiectului i s-a oferit o valoare initiala la punctul de
definitie. Neinițializat înseamnă că obiectului nu i s-a dat o valoare cunoscută (prin orice mijloace,
inclusiv alocare). Prin urmare, un obiect care nu este inițializat, dar i se atribuie apoi o valoare nu
mai este neinițializat (deoarece i s-a dat o valoare cunoscută).
A recapitula:
 Inițializare = Obiectului i se oferă o valoare cunoscută la punctul de definire.

 Atribuire = Obiectului i se oferă o valoare cunoscută dincolo de punctul de definire.
 Neinițializat = Obiectului nu i s-a dat încă o valoare cunoscută.
Ca o paranteza...
Această lipsă de inițializare este o optimizare a performanței moștenită de la C, atunci când

calculatoarele erau lente. Imaginați-vă un caz în care urmați să citiți 100.000 de valori dintr-un
fișier. În acest caz, puteți crea 100.000 de variabile, apoi completați-le cu date din fișier.
Dacă C ++ a inițializat toate acele variabile cu valori implicite la creare, aceasta ar avea ca rezultat
100.000 inițializări (ceea ce ar fi lent), și pentru un avantaj redus (deoarece oricum scrieți acele
valori).
Deocamdată, ar trebui să vă inițializați întotdeauna variabilele, deoarece costul în acest sens este
minim în comparație cu beneficiul. Odată ce sunteți mai confortabil cu limba, pot exista anumite
cazuri în care omiteți inițializarea în scopuri de optimizare. Dar acest lucru trebuie făcut întotdeauna
selectiv și intenționat.
Utilizarea valorilor variabilelor neinițializate poate duce la rezultate neașteptate. Luați în considerare
următorul program scurt:
#include <iostream>
1
2 int main()
3
4 {
5 // define an integer variable named x
6 int x; // this variable is uninitialized because we haven't given it a value
7
8 // print the value of x to the screen
9
10 std::cout << x; // who knows what we'll get, because x is uninitialized
11
12 return 0;
}
În acest caz, computerul va atribui o memorie neutilizată lui x . Va trimite apoi valoarea rezidențiată
în locația de memorie către std :: cout , care va imprima valoarea (interpretată ca un număr
întreg). Dar ce valoare va tipări? Răspunsul este „cine știe!”, Iar răspunsul se poate schimba (sau
nu) de fiecare dată când rulați programul. Când autorul a executat acest program în Visual
Studio, std :: cout a imprimat valoarea 7177728o dată și 5277592alta. Nu ezitați să compilați și să
executați singur programul (computerul dvs. nu va exploda).
Ca o paranteza...
Unii compilatori, cum ar fi Visual Studio, vor inițializa conținutul memoriei la o anumită valoare
prestabilită atunci când utilizați o configurație de construire de depanare. Acest lucru nu se va
întâmpla atunci când utilizați o configurație de compilare a versiunii. Prin urmare, dacă doriți să
rulați singur programul de mai sus, asigurați-vă că utilizați o configurație de compilare
a versiunilor (vezi lecția 0.9 - Configurarea compilatorului: Creează configurații pentru un
memento despre cum să faci asta). De exemplu, dacă rulați programul de mai sus într-o configurație
de depanare Visual Studio, acesta va tipări constant -858993460, deoarece aceasta este valoarea
(interpretată ca un număr întreg) cu care Visual Studio inițializează memoria în configurațiile de
depanare.
Majoritatea compilatoarelor moderne vor încerca să detecteze dacă o variabilă este folosită fără să i
se dea o valoare. Dacă sunt capabili să detecteze acest lucru, în general vor emite o eroare de
compilare. De exemplu, compilarea programului de mai sus pe Visual Studio a produs următorul
avertisment:
c:\VCprojects\test\test.cpp(11) : warning C4700: uninitialized local variable 'x'

used
Dacă compilatorul dvs. nu vă va permite să compilați și să rulați programul de mai sus din acest
motiv, iată o posibilă soluție pentru a rezolva această problemă:
#include <iostream>
void doNothing(const int &x) // Don't worry about what &x is for now, we're just using it
1
2 to trick the compiler into thinking variable x is used
3 {
4
5 }
6
7 int main()
8
9 {
10 // define an integer variable named x
11
12
int x; // this variable is uninitialized
13
14 doNothing(x); // make compiler think we're using this variable
15
16 // print the value of x to the screen (who knows what we'll get, because x is uninitialized)
17
18 std::cout << x;
return 0;
}
Folosirea variabilelor neinițializate este una dintre cele mai frecvente greșeli pe care le fac
programatorii începători și, din păcate, poate fi și una dintre cele mai dificile debuguri (deoarece
programul poate rula bine oricum, dacă valoarea neinițializată s-a întâmplat să fie atribuită unui loc
de memorie. care avea o valoare rezonabilă în ea, cum ar fi 0).
Acesta este motivul principal pentru cele mai bune practici „inițializează-ți mereu variabilele”.
Comportament nedefinit
Utilizarea valorii dintr-o variabilă neinițializată este primul nostru exemplu de comportament
nedefinit. Comportamentul nedefinit este rezultatul executării codului al cărui comportament nu
este bine definit de limbajul C ++. În acest caz, limba C ++ nu are nicio regulă care să determine ce
se întâmplă dacă utilizați valoarea unei variabile căreia nu i s-a dat o valoare cunoscută. În
consecință, dacă efectuați acest lucru, va rezulta un comportament nedefinit.
Codul care implementează un comportament nedefinit poate prezenta oricare dintre următoarele
simptome:
 Programul dvs. produce rezultate diferite de fiecare dată când este executat.
 Programul dvs. produce constant același rezultat incorect.
 Programul dvs. se comportă în mod inconsistent (uneori produce rezultatul corect, alteori
nu).
 Programul dvs. pare să funcționeze, dar produce rezultate incorecte mai târziu în program.
 Programul dvs. se prăbușește, imediat sau mai târziu.
 Programul dvs. funcționează pe unele compilatoare, dar nu pe altele.
 Programul dvs. funcționează până când schimbați un alt cod aparent fără legătură.
Sau, oricum, codul dvs. poate produce un comportament corect. Natura comportamentului nedefinit
este faptul că nu știi niciodată destul de bine ceea ce vei obține, dacă îl vei obține de fiecare dată și
dacă acest comportament se va schimba atunci când faci alte modificări.
C ++ conține multe cazuri care pot duce la un comportament nedefinit dacă nu ești atent. Le vom
evidenția în lecțiile viitoare ori de câte ori le vom întâlni. Rețineți unde sunt aceste cazuri și
asigurați-vă că le evitați.
Regulă
Aveți grijă să evitați toate situațiile care duc la un comportament nedefinit, cum ar fi utilizarea unor
variabile neinitializate.
Nota autorului
Unul dintre cele mai frecvente tipuri de comentarii pe care le primim de la cititori spune: „Ați spus că
nu pot face X, dar am făcut-o oricum și programul meu funcționează! De ce?".
Există două răspunsuri comune. Cel mai frecvent răspuns este că programul dvs. prezintă de fapt un
comportament nedefinit, dar acel comportament nedefinit se întâmplă să producă rezultatul dorit
oricum ... deocamdată. Mâine (sau pe un alt compilator sau mașină) s-ar putea să nu fie.
În mod alternativ, uneori, autorii compilatorului iau libertăți cu cerințele de limbă atunci când aceste
cerințe pot fi mai restrictive decât este necesar. De exemplu, standardul poate spune „trebuie să
faceți X înainte de Y”, dar un autor al compilatorului poate simți că nu este necesar și face ca Y să
funcționeze chiar dacă nu faceți X mai întâi. Acest lucru nu ar trebui să afecteze funcționarea corectă
a programelor scrise, dar poate duce la funcționarea oricăror programe scrise incorect. Așadar, un
răspuns alternativ la întrebarea de mai sus este că este posibil ca compilatorul dvs. să nu urmeze
standardul! S-a întâmplat. Puteți evita o mare parte din aceasta asigurându-vă că ați oprit extensiile
compilatorului, așa cum este descris în lecția 0.10 - Configurarea compilatorului: Extensii
compilatoare .
Timp de testare
Intrebarea 1
Ce este o variabilă neinitializată? De ce ar trebui să evitați utilizarea acestora?
O variabilă neinițializată este o variabilă căreia programul nu a primit o valoare (în general prin
inițializare sau alocare). Utilizarea valorii stocate într-o variabilă neinițializată va duce la un
comportament nedefinit.
Intrebarea 2
Ce este un comportament nedefinit și ce se poate întâmpla dacă faci ceva care prezintă un
comportament nedefinit?
Comportamentul nedefinit este rezultatul executării codului al cărui comportament nu este bine
definit de limbă. Rezultatul poate fi aproape orice, inclusiv ceva care se comportă corect.
1.7 - Cuvinte cheie și identificatori de denumire
Cuvinte cheie
C ++ își rezervă un set de 84 de cuvinte (de la C ++ 17) pentru uz propriu. Aceste cuvinte se
numesc cuvinte cheie (sau cuvinte rezervate) și fiecare dintre aceste cuvinte cheie are un sens
special în limba C ++.
Iată o listă a tuturor cuvintelor cheie C ++ (prin C ++ 17):
alignas (C++11) decltype (C++11) namespace struct

alignof (C++11) default new switch
and delete noexcept (C++11) template
and_eq do not this
asm double not_eq thread_local (C++11)
auto dynamic_cast nullptr (C++11) throw
bitand else operator true
bitor enum or try
bool explicit or_eq typedef
break export private typeid
case extern protected typename
catch false public union
char float register unsigned
char16_t (C++11) for reinterpret_cast using
char32_t (C++11) friend return virtual
class goto short void
compl if signed volatile
const inline sizeof wchar_t
constexpr (C++11) int static while
const_cast long static_assert (C++11) xor
continue mutable static_cast xor_eq
Cuvintele cheie marcate (C ++ 11) au fost adăugate în C ++ 11. Dacă compilatorul dvs. nu respectă
C ++ 11 (sau are funcționalitate C ++ 11, dar este oprit implicit), este posibil ca aceste cuvinte
cheie să nu fie funcționale.
C ++ 11 adaugă, de asemenea, doi identificatori speciali: override si final. Acestea au un sens

specific atunci când sunt utilizate în anumite contexte, dar nu sunt rezervate.
Ați deja dat peste unele dintre aceste cuvinte cheie, inclusiv int și return . Alături de un set de
operatori, aceste cuvinte cheie și identificatori speciali definesc întregul limbaj al C ++ (comenzile
preprocesorului sunt excluse). Deoarece cuvintele cheie și identificatorii speciali au o semnificație
specială, IDE-urile dvs. vor schimba probabil culoarea textului acestor cuvinte (deseori la albastru)
pentru a le face să se distingă de alți identificatori.
Până la sfârșitul acestui serial, veți înțelege ce fac aproape toate aceste cuvinte!
Reguli de denumire a identificatorului

Ca memento, numele unei variabile (sau funcții, tip sau alt tip de articol) se numește
identificator. C ++ vă oferă multă flexibilitate pentru a identifica identificatorii așa cum doriți. Cu
toate acestea, există câteva reguli care trebuie respectate la numirea identificatorilor:
 Identificatorul nu poate fi un cuvânt cheie. Cuvintele cheie sunt rezervate.

 Identificatorul poate fi format numai din litere (minuscule sau majuscule), numere și
caracterul sublinieri (underline/underscore (_)). Asta înseamnă că numele nu poate conține
simboluri (cu excepția sublinierii) și nici spațiu alb (spații sau file).
 Identificatorul trebuie să înceapă cu o literă (litera mica sau majuscule (litera mare)) sau cu o
notă subliniată. Nu poate începe cu un număr.
 C ++ este sensibilă între litere mici și majuscule și, astfel, face distincție între litere mici și
majuscule nvalue este diferit decât nValue este diferit decât NVALUE.
Identificarea numirii celor mai bune practici
Acum că știi cum poți numi o variabilă, hai să vorbim despre cum ar trebui să numești o variabilă
(sau o funcție).
În primul rând, este o convenție în C ++, ca numele variabilelor să înceapă cu litere mici. Dacă
numele variabilei este un singur cuvânt, totul trebuie scris cu litere mici.
1 int value; // correct

2
3 int Value; // incorrect (trebuie sa inceapa cu litera mica)
4 int VALUE; // incorrect (trebuie sa inceapa cu litera mica)
5
int VaLuE; // incorrect (see your psychiatrist) ;)
Cel mai adesea, numele funcțiilor sunt de asemenea începute cu o literă mică (deși există un
anumit dezacord în acest sens). Vom urma această convenție, întrucât funcția principală (main) (pe
care trebuie să o aibă toate programele) începe cu o literă mică, la fel ca toate funcțiile din biblioteca
standard C ++.
Numele de identificare care încep cu majusculă sunt de obicei utilizate pentru tipuri definite de
utilizator (cum ar fi structuri, clase și enumerari, pe care le vom acoperi mai târziu).
Dacă variabila sau denumirea funcției este cu mai multe cuvinte, există două convenții obișnuite:
separate prin scări mici sau intercalate (uneori numite camelCase, din moment ce literele majuscule
se lipesc ca cocoașele pe o cămilă).
int my_variable_name; // correct (separate de underscore/underline)

1 int my_function_name(); // correct (separate de underscore/underline)
2
3
4 int myVariableName; // correct (intercapped/CamelCase)
5 int myFunctionName(); // correct (intercapped/CamelCase)
6
7
8 int my variable name; // invalid (spatiu intre cuvinte nu este permis)
9 int my function name(); // invalid (spatiu intre cuvinte nu este permis)
10
11 int MyVariableName; // valid dar incorrect (trebuie sa inceapa cu litera mica)
int MyFunctionName(); // valid dar incorrect (trebuie sa inceapa cu litera mica)
În acest tutorial, vom folosi în mod obișnuit abordarea interconectată, deoarece este mai ușor de
citit (este ușor să greșești o subliniere pentru un spațiu în blocuri dense de cod). Dar este obișnuit
să vedem fie - biblioteca standard C ++ folosește metoda de subliniere atât pentru variabile, cât și
pentru funcții. Uneori, veți vedea un amestec dintre cele două: schemele scrise folosite pentru
variabile și intercaps utilizate pentru funcții.
Este demn de remarcat faptul că dacă lucrați în codul altcuiva, în general, este considerat mai bine
să se potrivească stilului codului în care lucrați, decât să respectați în mod riguros convențiile de
denumire prevăzute mai sus.
Când lucrați într-un program existent, utilizați convențiile programului respectiv (chiar dacă nu se
conformează celor mai bune practici moderne). Folosiți cele mai bune practici moderne când scrieți
programe noi.
În al doilea rând, ar trebui să evitați numirea identificatorilor dvs. începând cu _

subliniere/underline, deoarece aceste nume sunt rezervate de obicei pentru sistem de operare,
bibliotecă și / sau compilare.
În al treilea rând, identificatorii dvs. ar trebui să clarifice ce înseamnă valoarea pe care o dețin (în
special dacă unitățile nu sunt evidente). Identificatorii ar trebui să fie numiți într-un mod care să
ajute pe cineva care habar nu are ce codul tău poate să-și dea seama cât mai repede posibil. În 3
luni, când te uiți din nou la programul tău, ai uitat cum funcționează și îți vei mulțumi că ai ales
nume variabile care au sens.
Totuși, acordarea unei variabile banale cu un nume excesiv de complex împiedică înțelegerea
generală a ceea ce face programul aproape la fel de mult, încât să dea un nume inadecvat unui
identificator larg utilizat. Prin urmare, o regulă bună este de a face lungimea unui identificator
proporțional cu cât de larg este utilizat. Un identificator cu o utilizare banală poate avea un nume
scurt (de exemplu, x ). Un identificator care este utilizat mai larg (de exemplu, o funcție care este
numită in mai multe locuri diferite dintr-un program) ar trebui să aibă un nume mai lung și mai
descriptiv (de exemplu, în loc de open , încercați openFileOnDisk ).
int ccount Rău Ce înseamnă c înainte de „numărare”?
int customerCount Bun Șterge ce contează
int i Fie Bine, dacă utilizarea este banală, altfel rău
int index Fie Bine, dacă este evident ce facem indexarea
int totalScore Fie Bine, dacă este marcat un singur lucru, altfel prea ambiguu
int _count Rău Nu începeți nume variabile cu subliniere
int count Fie Bine, dacă e evident ce contează
int data Rău Ce fel de date?
int time Rău Acest lucru este în câteva secunde, minute sau ore?
int minutesElapsed Bun Descriptiv
int value1, value2 Fie Poate fi greu de diferențiat între cele două
int numApples Bun Descriptiv
int monstersKilled Bun Descriptiv
int x, y Fie Bine, dacă utilizarea este banală, altfel rău
În cele din urmă, un comentariu clarificator poate merge mult. De exemplu, să spunem că am
declarat o variabilă numită numberOfChars care ar trebui să stocheze numărul de caractere într-o
bucată de text. Textul „Hello World!” Are 10, 11 sau 12 caractere? Depinde dacă includem spațiul
alb sau punctuația. Mai degrabă decât numirea
variabila numberOfCharsIncludingWhitespaceAndPunctuation , care este destul de lungă, un
comentariu bine plasat pe linia de declarație ar trebui să ajute cifra de utilizator - l:
1 // deține un număr de caractere într-o bucată de text - inclusiv spațiul alb și punctuația!
2 int numberOfChars;
Timp de testare
Intrebarea 1
Pe baza modului în care ar trebui să numiți o variabilă, indicați dacă fiecare nume de variabilă este
corect (urmează convenția), incorect (nu respectă convenția) sau invalid (nu va compila) și de ce.
int sum; Corect.
int _apples; Incorecte - numele variabilelor nu ar trebui să înceapă cu o subliniere.
int VALUE; Incorecte - numele variabilelor ar trebui să înceapă cu o litere mică.
int my variable name; Invalide - numele variabile nu pot conține spații.
int TotalCustomers; Incorecte - numele variabilelor ar trebui să înceapă cu o litere mică.
int void; Invalid - void este un cuvânt cheie.

int numFruit; Corect.
int 3some; Invalid - numele variabile nu pot începe cu un număr.
int meters_of_pipe; Corect.
1.8 - Introducere în literale și operatori

Literali
Luați în considerare următoarele două afirmații:
1 std::cout<< "Hello world!";

2
int x{ 5 };
Ce sunt „Hello world!” Și 5 ? Sunt literale. O literală (cunoscută și sub numele de constantă
literală ) este o valoare fixă care a fost introdusă direct în codul sursă.
Literalele și variabilele au ambele o valoare (și un tip). Cu toate acestea, valoarea unui literal este
fixă și nu poate fi modificată (de aici fiind numită constantă), în timp ce valoarea unei variabile
poate fi modificată prin inițializare și atribuire.
operatorii
În matematică, o operație este un calcul matematic care implică zero sau mai multe valori de
intrare (numiti operanzi ) care produce o nouă valoare (numită valoare de ieșire). Operația
specifică care trebuie efectuată este notată de o construcție (de obicei un simbol sau o pereche de
simboluri) numită operator .
De exemplu, ca copii, învățăm cu toții că 2 + 3 este egal cu 5 . În acest caz, literalele 2 și 3 sunt
operanzi, iar simbolul + este operatorul care ne spune să aplicăm adunare matematică pe
operanzi pentru a produce noua valoare 5 .
Nota autorului
Din motive care vor deveni clare atunci când discutăm despre operatori mai detaliat, pentru
operatorii care sunt simboluri, este o nomenclatură comună să atașeze
simbolul operatorului cuvântului operator .
De exemplu, operatorul plus se va numi operator + , iar operatorul de extracție se va numi operator
>> .
Probabil că sunteți deja familiarizați cu operatorii standard de aritmetică din utilizarea comună în
matematică, inclusiv adunarea (+), scăderea (-), înmulțirea (*) și diviziunea/impartirea (/). În
C ++, alocarea (=) este de asemenea un operator, la fel și << (inserare) și >> (extracție). Unii
operatori folosesc mai multe simboluri, cum ar fi operatorul de egalitate (==), care ne permite să
comparăm două valori pentru a vedea dacă sunt egale. Există, de asemenea, o serie de operatori
care sunt cuvinte (de exemplu, nou, șterge și arunca).
Numărul de operanțe pe care le ia un operator ca input este numit arity al operatorului (aproape
nimeni nu știe ce înseamnă acest cuvânt, așa că nu-l aruncați într-o conversație și nu așteptați ca
cineva să aibă vreo idee despre ce vorbiți). Operatorii din C ++ au trei arii diferite :
- Operatorii unari (unary) acționează pe un singur operand. Un exemplu de operator unar

este operatorul . De exemplu, dat -5, operatorul - ia operandul literal 5 și își întoarce semnul pentru
a produce o nouă valoare de ieșire -5 .
- Operatorii binari (binary) acționează pe două operanze (cunoscute sub numele

de stânga și dreapta ). Un exemplu de operator binar este operatorul + . De exemplu, dat 3 +
4, operator + ia operandul stâng (3) și operandul drept (4) și aplică adaos/adunare matematic/a
pentru a produce o nouă valoare de ieșire 7 . Operatorii de inserare (<<) și extracție (>>) sunt
operatori binari, luând std :: cout sau std :: cin în partea stângă, iar elementul la ieșire sau variabila
la intrare în partea dreaptă.
- Operatorii ternari (ternary) acționează pe trei operanzi. Există doar unul dintre acestea în C
++, pe care le vom acoperi mai târziu.
Rețineți că unii operatori au mai multe semnificații în funcție de modul de utilizare. De

exemplu, operator - are două contexte. Poate fi folosit sub formă unară pentru a inversa semnul
unui număr (de exemplu, pentru a converti 5 la -5, sau invers), sau poate fi utilizat în formă binară
pentru a face scăderea (de exemplu, 4 - 3).
Înlănțuirea operatorilor
Operatorii pot fi înlănțuiți astfel încât ieșirea unui operator să poată fi utilizată ca intrare pentru un
alt operator. De exemplu, având în vedere următoarele: 2 * 3 + 4 , operatorul de înmulțire (*)
merge mai întâi și transformă operandul stâng 2 și operandul 3 drept în noua valoare 6 (care devine
operandul stâng pentru operatorul plus (+)). În continuare, operatorul plus (+) se execută și
transformă operandul stânga 6 și operandul drept 4 în noua valoare 10.
Vom vorbi mai multe despre ordinea în care operatorii execută atunci când facem o scufundare
profundă în subiectul operatorilor. Deocamdată, este suficient să știm că operatorii aritmetici
execută în aceeași ordine ca și în matematica standard: Paranteză mai întâi ( ) 1, apoi Exponenți (2)
(la putere) 2, apoi Multiplicare/Inmultire (*) 3 și Diviziune/Impartire (/) 4, apoi Adunare (+) 5 și
Scădere (-) 6. Această comandă este uneori prescurtată PEMDAS , sau mnemonicul „Vă rog să mă
scuzați draga mea mătușă Sally”.
Timp de testare
Intrebarea 1
Pentru fiecare dintre următoarele, indicați ce producție produc:

1 std::cout << 3 + 4; 7
1 std::cout << 3 + 4 - 5; 2
std::cout << 2 + 3 * 4; 14 Înmulțirea este înainte de adăugare, deci 3 * 4
1 este primul, producând rezultatul 12. 12 + 2 este 14.
1.9 - Introducere în expresii

Expresii
Luați în considerare următoarea serie de declarații:
1
int x{ 2 }; // initializeaza variabila x cu valoare 2
2 int y{ 2 + 3 }; // initializeaza variabila y cu valoare 5
3
4
int z{ (2 * 3) + 4 }; // initializeaza variabila z cu valoare 10
int w{ y }; // initializeaza variabila w cu valoare 5 (valoarea curenta a variabilei y)
Fiecare dintre aceste declarații definește o nouă variabilă și o inițializează cu o valoare. Rețineți că
inițializatoarele prezentate mai sus folosesc o varietate de constructe diferite: literale, variabile și
operatori. Într-un fel, C ++ transformă fiecare din aceste literale, variabile și operatori într-o singură
valoare care poate fi utilizată ca valoare de inițializare a variabilei.
Ce au toate acestea în comun? Ei folosesc o expresie.
O expresie este o combinație de literale, variabile, operatori și apeluri funcționale explicite (care nu
sunt arătate mai sus) care produc o singură valoare de ieșire. Când o expresie este executată,
fiecare dintre termenii din expresie este evaluat până când rămâne o singură valoare (acest proces
se numește evaluare ). Acea valoare unică este rezultatul expresiei.
Iată câteva exemple de diferite tipuri de expresii, cu comentarii care indică modul în care evaluează:
2 // 2 este un literal care evaluează valoarea 2

"Hello world!" // "Salut Lume!" este un literal care evaluează textul "Hello lume!"
x // x este o variabilă care se evaluează la valoarea lui x
2+3 // 2 + 3 folosește operatorul + pentru a evalua valoarea 5
x=2+3 // 2 + 3 evaluează valoarea 5, care este apoi atribuită variabilei x
std::cout << x // x evaluează valoarea x, care este apoi tipărită pe consolă
După cum puteți vedea, literalele se evaluează la valorile proprii. Variabilele se evaluează la
valoarea variabilei. Încă nu am acoperit apelurile funcționale, dar în contextul unei expresii,
apelurile funcționale evaluează orice valoare returnează funcția. Iar operatorii ne permit să
combinăm mai multe valori împreună pentru a produce o nouă valoare.
Rețineți că expresiile nu se termină cu punct și virgulă (;) și nu pot fi compilate de unul singur. De
exemplu, dacă încercați să compilați expresia x = 5 , compilatorul dvs. se va plânge (probabil despre
punct și virgulă lipsă). Mai degrabă, expresiile sunt întotdeauna evaluate ca parte a enunțurilor.
De exemplu, luați această afirmație:
int x{ 2 + 3 }; // 2 + 3 este o expresie care nu are punct și virgulă - punct și

virgulă este la sfârșitul enunțului care conține expresia
Dacă ați descompune această afirmație în sintaxa ei, ar arăta astfel:
identificator de tip {expresie};

Tipul ar putea fi orice tip valid (am ales int ). Identificator ar putea fi orice nume valid (am
ales x ). Și expresia ar putea fi orice expresie valabilă (am ales 2 + 3 , care folosește 2 literale și
un operator).
Informații cheie
Oriunde puteți utiliza o singură valoare în C ++, puteți utiliza o expresie în schimb, iar compilatorul
va rezolva expresia la o singură valoare.
Enunțuri de expresie
Anumite expresii (cum ar fi x = 5 ) sunt utile de la sine. Cu toate acestea, am menționat mai sus că
expresiile trebuie să facă parte dintr-o afirmație, deci cum putem folosi aceste expresii de unul
singur?
Din fericire, putem converti orice expresie într-o declarație echivalentă (numită declarație
expresie). O declarație de expresie este o afirmație care constă dintr-o expresie urmată de punct
și virgulă (;). Când instrucțiunea este executată, expresia va fi evaluată (iar rezultatul expresiei va fi
aruncat).
Astfel, putem lua orice expresie (cum ar fi x = 5 ) și să o transformăm într-o declarație de expresie
(cum ar fi x = 5; ) care să compileze.
Rețineți că putem face declarații de expresie care compilează , dar sunt lipsite de sens / inutile
( de exemplu , 2 * 3; ). Această expresie se evaluează la 6, iar apoi valoarea 6 este aruncată.
Regulă
Valorile calculate într-o expresie sunt aruncate la sfârșitul expresiei.
Timp de testare
Intrebarea 1
Care este diferența dintre o enunțare/declaratie (statement) și o expresie (expression)?
Rezultat
Declarațiile sunt utilizate atunci când dorim ca programul să efectueze o acțiune. Expresiile sunt
utilizate atunci când dorim ca programul să calculeze o valoare.
Intrebarea 2
Indicați dacă fiecare dintre rândurile următoare sunt enunțuri care nu conțin expresii , instrucțiuni
care conțin expresii sau sunt declarații de expresie .
a) int x;
Rezultat
Declarația nu conține o expresie (aceasta este definiste doar o variabilă)
b)
b) int x = 5;
Rezultat
Instrucțiunea conține o expresie (partea dreaptă a părții egale este o expresie care conține o singură
valoare, dar restul enunțului nu este o expresie)
c) x = 5;
Rezultat
Instrucțiune de expresie (întreaga afirmație este o expresie, încheiată cu punct și virgulă)
d) credit suplimentar:
std::cout << x; // Sugestie: operator << este un operator binar.
Rezultat
Dacă operatorul << este un operator binar, atunci std :: cout trebuie să fie operandul din stânga și
x trebuie să fie operandul din dreapta. Întrucât aceasta este întreaga afirmație, aceasta trebuie să
fie o declarație de expresie.
Întrebarea nr. 3
Determinați ce valori următoarele rezultate ale programului. Nu compilați acest program. Doar
lucrează linie cu linie în capul tău.
#include<iostream>
1 int main()
2
3 {
4 std::cout << 2 + 3 << '\n';
5
6
7 int x{ 6 };
8 int y{ x - 2 };
9 std::cout << y << '\n';
10
11
12 int z{ 0 };
13 z = x;
14
15 std::cout << z - x << '\n';
16
return 0;
}
Rezultat
5
4
0
1.10 - Dezvoltarea primului program
Lecțiile precedente au introdus o mulțime de terminologii și concepte pe care le vom folosi în
aproape fiecare program creat. În această lecție, vom parcurge procesul de integrare a acestor
cunoștințe în primul nostru program simplu.
Înmulțiți cu 2
Mai întâi, să creăm un program care solicită utilizatorului să introducă un număr întreg, îi așteaptă
să introducă un număr întreg, apoi le spune ce este de 2 ori acel număr. Programul ar trebui să
producă următoarea ieșire (presupun că am introdus 4 ca intrare):
Introduceți un număr întreg: 4

Dubla acestui număr este: 8
Cum abordăm acest lucru? În pași.
Noii programatori încearcă adesea să scrie un program întreg deodată, apoi sunt copleșiți când
produce o mulțime de erori. O strategie mai bună este să adăugați o bucată la un moment dat, să
vă asigurați că se compila și să o testați. Atunci când sunteți sigur că funcționează, treceți la
următoarea piesă.
Vom folosi această strategie aici. Pe măsură ce parcurgem fiecare etapă, tastați (nu copiați /
inserați) fiecare program în compilatorul dvs., compilați-l și rulați-l.
Mai întâi, creați un nou proiect de consolă.
Acum să începem cu niște schele de bază. Știm că vom avea nevoie de o funcție principală (),
deoarece toate C ++ trebuie să aibă una), așa că dacă IDE-ul dvs. nu a creat unul gol atunci când
ați creat un proiect nou, creați unul:
1
int main()
2 {
3
4
return 0;
}
Știm că va trebui să scoatem text în consolă și să obținem text de la tastatura utilizatorului, așa că
trebuie să includem iostream pentru acces la std :: cout și std :: cin.
#include <iostream>
1
2
3 int main()
4
5
{
6 return 0;
}
Acum să-i spunem utilizatorului că avem nevoie de ei pentru a intra într-un număr întreg:
#include <iostream>
1
2 int main()
3
4 {
5
6
std::cout << "Enter an integer: ";
7
8
return 0;
}
În acest moment, programul dvs. ar trebui să producă acest rezultat:
Introduceți un număr întreg:
apoi se încheie.
În continuare, vom primi intrarea utilizatorului. Vom folosi std :: cin și operator >> pentru a obține
intrarea utilizatorului. Dar, de asemenea, trebuie să definim o variabilă pentru a stoca acea intrare
pentru a fi utilizată ulterior.
#include <iostream>
1
2
int main()
3 {
4
5 std::cout << "Enter an integer: ";
6
7
8 int num{ 0 }; // define variable num as an integer variable
9 std::cin << num; // get integer value from user's keyboard
10
11
return 0;
}
E timpul să compunem modificările noastre ... și ...
Uh oh! Iată ce a primit autorul la Visual Studio 2017:
1> ------ Construit început: Proiect: dublu, configurare: lansare Win32 ------
1> Double.cpp
1> c: \ vcprojects \ double \ double.cpp (8): eroare C2678: „<<” binar: nu a fost găsit niciun operator
care să ia un operand din stânga de tipul „std :: istream” (sau nu există o conversie acceptabilă )
1> c: \ vcprojects \ double \ double.cpp: notă: ar putea fi "operator C ++ încorporat << (bool, int)"
1> c: \ vcprojects \ double \ double.cpp: notă: în timp ce încercați să se potrivească cu lista de
argumente '(std :: istream, int)'
1> Proiect de construcție finalizat "Double.vcxproj" - FAILED.
========== Construire: 0 reușit, 1 eșuat, 0 actualizat, 0 omis ==========
Ne-am confruntat cu o eroare de compilare!
În primul rând, din moment ce programul a fost compilat înainte de a face această ultimă actualizare
și nu se compilează acum, eroarea trebuie să fie în codul pe care tocmai l-am adăugat (liniile 7 și
8). Aceasta reduce semnificativ cantitatea de cod pe care trebuie să o scanăm pentru a găsi
eroarea. Linia 7 este destul de simplă (doar o definiție variabilă), deci eroarea probabil nu
există. Asta lasă linia 8 ca vinovată probabilă.
În al doilea rând, acest mesaj de eroare nu este foarte ușor de citit. Dar să alegem câteva elemente
cheie: compilatorul ne spune că a intrat în eroarea de pe linia 8. Asta înseamnă că eroarea reală
este probabil pe linia 8, sau posibil pe linia precedentă, ceea ce consolidează evaluarea noastră
anterioară. În continuare, compilatorul vă spune că nu a putut găsi un operator << << care are un
operand din stânga de tip std :: istream (care este tipul std :: cin). Altfel spus, operatorul << nu
știe ce să facă cu std :: cin, așa că eroarea trebuie să fie fie cu utilizarea noastră de std :: cin, fie
prin utilizarea noastră de operator <<.
Vezi eroarea acum? Dacă nu, faceți un moment și vedeți dacă îl puteți găsi.
Iată programul care conține codul corectat:
1
2
#include <iostream>
3
4
5
int main()
6 {
7
9
10
int num{ 0 };
std::cin >> num; // std::cin uses operator >>, not
operator <<!
11
return 0;
}
Acum programul va fi compilat și îl putem testa. Programul va aștepta să introduceți un număr, așa
că haideți să introducem 4. Ieșirea ar trebui să arate astfel:
Aproape acolo! Ultimul pas este dublarea numărului.
După ce terminăm acest ultim pas, programul nostru va compila și rula cu succes, producând
rezultatul dorit.
Există (cel puțin) 3 modalități prin care putem merge în acest sens. Să mergem de la cel mai rău la
cel mai bun.
Soluția nu tocmai bun ă

#include <iostream>
// worst version
1 int main()
2
3 {
4
5
6
7
8
int num{ 0 };
9 std::cin >> num;
10
11
12 num = num * 2; // double num's value, then assign that value
13 back to num
14
15
16 std::cout << "Double that number is: " << num << '\n';
return 0;
}
În această soluție, folosim o expresie la multiple num cu 2, apoi atribuim această valoare înapoi
la num . Din acel moment, num va conține numărul nostru dublat.
De ce aceasta este o soluție proastă:
 Înainte de declarația de atribuire, num conține intrarea utilizatorului. După atribuire, acesta
conține o valoare diferită. Este confuz.
 Suprascriem intrarea utilizatorului prin alocarea unei noi valori variabilei de intrare, așa că,
dacă am dori să extindem programul nostru pentru a face altceva cu acea valoare de intrare
mai târziu (de exemplu, tripla intrarea utilizatorului), aceasta a fost deja pierdută.
Cea mai bună soluție

1
2
#include <iostream>
3
4
5
// less-bad version
6 int main()
7
8 {
9
int num{ 0 };
10 std::cin >> num;
11
12
13 int doublenum{ num * 2 }; // define a new variable and initialize it with num * 2
14
15
std::cout << "Double that number is: " << doublenum <<
'\n'; // then print the value of that variable here
return 0;
}
Această soluție este destul de simplă de citit și de înțeles și rezolvă ambele probleme întâlnite în cea
mai proastă soluție.
Dezavantajul principal este că definim o nouă variabilă (care adaugă complexitate) pentru a stoca o
valoare pe care o folosim o singură dată. Putem face mai bine.
Soluția preferată
#include <iostream>
// preferred version
1
2
int main()
3 {
4
5
6
7
8 int num{ 0 };
9 std::cin >> num;
10
11
12 std::cout << "Double that number is: " << num * 2 <<
13
14 '\n'; // use an expression to multiply num * 2 at the point where we are going to print it
return 0;
}
Aceasta este soluția preferată a buchetului. Când std :: cout se execută, expresia num * 2 va fi
evaluată, iar rezultatul va fi valoarea dublă a num . Această valoare va fi
tipărită. Valoarea num în sine nu va fi modificată, așa că o putem folosi din nou mai târziu dacă
dorim.
Această versiune este soluția noastră de referință.
Nota autorului
Primul și principalul obiectiv al programării este de a face programul dvs. să funcționeze. Un

program care nu funcționează nu este util indiferent de cât de bine este scris.
Cu toate acestea, există o afirmație care îmi place: „Trebuie să scrii o programă o dată pentru a ști
cum ar fi trebuit să o scrii prima dată.” Aceasta vorbește despre faptul că cea mai bună soluție este
adesea evidentă și că primele soluții la probleme nu sunt de obicei atât de bune pe cât ar putea fi.
Când ne concentrăm să ne gândim cum să facem programele noastre să funcționeze, nu are prea
mult sens să investim mult timp în cod pe care nici nu știm dacă îl vom păstra. Deci luăm comenzi
rapide. Sărim lucruri precum gestionarea erorilor și comentarii. Stropim codul de depanare în toată
soluția noastră pentru a ne ajuta să diagnosticăm probleme și să găsim erori. Învățăm pe măsură ce
mergem - lucrurile despre care am crezut că nu funcționează nu funcționează până la urmă și
trebuie să facem un backtrack și să încercăm o altă abordare.
Rezultatul final este că soluțiile noastre inițiale nu sunt adesea bine structurate, robuste (fără erori),
lizibile sau concise. Așadar, odată ce programul funcționează, treaba dvs. nu se face cu adevărat (cu
excepția cazului în care programul este unul singur / de urgență). Următorul pas este să vă curățați
codul. Aceasta implică lucruri precum: eliminarea (sau comentarea) codului temporar / depanare,
adăugarea de comentarii, gestionarea cazurilor de eroare, formatarea codului dvs. și asigurarea
celor mai bune practici. Și chiar și atunci, este posibil ca programul dvs. să nu fie atât de simplu pe
cât ar putea fi - poate există o logică redundantă care poate fi consolidată, sau mai multe afirmații
care pot fi combinate, sau variabile care nu sunt necesare sau alte o mie de lucruri mici care ar
putea fi simplificată. Prea des programatorii noi se concentrează pe optimizarea performanței atunci
când ar trebui să fie optimizați pentru mentenanță.
Foarte puține dintre soluțiile prezentate în aceste tutoriale au ieșit minunate pentru prima dată. Mai
degrabă, acestea sunt rezultatul perfecționării continue până când nu s-a putut găsi nimic care să se
îmbunătățească. Și în multe cazuri, cititorii mai găsesc o mulțime de alte lucruri pe care să le
sugereze drept îmbunătățiri!
Toate acestea să spunem cu adevărat: nu vă frustrați dacă / atunci când soluțiile dvs. nu ies
minunat optimizate chiar din creierul vostru. E normal. Perfecțiunea în programare este un proces
iterativ (unul care necesită treceri repetate).
Nota autorului
Încă un lucru: S-ar putea să te gândești: „C ++ are atât de multe reguli și concepte. Cum îmi
amintesc toate aceste lucruri? ”.
Răspuns scurt: Nu. C ++ este o parte folosind ceea ce știi și două părți caută cum să faci restul.
Pe măsură ce citiți acest site pentru prima dată, concentrați-vă mai puțin pe memorarea specificului
și mai mult pe înțelegerea a ceea ce este posibil. Apoi, când aveți nevoie să implementați ceva într-
un program pe care îl scrieți, puteți reveni aici (sau pe un site de referință) și vă puteți reîmprospăta
cum să faceți acest lucru.
Timp de testare
Intrebarea 1
Modificați soluția la programul „cea mai bună soluție” de mai sus, astfel încât să iasă astfel
(presupunând introducerea utilizatorului 4):

Dubla 4 este: 8
Triple 4 este: 12
Rezultat
2
3 int main()
4 {
6
7 int num{ 0 };
8 std::cin >> num;
9
1 std::cout << "Double " << num << " is: " << num * 2 <<
0 '\n';
1 std::cout << "Triple " << num << " is: " << num * 3 <<
1 '\n';
1
2 return 0;
1 }
3
1
4
1.x - Capitolul 1 rezumat și test
Rezumat rapid
O declarație este un tip de instrucțiune care determină programul să efectueze unele
acțiuni. Declarațiile sunt adesea încheiate cu punct și virgulă.
O funcție este o colecție de declarații care se execută secvențial. Fiecare program C ++ trebuie să
includă o funcție specială numită principală (main) . Când rulați programul, execuția începe de la
partea superioară a funcției principale .
Instrucțiunile preprocesorului spun compilatorului să efectueze o sarcină specială. În acest

capitol, le folosim pentru #include <iostream>, ceea ce ne permite să accesăm rutinele de intrare
/ ieșire din biblioteca standard.
Regulile care guvernează modul în care sunt construite elementele limbajului C ++ se

numește sintaxă . O eroare de sintaxă apare atunci când încalci regulile gramaticale ale limbii.
Comentariile permit programatorului să lase note în cod. C ++ acceptă două tipuri de

comentarii. Comentariile liniei încep cu a // și rulează până la sfârșitul liniei. Comentariile de
blocare încep cu a / * și accesați simbolul * / pereche. Nu cuibărește comentarii.
Puteți utiliza comentarii pentru a dezactiva temporar liniile sau secțiunile de cod. Se numește
comentarea codului.
Datele sunt orice secvență de simboluri care poate fi interpretată pentru a însemna ceva. O singură
bucată de date, stocată undeva în memorie se numește valoare .
O variabilă este o bucată de memorie numită pe care o putem folosi pentru a stoca valori. Numele
unei variabile se numește identificator . Pentru a crea o variabilă, folosim o instrucțiune
numită instrucțiune de definiție . Când programul este rulat, fiecare variabilă definită
este instanțiată , ceea ce înseamnă că i se atribuie o adresă de memorie.
Un tip de date spune compilatorului cum să interpreteze o bucată de date într-o valoare
semnificativă. Un număr întreg este un număr care poate fi scris fără o componentă fracțională,
cum ar fi 4, 27, 0, -2 sau -12.
Copierea (prin operator =) poate fi utilizată pentru a atribui o valoare deja variabilă creată.
Initializarea poate fi folosita pentru a da o valoare variabila la punctul de creare. C ++ acceptă 3

tipuri de inițializare: inițializarea copiilor, inițializarea directă și inițializarea uniformă.
Ar trebui să preferați inițializarea uniformă față de celelalte forme de inițializare și să preferați

inițializarea decât repartizarea.
Deși puteți defini mai multe variabile într-o singură declarație, este mai bine să definiți și
să inițiați fiecare variabilă pe propria linie, într-o instrucțiune separată.
- std :: cout și operator << - ne permit să scoatem o expresie în consolă ca text.
- std :: endl scoate un nou caracter de linie, forțând cursorul consolei să treacă la linia următoare.
- std :: cin și operator >> ne permit să obținem o valoare de la tastatură.
O variabilă căreia nu i s-a dat o valoare se numește variabilă neinițializată . Încercarea de a

obține valoarea unei variabile neinicializate va duce la un comportament nedefinit , care se poate
manifesta în orice fel de moduri.
C ++ își rezervă un set de nume numite cuvinte cheie . Acestea au o semnificație specială în limbă
și nu pot fi utilizate ca nume variabile.
O constantă literală este o valoare fixă introdusă direct în codul sursă. Exemple sunt 5 și „Salut
lume!”.
O operație este un calcul matematic care implică zero sau mai multe valori de intrare,
numite operanzi . Operațiunea specifică care trebuie efectuată este notată de
către operatorul furnizat . Rezultatul unei operații produce o valoare de ieșire.
Operatorii unari iau un operand. Operatorii binari iau doi operanzi, adesea numiți la stânga și la
dreapta. Operatorii ternari iau trei operanzi.
O expresie este o combinație de literale, variabile, operatori și apeluri funcționale care sunt
evaluate pentru a produce o singură valoare de ieșire. Calculul acestei valori de ieșire se
numește evaluare . Valoarea produsă este rezultatul expresiei.
O declarație de expresie este o expresie care a fost transformată în enunț prin plasarea unui
punct și virgulă la sfârșitul expresiei.
Programarea este grea, iar programele dvs. vor ieși rareori perfect (sau aproape de el) pentru prima
dată. Faceți mai întâi programele dvs. să funcționeze, apoi să le perfecționați în ceva extraordinar
Timp de testare
Intrebarea 1
Ascundeți soluția
Initializarea ofera o variabila cu o valoare initiala (la punctul de creare). Alocarea conferă unei
variabile o nouă valoare după ce variabila a fost deja definită.
Intrebarea 2
Când apare un comportament nedefinit? Care sunt consecințele comportamentului nedefinit?
Ascundeți soluția
Comportamentul nedefinit apare atunci când programatorul face ceva care nu este specificat de
limbajul C ++. Consecințele ar putea fi aproape orice, de la prăbușire până la producerea unui
răspuns greșit până la funcționarea corectă.
Întrebarea nr. 3
Scrieți un program care solicită utilizatorului să introducă un număr, apoi să introduceți un al doilea
număr. Programul ar trebui să spună utilizatorului care este rezultatul adăugării și scăderii celor
două numere.
Rezultatul programului trebuie să corespundă următoarelor (presupunând intrări de 6 și 4):

Introduceți un alt număr întreg: 4
6 + 4 este 10.
6 - 4 este 2.
Ascundeți soluția
2
3 int main()
4 {
5 int x{};
7 std::cin >> x;
8
9 int y{};
1 std::cout << "Enter another integer: ";
0
1
1
1
2 std::cin >> y;
1
3 std::cout << x << " + " << y << " is " << x + y << ".\n";
1 std::cout << x << " - " << y << " is " << x - y << ".\n";
4
1 return 0;
5 }
1
6
1
7
2.1 - Introducere în funcții
În ultimul capitol, am definit o funcție ca o colecție de declarații care se execută secvențial. Deși
acest lucru este cu siguranță adevărat, această definiție nu oferă prea multe informații despre
motivul pentru care funcțiile sunt utile. Să actualizăm definiția noastră: o funcție este o secvență
reutilizabilă de enunțuri concepute pentru a face o anumită lucrare.
Știți deja că fiecare program trebuie să aibă o funcție numită principal (main) (care este locul în
care programul începe executarea atunci când este rulat). Cu toate acestea, pe măsură ce
programele încep să devină din ce în ce mai lungi, introducerea întregului cod
în funcția principală devine din ce în ce mai greu de gestionat. Funcțiile oferă o modalitate pentru a
ne împărți programele în bucăți mici, modulare, care sunt mai ușor de organizat, testat și
utilizat. Majoritatea programelor folosesc multe funcții. Biblioteca standard C ++ vine cu o mulțime
de funcții deja scrise pe care să le folosești - cu toate acestea, este la fel de obișnuit să îți scrie
singur. Funcțiile pe care le scrieți singur sunt numite funcții definite de utilizator .
Luați în considerare un caz care ar putea apărea în viața reală: citiți o carte, când vă amintiți că
trebuie să apelați un telefon. Puneți un marcaj în cartea dvs., efectuați apelul telefonic și, după ce
ați terminat apelul telefonic, reveniți la locul pe care l-ați marcat și continuați cartea exact acolo
unde ați plecat.
Programele C ++ pot funcționa la fel. Un program va executa instrucțiuni secvențial în interiorul unei
funcții atunci când întâlnește un apel funcțional. Un apel funcțional este o expresie care spune
procesorului să întrerupă funcția curentă și să execute o altă funcție. CPU „pune un marcaj” la
punctul de execuție curent, apoi apelează (execută) funcția numită în apelul funcțional. Când
funcția apelată se încheie, procesorul revine la punctul pe care l-a marcat și reia execuția.
Funcția care inițiază apelul funcțional se numește apelant , iar funcția numită
este callee sau funcție numită .
Un exemplu de func ție definit ă de utilizator

În primul rând, să începem cu sintaxa cea mai de bază pentru a defini o funcție definită de
utilizator. Pentru această lecție, toate funcțiile definite de utilizator (cu excepția principalului) vor lua
următoarea formă:
void identifier () // identificator înlocuit cu numele funcției tale

{
// Codul tău aici
}
Vom vorbi mai multe despre diferitele părți ale acestei sintaxe în următoarele
lecții. Deocamdată, identificatorul va fi înlocuit pur și simplu cu numele funcției dvs. definite de
utilizator. Brățările ondulate și afirmațiile dintre ele sunt numite corpul funcției .
Iată un exemplu de program care arată cum este definită și numită o nouă funcție:
1 #include <iostream> // for std::cout

2
3
4
5
6
7 // Definition of user-defined function doPrint()
8 void doPrint() // doPrint() is the called function in this example
9 {
1 std::cout << "In doPrint()\n";
0 }
1
1 // Definition of function main()
1 int main()
2 {
1 std::cout << "Starting main()\n";
3 doPrint(); // Interrupt main() by making a function call
to doPrint(). main() is the caller.
1 std::cout << "Ending main()\n"; // this statement is executed after doPrint() ends
4
1 return 0;
5 }
1
6
1
7
Acest program produce următoarea ieșire:
Pornire principală ()
În doPrint ()
Terminare principală ()
Acest program începe execuția în partea de sus a funcției principale , iar prima linie care va fi
executată tipărește Starting main().
A doua linie principală este un apel funcțional la funcția doPrint . Noi numim funcția doPrint prin
adăugarea unei perechi de paranteze numele funcției ca o astfel: doPrint(). Rețineți că, dacă uitați
paranteza, este posibil ca programul dvs. să nu se compileze (și dacă se întâmplă, funcția nu va fi
apelată).
Avertizare
Nu uitați să includeți paranteza () după numele funcției atunci când efectuați un apel funcțional.
Deoarece s-a făcut un apel funcțional, execuția instrucțiunilor în principal este suspendată, iar
execuția sare în partea de sus a funcției numite doPrint . Prima (și singura) linie din tipărirea doPrint
In doPrint() . Când doPrint se încheie, execuția revine apelantului (funcția principală ) și reia din
punctul în care a plecat. În consecință, următoarea declarație executată în print-uri principale
Ending main() .
Funcțiile de apelare de mai multe ori

Un lucru util în ceea ce privește funcțiile este faptul că acestea pot fi apelate de mai multe ori. Iată
un program care demonstrează acest lucru:
1 #include <iostream> // for

2 std::cout
3
4 void doPrint()
5 {
6 std::cout << "In doPrint()\n";
7 }
8
9
1
0
1 int main()
1 {
1 doPrint(); // doPrint()
called for the first time
3
doPrint(); // doPrint()
1 called for the second time
4 std::cout << "Ending main()\n";
1
5 return 0;
1 }
6
1
7
În doPrint ()
În doPrint ()
Deoarece doPrint este apelat de două ori de către principal , doPrint se execută de două ori, iar In
doPrint () este tipărit de două ori (o dată pentru fiecare apel).
Funcții care apeleaz ă func ții care apeleaz ă func ții

Ați văzut deja că funcția principală poate apela o altă funcție (cum ar fi funcția doPrint în exemplul
de mai sus). Orice funcție poate apela orice altă funcție. În programul următor,
funcția apeluri principale funcționează doA , care apelează funcția doB :

2
3 void doB()
4 {
5 std::cout << "In doB()\n";
6 }
7
8
9 void doA()
1 {
0 std::cout << "Starting doA()\n";
1
1 doB();
1
2 std::cout << "Ending doA()\n";
1 }
3
4 int main()
1 {
1
6 doA();
1
7
1
8
1
9
2
0
2
1
2
std::cout << "Ending main()\n";
2
2
return 0;
3
}
2
4
2
5
2
6
2
7
2
8
Începând doA ()
În doB ()
Încheierea doA ()
Funcțiile imbricate nu sunt acceptate

Spre deosebire de alte limbaje de programare, în C ++, funcțiile nu pot fi definite în alte
funcții. Următorul program nu este legal:
#include <iostream>
1
2
int main()
3
{
4
int foo() // Illegal: this function is nested inside
5
function main()
6
{
7
std::cout << "foo!";
8
return 0;
9
}
10
11
foo(); // function call to foo()
12
return 0;
13
}
Modul corect de a scrie programul de mai sus este:
2
3 int foo() // no longer inside of main()
4 {
5 std::cout << "foo!";
6 return 0;
7 }
8
9 int main()
1
0
1 {
1 foo();
1 return 0;
2 }
1
3
Timp de testare
Intrebarea 1
Într-o definiție a funcției, cum se numesc clapete și enunțuri buclate?
Ascundeți soluția
Corpul funcției
Intrebarea 2
Ce imprimă următorul program? Nu compilați acest program, doar urmăriți singur codul.

2
3 void doB()
4 {
5 std::cout << "In doB()\n";
6 }
7
8 void doA()
9 {
1 std::cout << "In doA()\n";
0
1 doB();
1 }
1
1 int main()
3 {
4
1 doA();
5 doB();
1
6 std::cout << "Ending main()\n";
1
7 return 0;
1 }
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
Ascundeți soluția
Start principal ()
În doA ()
În doB ()
În doB ()
Ending main ()
2.2 - Valorile returnării funcției

Luați în considerare următorul program:
1
2
#include <iostream>
3
4
int main()
5
{
6
// get a value from
7
the user
8
9
int num{};
1
std::cin >> num;
0
1
// print the value
1
doubled
1
std::cout << num << " doubled is: " << num * 2 << '\n';
2
1
return 0;
3
}
1
4
Acest program este compus din două părți conceptuale: În primul rând, obținem o valoare de la
utilizator. Apoi îi spunem utilizatorului care este valoarea dublă.
Deși acest program este suficient de banal încât nu este necesar să-l împărțim în mai multe funcții,
ce se întâmplă dacă am fi dorit? Obținerea unei valori întregi de la utilizator este o sarcină bine
definită pe care dorim să o facă programul nostru, astfel încât ar face un candidat bun pentru o
funcție.
Deci, să scriem un program pentru a face acest lucru:
1 // Acest program nu va functiona

3
4 void getValueFromUser()
5 {
7 int input{};
8 std::cin >> input;
9
1
0
1
1
1 }
2
1 int main()
3 {
1 getValueFromUser(); // Ask user for input
4
1 int num{}; // How do we get the value from getValueFromUser() and use
5 it to initialize this variable?
1
6 std::cout << num << " doubled is: " << num * 2 << '\n';
1
7 return 0;
1 }
8
1
9
2
0
Deși acest program este o încercare bună de soluție, nu funcționează destul de bine.
Când este apelată funcția getValueFromUser , utilizatorului i se cere să introducă un număr întreg
așa cum este de așteptat. Dar valoarea pe care o introduc se pierde atunci când
se termină getValueFromUser și controlul revine la principal . Numărul variabil nu se inițializează
niciodată cu valoarea introdusă de utilizator, astfel încât programul tipărește întotdeauna răspunsul
0.
Ceea ce ne lipsește este cumva pentru ca getValueFromUser să returneze valoarea pe care a

introdus-o înapoi la principal, astfel încât principalul să poată folosi aceste date.
Valori de returnare
Când scrieți o funcție definită de utilizator, trebuie să determinați dacă funcția dvs. va returna sau
nu o valoare. Pentru a returna o valoare către apelant, sunt necesare două lucruri.
În primul rând, funcția dvs. trebuie să indice ce tip de valoare va fi returnată. Acest lucru se
realizează prin setarea tipului de returnare a funcției , care este tipul definit înainte de numele
funcției. În exemplul de mai sus, funcția getValueFromUser are un tip de returnare
a golului/vidului (void = vid), iar funcția principală are un tip de returnare a int. Rețineți că aceasta
nu determină ce valoare specifică este returnată - doar tipul valorii.
În al doilea rând, în interiorul funcției care va returna o valoare, folosim o declarație

returnare pentru a indica valoarea specificată returnată apelantului. Valoarea specifică returnată
dintr-o funcție se numește valoare returnare . Când instrucțiunea de returnare este executată,
valoarea returnată este copiată din funcția înapoi către apelant. Acest proces se numește returnare
prin valoare .
Haideți să aruncăm o privire la o funcție simplă care returnează o valoare întreagă și un program de
exemplu care o numește:
2
3 //// int is the return type
A return type of int means the function will return some integer value to the caller (the specific value is
4 not specified here)
5 int returnFive()
6 {
7
8
9
1
// the return statement indicates the
0 specific value that will be returned
1 return 5; // return the specific value 5 back to the caller
1 }
1
2 int main()
1 {
3 std::cout << returnFive() << '\n'; //
1 prints 5
4 std::cout << returnFive() + 2 << '\n'; //
1 prints 7
5
1 returnFive(); // okay: the value 5 is returned, but is ignored since
main() doesn't do anything with it
6
1 return 0;
7 }
1
8
1
9
Când este rulat, acest program imprimă:
5
7
Executarea începe din partea de sus a (principalului) int main(). În prima declarație, se
evaluează apelul funcțional la returnFive , ceea ce duce la
funcționarea returnFive . Funcția returnFive returnează valoarea specifică 5 înapoi apelantului, care
este apoi tipărit pe consolă prin std :: cout.
În cel de-al doilea apel de funcții, se evaluează apelul funcțional la returnFive , ceea ce duce la
funcția returnFive fiind apelată din nou. Funcția returnFive returnează apelul la valoarea de 5
înapoi. Expresia 5 + 2 este evaluată pentru a produce rezultatul 7, care este apoi tipărit pe consolă
prin std :: cout.
În cea de-a treia declarație, funcția returnFive este apelată din nou, rezultând returnarea valorii 5
către apelant. Cu toate acestea, funcția principală nu face nimic cu valoarea returnată, deci nu se
întâmplă nimic mai departe (valoarea returnată este ignorată).
Notă: Valorile de returnare nu vor fi tipărite decât dacă apelantul le trimite la consolă prin std ::
cout. În ultimul caz de mai sus, valoarea returnată nu este trimisă la std :: cout, astfel încât nimic
nu este tipărit.
Fixarea programului nostru de provocare

Având în vedere acest lucru, putem repara programul prezentat în partea de sus a lecției:
2
3 int getValueFromUser() // this function now
4 returns an integer value
5 {
7 int input{};
9
1 return input; // return the value the user
0
1
1
1
entered back to the caller
2
}
1
3
int main()
1
{
4
int num { getValueFromUser() }; // initialize num with the return value
1 of getValueFromUser()
5
6
1 return 0;
7 }
1
8
1
9
Când acest program se execută:
- prima declarație din functia int mai() (principală) va crea o variabilă int, numită num .
- când programul va inițializa num , va vedea că există un apel funcțional la getValueFromUser , deci
va merge să execute acea funcție.
- funcția getValueFromUser , solicită utilizatorului să introducă o valoare, apoi o returnează înapoi

apelantului ( principal ) int mai(). Această valoare de returnare este utilizată ca valoare de
inițializare pentru variabila num .
Compilați singur acest program și executați-l de câteva ori pentru a vă dovedi că funcționează.
Valorile returului vid (void)

Funcțiile nu sunt necesare pentru a returna o valoare. Pentru a spune compilatorului că o funcție nu
returnează o valoare, se folosește un tip de returnare a golului/vidului (void). Să ne uităm la
funcția doPrint () din lecția anterioară:
1 void doPrint() // void is the return type
2{
3 std::cout << "In doPrint()" << '\n';
// This function does not return a
4 value so no return statement is needed
5}
Această funcție are un tip de returnare a golului, care indică faptul că nu returnează o valoare
apelantului. Deoarece nu returnează o valoare, nu este necesară nicio declarație de returnare
(încercarea de a returna o valoare specifică dintr-o funcție cu un tip de returnare void va avea ca
rezultat o eroare de compilare).
Iată un alt exemplu de funcție care returnează nulul și un program de exemplu care îl numește:
2
3 a value to the caller // void means the function does not return
4 void returnNothing()
5 {
6 std::cout << "Hi" << '\n';
7 // This function does not return a
8 value so no return statement is needed
9
1
0
1 }
1
1 int main()
2 {
1 returnNothing(); // okay: function returnNothing() is
called, no value is returned
3
1
std::cout << returnNothing(); // error: this line will not compile. You'll
4 need to comment it out to continue.
1
5 return 0;
1 }
6
1
7
În primul apel de funcții pentru funcția returnNothing , funcția tipărește „Bună” și apoi nu
returnează nimic apelantului. Controlul revine la principal și programul continuă.
Cel de-al doilea apel de funcție pentru returnarea funcției Nimeni nu va fi chiar
compilat. Funcție returnare Nimic nu are un tip de returnare a golului, ceea ce înseamnă că nu
returnează o valoare. Cu toate acestea, această declarație încearcă să trimită valoarea de retur
a returnNothing to std :: cout care trebuie tipărită. std :: cout nu știe cum să se ocupe de acest
lucru (ce valoare ar rezulta?). În consecință, compilatorul va marca acest lucru ca o eroare. Va
trebui să comentați această linie de cod pentru a vă face codul compilat.
Un tip void return (care înseamnă că nu se returnează nimic) este utilizat atunci când dorim să avem
o funcție care nu returnează nimic apelantului (pentru că nu este necesar). În exemplul de mai
sus, funcția returnNothing are un comportament util (tipărește „Hi”), dar nu trebuie să returneze
nimic apelantului (în acest caz, principal ). Prin urmare, returnNow i se oferă un tip de
returnare voidă .
Revenind la principal
Acum aveți instrumente conceptuale pentru a înțelege modul în care funcția principală funcționează
de fapt. Când programul este executat, sistemul de operare face un apel la
funcția principală . Execuția sare apoi în vârful principalului . Instrucțiunile principale sunt executate
secvențial. În cele din urmă, principal returnează o valoare întreagă (de obicei 0) înapoi la sistemul
de operare. Acesta este motivul pentru care principalul este definit ca fiind int main().
De ce să returnăm o valoare înapoi la sistemul de operare? Această valoare se numește cod de

stare și indică sistemul de operare (și orice alte programe care au apelat al tău) dacă programul tău
a fost executat cu succes sau nu. Prin consens, o valoare de returnare de 0 înseamnă succes, iar o
valoare de returnare non-zero înseamnă eșec.
Funcția principală ar trebui să returneze 0 dacă programul rulează normal, sau o valoare diferită de
zero dacă a întâmpinat o eroare și nu s-a putut finaliza așa cum era de așteptat.
Rețineți că specificația C ++ specifică explicit că funcția principală main() trebuie să returneze o

int. Unii compilatori vă vor permite invalid să specificați un tip de returnare a void-ului (implicit vor
returna 0 dacă faceți acest lucru), dar nu ar trebui să vă bazați pe acest lucru.
Deocamdată, ar trebui să definiți și funcția principală () din partea de jos a fișierului dvs. de cod, sub
alte funcții.
Câteva note suplimentare despre valorile de retur

În primul rând, dacă o funcție are un tip de returnare nulă, trebuie să returneze o valoare a acelui
tip (folosind o declarație returnare). Nerespectarea acestui lucru va duce la un comportament
nedefinit. Singura excepție de la această regulă este pentru funcția main (), care va presupune o
valoare de returnare de 0 dacă nu este furnizată explicit. Acestea fiind spuse, este cea mai bună
practică să returnați explicit o valoare de la principal main(), atât pentru a vă arăta intenția, cât și
pentru consecvența cu alte funcții (ceea ce nu vă va permite să omiteți valoarea returnată).
Oferiți întotdeauna explicit o valoare de retur pentru orice funcție care are un tip de returnare nul.
Avertizare
Eșecul de a returna o valoare dintr-o funcție cu un tip de retur nul (altul decât principal)
va duce la un comportament nedefinit.
În al doilea rând, atunci când este executată o declarație de returnare, funcția revine apelantului
imediat în acel moment. Orice cod suplimentar din funcție este ignorat.
În al treilea rând, o funcție poate returna o singură valoare înapoi apelantului de fiecare dată când
este apelată. Cu toate acestea, valoarea nu trebuie să fie literală, ci poate fi rezultatul oricărei
expresii valide, inclusiv o variabilă sau chiar un apel către o altă funcție care returnează o
valoare. În exemplul getValueFromUser () de mai sus, am returnat o variabilă care ține numărul
pe care l-a tastat utilizatorul.
În sfârșit, rețineți că o funcție este liberă să definească ce înseamnă valoarea de returnare a

acesteia. Unele funcții folosesc valori de retur ca coduri de stare, pentru a indica dacă au reușit sau
nu. Alte funcții returnează o valoare calculată sau selectată. Alte funcții nu returnează nimic. Ceea
ce funcția returnează și semnificația acelei valori este definită de autorul funcției. Datorită
numeroase posibilități de aici, este bine să vă documentați funcția cu un comentariu care să indice
ce înseamnă valorile de retur.
De exemplu:
1 // Function asks user to enter a value

2 // Return value is the integer entered by the user from the keyboard
3 int getValueFromUser()
4 {
6 int input{};
8
9 return input; // return the value the user
entered back to the caller
1
}
0
Reutilizarea func țiilor

Acum putem ilustra un caz bun pentru reutilizarea funcțiilor. Luați în considerare următorul
program:
2
3 int main()
4 {
5 int x{};
7 std::cin >> x;
8
9 int y{};
0 std::cin >> y;
1
1 std::cout << x << " + " << y << " = " << x + y << '\n';
1
2
1
3
1
return 0;
4
}
1
5
1
6
În timp ce acest program funcționează, este puțin redundant. De fapt, acest program încalcă unul
dintre elementele centrale ale unei bune programări: „Nu vă repetați” (adesea prescurtat „DRY”).
De ce codul repetat este rău? Dacă am dori să schimbăm textul „Introduceți un număr întreg” în
altceva, ar trebui să îl actualizăm în două locații. Și dacă am dori să inițializăm 10 variabile în loc de
2? Acesta ar fi o mulțime de cod redundant (ceea ce face ca programele noastre să fie mai lungi și
mai greu de înțeles) și o mulțime de spațiu pentru a da drumul la dactilografii.
Să actualizăm acest program pentru a utiliza funcția noastră getValueFromUser pe care am

dezvoltat-o mai sus:
1
2
3
4
5
7
9 {
0 int input{};
1
1 return input;
2 }
1
3 int main()
1 {
4 int x{ getValueFromUser() }; // first call
to getValueFromUser
1
int y{ getValueFromUser() }; // second call
5 to getValueFromUser
1
6 std::cout << x << " + " << y << " = " << x + y << '\n';
1
7 return 0;
1 }
8
1
9
2
0

5 + 7 = 12
În acest program, apelăm de două ori la getValueFromUser , la inițializarea variabilei x și la o
inițializare a variabilei y . Acest lucru ne scutește de la duplicarea codului pentru a obține
introducerea utilizatorului și reduce șansele de a greși. După ce știm
că getValueFromUser funcționează pentru o singură variabilă, aceasta va funcționa pentru atâtea
dintre ele, cât avem nevoie.
Aceasta este esența programării modulare: capacitatea de a scrie o funcție, de a o testa, de a se

asigura că funcționează și apoi să știm că o putem refolosi de câte ori dorim și va continua să
funcționeze (atâta timp cât nu vom da nu modificați funcția - moment în care va trebui să o testăm
din nou).
Urmați cele mai bune practici DRY: „nu vă repetați”. Dacă trebuie să faceți ceva de mai multe ori,
luați în considerare modul de modificare a codului dvs. pentru a elimina cât mai multă
redundanță. Variabilele pot fi utilizate pentru a stoca rezultatele calculelor care trebuie utilizate de
mai multe ori (deci nu trebuie să repetăm calculul). Funcțiile pot fi utilizate pentru a defini o
secvență de enunțuri pe care dorim să le executăm de mai multe ori. Și buclele (pe care le vom
acoperi într-un capitol ulterior) pot fi folosite pentru a executa o declarație de mai multe ori.
Concluzie
Valorile de returnare oferă o modalitate pentru ca funcțiile să returneze o singură valoare apelantului
funcției.
Funcțiile oferă o modalitate de a reduce redundanța în programele noastre.
Timp de testare
Intrebarea 1
Inspectați următoarele programe și indicați ce produc, sau dacă nu vor compila.
1a)
2
3 int return7()
4 {
5 return 7;
6 }
7
8 int return9()
9 {
1 return 9;
0 }
1
1 int main()
1 {
2 std::cout << return7() + return9() << '\n';
1
3 return 0;
1 }
4
1
5
1
6
1
7
1
8
Ascundeți soluția
Acest program imprimă numărul 16.
1b)
1
2
3
4
5
#include <iostream>
6
7
int return7()
8
{
9
return 7;
1
0
int return9()
1
{
1
return 9;
1
}
2
}
1
3
int main()
1
{
4
std::cout << return7() + return9() << '\n';
1
5
return 0;
1
}
6
1
7
1
8
Ascundeți soluția
Acest program nu va compila. Funcțiile blocate nu sunt permise.
1c)
2
3 int return7()
4 {
5 return 7;
6 }
7
8 int return9()
9 {
1 return 9;
0 }
1
1 int main()
1 {
2 return7();
1 return9();
3
1
4
1
5
1
6 return 0;
1 }
7
1
8
1
9
Ascundeți soluția
Acest program compilează, dar nu produce niciun rezultat. Valorile de retur din funcții nu sunt
utilizate pentru nimic (și astfel sunt aruncate).
1d)
1
2
3
4
5
7
8 void printA()
9 {
1 std::cout << "A\n";
0 }
1
1 void printB()
1 {
2 std::cout << "B\n";
1 }
3
1 int main()
4 {
1 printA();
5 printB();
1
6 return 0;
1 }
7
1
8
1
9
Ascundeți soluția
Acest program imprimă literele A și B pe linii separate.
1e)
2
3 void printA()
4
5
6 {
7 std::cout << "A\n";
8 }
9
1 int main()
0 {
1 std::cout << printA() << '\n';
1
1 return 0;
2 }
1
3
Ascundeți soluția
Acest program nu compilează. Funcția printA () returnează voidul, pe care principalul () încearcă să-l
trimită la std :: cout. Aceasta va produce o eroare de compilare.
1f)
1
2
3
5
6 int getNumbers()
7 {
8 return 5;
9 return 7;
1 }
0
1 int main()
1 {
1 std::cout << getNumbers() << '\n';
2 std::cout << getNumbers() << '\n';
1
3 return 0;
1 }
4
1
5
Ascundeți soluția
Acest program tipărește 5 de două ori (pe linii separate). Ambele ori când se apelează funcția
getNumbers (), valoarea 5 este returnată. Când instrucțiunea return 5 este executată, funcția este
ieșită imediat, astfel încât instrucțiunea return 7 nu se execută niciodată.
1g)
2
3 int return 5()
4 {
5 return 5;
6 }
7
8 int main()
9
1
0 {
1 std::cout << return 5() << '\n';
1
1 return 0;
2 }
1
3
Ascundeți soluția
Acest program nu va fi compilat deoarece funcția are un nume nevalid.
1h) Credit suplimentar:
1
2
4
5 int returnFive()
6 {
7 return 5;
8 }
9
1 int main()
0 {
1 std::cout << returnFive << '\n';
1
1 return 0;
2 }
1
3
Ascundeți soluția
Acest program va compila, dar funcția nu va fi apelată, deoarece apelul funcției lipsește
paranteza. Ceea ce obține efectiv rezultatul depinde de compilator.
Intrebarea 2
Ce înseamnă „DRY” și de ce este de urmat o practică utilă?
Ascundeți soluția
DRY înseamnă „Nu vă repetați”. Este o practică care presupune scrierea codului dvs. în așa fel încât
să minimizați redundanța. Acest lucru face ca programele dvs. să fie mai concise, mai puțin
predispuse la erori și mai ușor de întreținut.
2.3 - Introducere în parametrii și argumentele
funcției
În lecția precedentă, am aflat că putem avea o funcție care returnează o valoare înapoi apelantului
funcției. Am folosit asta pentru a crea o funcție modulară getValueFromUser pe care am folosit-o în
acest program:
2
4 {
5
6
7
8
9
0 int input{ 0 };
1
1 return input;
2 }
1
3 int main()
1 {
4 int num { getValueFromUser() };
1
1
6 return 0;
1 }
7
1
8
1
9
Cu toate acestea, dacă am dori să punem și linia de ieșire în propria funcție? Ați putea încerca așa
ceva:
2
3 int getValueFromUser() // this function now returns an integer value
4 {
6 int input{ 0 };
8
9 return input; // added return statement to return input back to the
1 caller
0 }
1 // This function won't compile
1 // The void return type means the function
1 won't return a value to the caller
2 void printDouble()
1 {
1 }
4
1 int main()
5 {
6
1 printDouble();
7
1 return 0;
8 }
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
Acest lucru nu va compila, deoarece funcția printDouble nu știe ce identificator num este. Ați putea
încerca să definiți num ca o variabilă în interiorul funcției printDouble ():
1 void printDouble()
2{
3 int num{ 0 }; // we added this line
5}
În timp ce aceasta abordează eroarea compilatorului și face ca programul să poată fi compilat,

programul încă nu funcționează corect (se imprimă întotdeauna „0 dublat este: 0”). Nucleul
problemei de aici este că funcția printDouble nu are o modalitate de a accesa valoarea introdusă de
utilizator.
Avem nevoie de o cale de a trece valoarea variabilei num funcției printDouble , astfel
încât printDouble poate utiliza această valoare în corpul funcției.
Parametrii și argumentele func ției

În multe cazuri, este util să se poată transmite informații către o funcție fiind numit, astfel încât
funcția are date pentru a lucra cu. De exemplu, dacă am dorit să scriem o funcție pentru a adăuga
două numere, avem nevoie de o modalitate de a spune funcția pe care două numere să o adăugăm
atunci când o numim. Altfel, cum ar ști funcția ce să adauge? Facem asta prin parametrii și
argumentele funcției.
Un parametru funcțional este o variabilă folosită într-o funcție. Parametrii funcției funcționează
aproape identic la variabilele definite în interiorul funcției, dar cu o diferență: sunt inițializate
întotdeauna cu o valoare furnizată de apelantul funcției.
Parametrii funcției sunt definiți în declarația de funcție plasându-i între paranteză după identificatorul
funcției, mai mulți parametri fiind separați prin virgule.
Iată câteva exemple de funcții cu un număr diferit de parametri:
1 // Această funcție nu are parametri

2 // Nu se bazează pe apelant pentru nimic
3 void doPrint()
4 {
5 std::cout << "In doPrint()" << '\n';
6 }
7
8 // Această funcție are un parametru întreg numit x
9 // Apelantul va furniza valoarea lui x
1 void printValue(int x)
0
1
1
1
2
1 {
3 std::cout << x << '\n';
1 }
4
1 // Această funcție are doi parametri întregi, unul numit x
5 și unul numit y
1 // Apelantul va furniza atât valoarea x cât și y
6 int add(int x, int y)
1 {
7 return x + y;
1 }
8
1
9
2
0
Un argument este o valoare care este transmisă de la apelant la funcție atunci când se face un apel
funcțional:
doPrint(); // acest apel nu are argumente

1 printValue(6); // 6 este argumentul transmis funcției
2 printValue()
3 add(2, 3); // 2 și 3 sunt argumentele transmise
funcției add ()
Rețineți că mai multe argumente sunt, de asemenea, separate prin virgule.
Cum funcționează parametrii și argumentele

Când se numește o funcție, toți parametrii funcției sunt creați ca variabile, iar valoarea fiecăruia
dintre argumente este copiată în parametrul de potrivire. Acest proces se numește pas cu valoare .
De exemplu:
2
3 // Această funcție are doi parametri întregi, unul
4 numit x și unul numit y
5 // Valorile x și y sunt transmise de apelant
6 void printValues(int x, int y)
7 {
8 std::cout << x << '\n';
9 std::cout << y << '\n';
1 }
0
1 int main()
1 {
1 printValues(6, 7); // Acest apel funcțional are două
2 argumente, 6 și 7
1 return 0;
3 }
1
4
1
5
1
6
Când funcția printValues este apelată cu argumentele 6 și 7 , parametrul x printValues este creat și
atribuit valoarea 6 , iar parametrul y printValues este creat și atribuit valoarea lui 7 .
Rezultă rezultatul:
6
7
Rețineți că numărul de argumente trebuie să corespundă, în general, cu numărul parametrilor

funcției, sau compilatorul va arunca o eroare. Argumentul transmis unei funcții poate fi orice
expresie valabilă (întrucât argumentul este în esență doar un inițializator pentru parametru, iar
inițiatorii pot fi orice expresie valabilă).
Fixarea programului nostru de provocare

Avem acum instrumentul de care avem nevoie pentru a repara programul prezentat în partea de sus
a lecției:
2
3 int getValueFromUser() // această funcție returnează acum o valoare întreagă
4 {
6 int input{ 0 };
8
9 return input; // adăugarea declarației de returnare pentru a returna introducerea
1 înapoi către apelant
0 }
1
1 void printDouble(int value)
1 {
2 std::cout << value << " doubled is: " << value * 2 << '\n';
1 }
3
1 int main()
4 {
5
1 printDouble(num);
6
1 return 0;
7 }
1
8
1
9
2
0
2
1
2
2
2
3
2
4
În acest program, variabila num este inițializată mai întâi cu valoarea introdusă de utilizator. Apoi,
funcția printDouble se numește, iar valoarea argumentului num este copiată
în parametrul valorii funcției printDouble . Funcția printDouble utilizează apoi valoarea parametrului
de valoare .
Utilizarea valorilor de returnare ca argumente

În problema de mai sus, putem vedea că variabila num este folosită o singură dată, pentru a
transporta valoarea de retur a funcției getValueFromUser la argumentul apelului la
funcția printDouble .
Putem simplifica ușor exemplul de mai sus după cum urmează:
1
2
3
4
5
6
8
9 int getValueFromUser() // this function now returns an integer value
1 {
1 int input{ 0 };
1
2 return input; // added return statement to return input back to the
1 caller
3 }
1
4 void printDouble(int value)
1 {
5 std::cout << value << " doubled is: " << value * 2 << '\n';
1 }
6
1 int main()
7 {
1 printDouble(getValueFromUser());
8
1 return 0;
9 }
2
0
2
1
2
2
Acum, folosim valoarea de retur a funcției getValueFromUser direct ca argument pentru a

funcționa printDouble !
Deși acest program este mai concis (și precizează că valoarea citită de utilizator nu va fi folosită
pentru nimic altceva), este posibil să găsiți și această „sintaxă compactă” un pic greu de citit. Dacă
te simți mai confortabil cu versiunea care folosește variabila în schimb, este în regulă.
Un avertisment despre ordinea de evaluare a argumentului func ției
Specificația C ++ nu definește dacă argumentele sunt potrivite cu parametri în ordine de la stânga
la dreapta sau dreapta la stânga. Când copiați valori, ordinea nu are nicio consecință. Cu toate
acestea, dacă argumentele sunt apeluri funcționale, acest lucru poate fi problematic:
1 someFunction(a(), b()); // a() or b() may be called first
Dacă arhitecturile evaluează de la stânga la dreapta, a () va fi apelat înainte de b (). Dacă

arhitectura evaluează de la dreapta la stânga, b () va fi apelat înainte de a (). Acest lucru poate fi
sau nu de consecință, în funcție de ceea ce fac a () și b ().
Dacă este important ca un argument să evalueze mai întâi, ar trebui să definiți explicit ordinea de
execuție, astfel:
int avar{ a() }; // a() will always be called first

1
int bvar{ b() }; // b() will always be called second
2
someFunction(avar, bvar); // it doesn't matter whether avar or bvar are copied first because they are just
3
values
Avertizare
Specificația C ++ nu definește dacă apelurile funcționale evaluează argumentele de la stânga la

dreapta sau de la dreapta la stânga. Aveți grijă să nu efectuați apeluri funcționale acolo unde
contează ordinea argumentelor.
Cum funcționează parametrii și valorile de retur

Folosind ambii parametri și o valoare de retur, putem crea funcții care iau date ca date de intrare,
facem unele calcule cu acesta și returnăm valoarea apelantului.
Iată un exemplu de funcție foarte simplă care adaugă două numere împreună și returnează
rezultatul apelantului.
2
3 // add() takes two integers as parameters, and returns the result of their sum
4 // The values of x and y are determined by the function that calls add()
6 {
7 return x + y;
8 }
9
10 // main takes no parameters
11 int main()
12 {
13 std::cout << add(4, 5) << '\n'; // Arguments 4 and 5 are passed to function add()
14 return 0;
15 }
Executarea începe din partea de sus a principalului . Atunci când add(4, 5)este evaluat, se
numește funcția add , parametrul x fiind inițializat cu valoarea 4 , iar parametrul y este inițializat cu
valoarea 5 .
Declarația de returnare în funcția de adăugare evaluează x + y pentru a produce valoarea 9 , care

este apoi returnată înapoi la principal . Această valoare de 9 este apoi trimisă la std :: cout pentru a
fi tipărită pe consolă.
ieșire:
În format pictural:
Mai multe exemple
Să aruncăm o privire la alte apeluri funcționale:
2
4 {
5 return x + y;
6 }
7
8 int multiply(int z, int w)
9 {
10 return z * w;
11 }
12
13 int main()
14 {
15 std::cout << add(4, 5) << '\n'; // within add() x=4, y=5, so x+y=9
16 std::cout << add(1 + 2, 3 * 4) << '\n'; // within add() x=3, y=12, so x+y=15
17
18 int a{ 5 };
19 std::cout << add(a, a) << '\n'; // evaluates (5 + 5)
20
21 std::cout << add(1, multiply(2, 3)) << '\n'; // evaluates 1 + (2 * 3)
22 std::cout << add(1, add(2, 3)) << '\n'; // evaluates 1 + (2 + 3)
23
24 return 0;
25 }
Acest program produce rezultatul:
9
15
10
7
6
Prima afirmație este simplă.
În cea de-a doua afirmație, argumentele sunt expresii care se evaluează înainte de a fi transmise. În
acest caz, 1 + 2 evaluează 3 , deci 3 este copiat la parametrul x . 3 * 4 evaluează 12 , deci 12 este
copiat la parametrul y . add (3, 12) se rezolvă la 15 .
Următoarea pereche de declarații este relativ ușoară și:
1 int a{ 5 };
2 std::cout << add(a, a) << '\n'; // evaluates (5 + 5)
În acest caz, se adaugă () unde valoarea unei este copiată în ambii parametri x și y . Deoarece a are
valoarea 5 , se adaugă (a, a) = se adaugă (5, 5) , care se rezolvă la valoarea 10 .
Haideți să aruncăm o privire la prima afirmație complicată din bucată:

1 std::cout << add(1, multiply(2, 3)) << '\n'; // evaluates 1 + (2 * 3)
Când funcția adaugă este executată, programul trebuie să stabilească care sunt valorile
parametrilor x și y . x este simplu, deoarece tocmai l-am trecut întregul 1 . Pentru a obține o valoare
pentru parametrul y , trebuie să evaluați mai întâi multiplicarea (2, 3) . Programul
apelează înmulțiți și inițializează z = 2 și w = 3 , deci multiplicarea (2, 3) returnează valoarea
întreagă 6 . Acea valoare returnată de 6 poate fi folosită acum pentru inițializarea parametrului y al
parametruluifuncție de adăugare . add (1, 6) returnează numărul întreg 7 , care este trecut apoi la
std :: cout pentru imprimare.
Pune mai puțin verbal:

adăugați (1, înmulțiți (2, 3)) evaluați pentru a adăuga (1, 6) evaluează la 7
Următoarea afirmație pare complicată, deoarece unul dintre parametrii dați pentru a adăuga este un
alt apel de adăugat .
1 std::cout << add(1, add(2, 3)) << '\n'; // evaluates 1 + (2 + 3)
Dar acest caz funcționează exact la fel ca cazul anterior. add (2, 3) rezolvă mai întâi, rezultând
valoarea de returnare de 5 . Acum poate rezolva adăugarea (1, 5), care se evaluează la valoarea 6 ,
care este trecută la std :: cout pentru imprimare.
Mai puțin verbal:

adăugați (1, adăugați (2, 3)) evaluează să adăugați (1, 5) => evaluează la 6
Concluzie
Parametrii funcției și valorile de returnare sunt mecanismele cheie prin care funcțiile pot fi scrise
într-un mod reutilizabil, deoarece ne permite să scriem funcții care să poată efectua sarcini și să
returneze rezultatele preluate sau calculate înapoi la apelant, fără să știm care sunt intrările sau
ieșirile specifice. inaintea timpului.
Timp de testare
Intrebarea 1
Ce este în neregulă cu acest fragment de program?
1 void multiply(int x, int y)

2 {
3 return x * y;
4 }
5
6 int main()
7 {
8 std::cout << multiply(4, 5) << '\n';
9 return 0;
10 }
Ascundeți soluția
multiplicați () este definit ca fiind returnarea voidului, ceea ce înseamnă că nu poate returna o
valoare. Deoarece funcția încearcă să returneze o valoare, această funcție va produce o eroare de
compilare. Funcția ar trebui să returneze o int.
Intrebarea 2
Ce două lucruri nu sunt în regulă cu acest fragment de program?
1 int multiply(int x, int y)

2 {
3 int product{ x * y };
4 }
5
6 int main()
7 {
8 std::cout << multiply(4) << '\n';
9 return 0;
10 }
Ascundeți soluția
Problema 1: main () trece un argument pentru a multiplica (), dar multiplicarea () necesită doi
parametri. Problema 2: multiplicarea () nu are o declarație de retur.
Întrebarea nr. 3
Ce valoare imprimă următorul program?
2
3 int add(int x, int y, int z)
4 {
5 return x + y + z;
6 }
7
8 int multiply(int x, int y)
9 {
10 return x * y;
11 }
12
13 int main()
14 {
15 std::cout << multiply(add(1, 2, 3), 4) << '\n';
16 return 0;
17 }
Ascundeți soluția
multiplicare se numește unde x = add (1, 2, 3) și y = 4. În primul rând, CPU rezolvă x = add (1, 2,
3), care returnează 1 + 2 + 3, sau x = 6. înmulțiți (6, 4) = 24, care este răspunsul.
Întrebarea nr. 4
Scrieți o funcție numită doubleNumber () care ia un parametru întreg și returnează de două ori
valoarea transmisă.
Ascundeți soluția
1 int doubleNumber(int x)
2{
3 return 2 * x;
4}
Întrebarea nr. 5
5) Scrieți un program complet care citește un număr întreg de la utilizator, îl dublează folosind
funcția doubleNumber () pe care ați scris-o pentru răspunsul la întrebare 4 și apoi imprima valoarea
dublată în consolă.
Ascundeți soluția
2
3 int doubleNumber(int x)
4 {
5 return 2 * x;
6 }
7
8 int main()
9 {
10 int x{ 0 };
11 std::cin >> x;
12 std::cout << doubleNumber(x) << '\n';
13 return 0;
14 }
Notă: S-ar putea să vină cu alte soluții (similare). De multe ori există multe moduri de a face același
lucru în C ++.

Invata C++

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Invata C++

Încărcat de

Drepturi de autor:

Formate disponibile

0.2 - INTRODUCERE ÎN LIMBAJELE DE PROGRAMARE.............................................................................

1.8 - INTRODUCERE ÎN LITERALE ȘI OPERATORI...................................................................................71

2.1 - INTRODUCERE ÎN FUNCȚII...................................................................................................................... 82

2.2 - VALORILE RETURNĂRII FUNCȚIEI....................................................................................................... 87

0.2 - Introducere în limbajele de programare

Iată un exemplu de instrucțiuni de limbaj de mașină: 10110000 01100001

Limbi la nivel înalt

Iată aceeași instrucțiune ca mai sus în C / C ++: a = 97;

Iată o reprezentare simplificată a procesului de compilare:

Iată o reprezentare simplificată a procesului de interpretare:

O bună comparație a avantajelor compilatorilor și interpretilor poate fi găsită aici .

Limbile la nivel înalt au multe proprietăți de dorit.

Unele compilatoare acceptă, de asemenea, extensii specifice compilatorului - dacă le utilizați,

Reguli, bune practici și avertismente

Cea mai buna practica

Înainte de C ++, exista C

De atunci au fost făcute trei actualizări majore la limbajul C ++ (C ++ 11, C ++ 14 și C ++ 17,

Î: La ce este bun C ++?

 Aplicații financiare de înaltă performanță (de exemplu, tranzacționare de înaltă frecvență)

 Aplicații și simulări grafice

 Productivitate / aplicații de birou

 Prelucrare audio și video

Î: Trebuie să cunosc C înainte să fac aceste tutoriale?

0.4 - Introducere în dezvoltarea C ++

Iată câteva exemple:

Pasul 2: Stabiliți cum aveți de gând s ă rezolva ți problema.

De obicei, soluțiile bune au următoarele caracteristici:

 Sunt simple (nu sunt prea complicate sau confuze).

Pasul 3: Scrieți programul

2) Sublinierea și colorarea sintaxei. Sublinierea și colorarea sintaxei schimbă culoarea diferitelor

Cea mai buna practica

0.5 - Introducere în compilator, linker și biblioteci

Pasul 4: Compilarea codului sursă

Pasul 5: Legarea fi șierelor de obiect și a bibliotecilor

Pentru cititorii avansați

Pașii 6 și 7: Testarea și depanarea

0.6 - Instalarea unui mediu de dezvoltare integrat

Visual Studio (pentru Windows)

Cod :: Blocuri (pentru Linux sau Windows)

Pentru utilizatorii Windows

Pentru utilizatorii Linux

3. Încercați să accesați setările, compilatorul, fila executabilă a cablurilor de instrumente și

4. Încercați să faceți o dezinstalare completă, apoi reinstalați.

5. Încercați un compilator diferit.

ID-uri Mac OSX

Alte compilatoare sau platforme

Î: Pot folosi un compilator pentru linia de comandă (de exemplu, g ++ pe Linux)?

Când lucrurile nu merg bine (de asemenea, când IDE înseamn ă

0.7 - Compilarea primului program

Cea mai buna practica

Creați un nou proiect pentru fiecare program nou pe care îl scrieți.

Proiecte pentru console

Iată o captură de ecran a consolei Windows:

Spații de lucru / solu ții

Scrierea primului t ău program

Crearea unui proiect în Visual Studio 2019

Vei vedea apoi un dialog care arată astfel:

În continuare, veți vedea un dialog care arată astfel:

Înlocuiți numele de proiect existent cu HelloWorld.

Faceți clic pe Create pentru a continua.

În cele din urmă, veți vedea un ultim dialog:

Crearea unui proiect în Visual Studio 2017 sau mai vechi

Exploratorul de solu ții Visual Studio