Tutorial C++: Identificatori - Variabile - Atribuire

Identificatori

Identificatorii reprezintă numele dat entităţilor dintr-un program C++.
Identificatorii pot începe cu literă sau underscore (_) şi pot continua numai cu litere, cifre sau underscore. Exemplu:

Apple, _mCount, startDownload1

Exemplu de identificatori nevalizi:

1apple, _mCount.20, 123

Aceştia vor fi respinşi de compilator. Nu sunt identificatori valizi deoarece: primul începe cu o cifră, al doilea conţine un caracter nepermis (punct), iar ultimul este un număr.
C++ este case-sensitive, deci Home este diferit de HoMe.
Nu folosiţi ca identificatori cuvintele rezervate - reserved keywords - şi identificatorii predefiniţi (de exemplu cout).
Deşi este posibil să redefiniţi aceşti identificatori, nu recomand asta deoarece fac parte din bibliotecile standard C++, şi cu siguranţă veţi avea nevoie de acestea.
De cele mai multe ori, IDE-urile colorează cuvintele rezervate în albastru, deci nu trebuie să le învăţaţi.
Nu există limită pentru numărul de caractere pe care-l poate avea un identificator. Unele compilatoare vor lua în considerare doar un anumit număr de caractere. Este un număr mare deci nu vă faceţi griji.
O convenţie populară (care a devenit universală în OOP) de numire este camelCase. În notaţia camelCase, literele mari sunt folosite pentru a delimita cuvintele dintr-un identificator. De exemplu:

bigApple, getName, setCount, estePrim

Prima literă poate fi mare, dar asta de obicei când numiţi clase (tipuri definite de programator).

Variabile

De cele mai multe ori programele lucrează cu informaţii. Aceste informaţii trebuie salvate undeva. Acest undeva este memoria.
Pentru a putea manipula informaţia în program, folosim variabile. Variabilele trebuie declarate înainte de a putea fi folosite. A declara o variabilă înseamnă:

• Să specifici ce fel de valori vei memora în respectiva variabilă
• Să-i dai un nume

Tipul de dată specifică ce valori poate memora o variabilă şi cât spaţiu va ocupa în memorie.
Calculatorul trebuie să cunoască tipul de dată al variabilei deoarece pe baza acestuia stabileşte cât spaţiu rezervă variabilei respective şi stabileşte algoritmii de codificare şi decodificare ai informaţiei.
De exemplu, caracterul 'a' în memorie este 1100001, dar acest şir de 1 şi 0 este de fapt numărul 97 scris în binar. Deoarece calculatorul ştie (datorită tipului de date) că lucrează cu un caracter, acesta va afişa (atunci când îi cerem) pe ecran caracterul a în loc de numărul 97.
Calculatorul ştie permanent adresa de memorie a fiecărei variabile. Astfel poate să actualizeze informaţia stocată în respectiva locaţie.
Puteţi afla adresa de memorie a variabilei folosind operatorul & (voi discuta mai multe despre asta în tutorialul despre pointeri).

int numar;
double pi, epsilon;

Prima linie declară o variabilă de tip int care poate memora numai numere întregi (integer).
A doua linie declară două variabile de tip double care pot memora numere reale (floating-point).
Observaţi că puteţi declara mai multe variabile de acelaşi tip pe aceeaşi linie despărţite prin virgulă. De asemenea, instrucţiunea de declarare se termină cu punct şi virgulă.
Pe lângă int şi double mai există tipurile char, float, bool, short, long. Toate acestea se numesc tipuri fundamentale (tipuri primitive).
Tabelul cu tipurile fundamentale îl găsiţi aici. NU trebuie să-l memoraţi!
Trebuie doar să ştiţi că int ocupă de obicei 4 bytes şi este folosit pentru numere întregi, double ocupă 8 bytes şi este folosit pentru numere reale, iar char ocupă 1 byte şi este folosit pentru caractere ASCII.
Tipurile întregi sunt: short (2 bytes), int, long (8 bytes). Puteţi trata char ca pe un tip întreg - deoarece fiecărui caracter ASCII îi corespunde un număr întreg - dar nu recomand acest lucru.
Tipurile reale sunt: float (4 bytes) şi double.
Tipul bool ocupă 1 byte şi memorează doar două valori: true şi false.

// Sintaxa de declarare
tip_data variabila1, variabila2, variabila3, ..., variabilaN;

// Exemple
int x, y, z;
char litera; bool ok;
double alfa, theta;

Fiecare din tipurile întregi pot fi unsigned, însemnând că reprezintă doar numere întregi pozitive. Evident că mulţimea de valori va fi mai mare.
De exemplu, dacă int ia valori din intervalul [-2,147,483,647 până la 2,147,483,647] atunci unsigned int va lua valori din intervalul [0 la 4,294,967,295]. Dacă vreţi să ştiţi cum sunt reprezentate numerele negative într-un calculator, intraţi aici.

Atribuirea

Atribuirea (asignarea) în C++ se face cu operatorul = (operatorul de atribuire). Atribuirea este operaţia prin care puteţi schimba valoarea unei variabile în mod direct.

int a = 40;

Mai sus am atribuit variabilei a valoarea 40. Observaţi că am făcut acest lucru imediat după ce am declarat variabila. Se citeşte a ia valoarea 40. (NU vă gândiţi la noţiunea de egalitate din matematică. Pentru asta avem operatorul ==).
Atunci când sunt declarate, variabilele nu au o valoare bine definită. De aceea este important să iniţializaţi o variabilă înainte de a o folosi.
Variabilele declarate global (în afara oricărei funcţii şi clase) sunt iniţializate automat cu valoarea implicită. Pentru tipurile întregi aceasta este 0, pentru bool este false, iar pentru char este '\0'.
Se zice că o variabilă este iniţializată atunci când îi atribuiţi o valoare pentru prima dată.
Mecanismul de asignare funcţionează în felul următor:
Partea din dreapta operatorului = (rvalue), care poate fi o variabilă, o constantă, sau o expresie, este evaluată, şi rezultatul evaluării este memorat în partea din stânga operatorului = (lvalue), care trebuie să fie o variabilă.

int x;
x = 45 + 32;

Variabila x are valoarea 77.
Deoarece operatorul = returnează valoarea atribuită variabilei, este posibil să-l folosim în felul următor:

int a, b;
a = b = 5;

Atenţie! Operaţia de atribuire este evaluată de la dreapta la stânga!!
În exemplu, b ia valoarea 5, iar apoi a ia valoarea returnată de operatorul = din subexpresia b = 5, adică a ia valoarea 5.
Fie următorul exemplu:

int a = 4, b;
b = a = 3;

Atât a cât şi b vor fi 3.
Atunci când daţi valori variabilelor încercaţi să nu amestecaţi tipurile. De exemplu unei variabile de tip int nu-i daţi valoarea 5.678 (double). Bineînţeles că în variabila int va fi memorat doar 5 (partea întreagă a lui 5.678), deoarece compilatorul face conversia automat. Dar aceste conversii automate, chiar dacă nu generează erori, pot duce la buguri în program.

Rulaţi următorul program:

#include <iostream>
using namespace std;

int main()
{
    int a, b = 10;
    double x, z, pi = 3.14;
    
    a = b = 30;
    x = pi;     // x este initializat
    z = x * pi; // * - inmultire
    b = (a + b) - 2 * b;
    
    // cout afiseaza pe ecran
    cout << a << ' ' << b << ' ' << x << ' ' << z;
    system("PAUSE"); // PAUZA
    return 0;
}

Tutorial C++: Structura unui program C++

#include <iostream>
using namespace std;

int main()
{
    // Afiseaza pe ecran Hello World
    cout << "Hello World";
    return 0;
}

Directivele preprocesor

#include <iostream>

Această linie se numeşte directivă preprocesor sau simplu directivă. Se deosebeşte de celelalte linii de cod prin faptul că începe cu #.
Rolul acestor linii este multiplu. Aici, directiva #include are rolul de a preciza compilatorului faptul că vom folosi în program entităţile (funcţii, clase, constante, etc.) din fişierul iostream (cout este un obiect definit în namespace-ul std din iostream).
În acest mod putem scrie programe pornind de la altele existente, fără a rescrie conţinutul lor în noul program. E un mod de a salva timp, spaţiu şi bani.
Fişierul iostream face parte din standardul C++ (compilatorul ştie unde se află, de aceea nu trebuie să precizăm întreg path-ul).
Directivele nu se termină cu punct şi virgulă (Reţineţi asta!).
Următoarea linie using namespace std; spune că vom folosi toate numele (denumirile entităţilor) din secţiunea (această secţiune se numeşte de fapt namespace; veţi afla mai târziu ce este acesta) std din iostream.
Majoritatea programelor C++ vor începe cu aceste două linii. Fără ele nu veţi putea afişa pe ecran şi nu veţi putea citi date de la user.

Funcţia main

Un program C++ constă practic doar din funcţia main. Atunci când rulaţi programul, sistemul de operare invocă automat funcţia numită main.
Funcţiile - alte denumiri pentru conceptul de funcţie sunt: procedură, subprogram, metodă (în OOP) - sunt entităţi ce grupează sub un singur nume o porţiune de cod din program.
Funcţiile pot fi apelate (invocate) precizând numele acestora. Atunci când o funcţie este invocată, codul funcţiei - se află între acolade - va fi executat.
Observaţi că o funcţie permite executarea aceluiaşi cod de mai multe ori fără a scrie respectivul cod de mai multe ori în program.
Main este entry-pointul (punctul de intrare) programului. Aproape toate limbajele de programare necesită definirea unei funcţii main. Fiecare program trebuie să aibă un punct de start, iar acest punct este funcţia main.
Linia int main() se numeşte antetul sau header-ul funcţiei. În antet apar: tipul valorii returnate de funcţie (aici int), numele funcţiei (aici main), parametrii între paranteze (dacă există).
Corpul funcţiei (function body) constă din cele două acolade şi codul definit între ele.
Instrucţiunea return 0; returnează valoarea 0 şi totodată opreşte execuţia funcţiei. Deoarece sistemul de operare a apelat funcţia, tot el este acela care va primi valoarea returnată de main. Codul 0 semnifică faptul că programul a rulat fără probleme.

Instrucţiuni şi comentarii

Instrucţiunile (statements) reprezintă comenzi către calculator; sarcinile pe care acesta trebuie să le îndeplinească.
Toate instrucţiunile trebuie să se termine cu punct şi virgulă ; (Reţineţi asta!).
Puteţi avea mai multe instrucţiuni pe aceeaşi linie atâta timp cât le separaţi prin punct şi virgulă.
În programul de mai sus, instrucţiuni sunt:

using namespace std;
cout << "Hello World";
return 0;

Directivele sunt instrucţiuni - speciale - pentru preprocesor. Preprocesorul este executat de compilator înainte ca procesul de compilare să aibă loc.
Linia // Afiseaza pe ecran Hello World reprezintă un comentariu (comment). Comentariile nu fac nimic (nu sunt instrucţiuni). Sunt de 2 feluri:
- comentariile întinse pe un rând (încep cu //);
- comentariile întinse pe mai multe rânduri (încep cu /* şi se termină cu */). Exemplu:

/* Grumpy wizards make toxic brew 
for the evil Queen and Jack. */

Comentariile sunt ignorate de compilator. Comentariile sunt folosite, în general, pentru a explica anumite părţi ale programului.
Instrucţiunea cout << "Hello World"; afişează pe ecran textul Hello World.

Instrucţiunile din program sunt executate secvenţial (una după alta) de la început până la sfârşit. După ce toate instrucţiunile au fost executate, programul îşi încetează execuţia.
Şi compilatorul scanează secvenţial codul sursă atunci când îl translatează în cod maşină.
Motivul pentru care browserul - pe care-l folosiţi acum - nu se opreşte este că acesta aşteaptă comenzi de la user. Dacă userul apasă pe X, atunci browserul se va opri, deoarece comanda de terminare va fi ultima de îndeplinit.
Este posibil să alterăm execuţia secvenţială a programului folosind structurile de control (for, if, while, etc.). Acestea modifică flow-ul execuţiei programului în funcţie de anumite condiţii. Voi discuta despre aceste lucruri mai târziu.

Tutorial C++: Introducere

Limbajul C++

C++, denumit iniţial C++ cu clase, este o extensie a limbajului C, inventat de Dennis Ritchie la AT&T Bell Laboratories pe la începutul anilor 1970.
Ritchie a folosit acest limbaj pentru a crea şi întreţine sistemul de operare UNIX.
La începutul anilor 1980, Bjarne Stroustrup (tot la AT&T Bell Laboratories) a inventat C++, având ca subset limbajul C. Motivul pentru care a făcut asta a fost că, deşi C era un limbaj popular (şi astăzi continuă să fie) nu avea caracteristicile unui limbaj OOP; C este un limbaj procedural.
OOP (Programarea Obiect-Orientată) este cea mai populară şi puternică tehnică (paradigmă) de programare. Ideea de bază a OOP este că datele pot fi organizate în obiecte, fiecare cu atributele şi acţiunile specifice. Cele trei caracterisitici ale OOP sunt: încapsularea (encapsulation), moştenirea (inheritance) şi polimorfismul (polymorphism). Momentan nu vă bateţi capul cu OOP. Le voi aborda în alte lecţii.
Pe lângă OOP, C++ oferă suport şi pentru programarea generică (cu template-uri), tratarea excepţiilor, are propria sintaxă pentru managementul memoriei (C++ nu dispune de garbage collection), şi altele.

Memoria

Trebuie să ştiţi că toate aplicaţiile pe care le rulaţi pe calculator (inclusiv elementele necesare funcţionării sistemului de operare) sunt încărcate în memoria RAM (Random Access Memory). Această memorie are caracter volatil (adică conţinutul său se poate schimba).
Deci şi aplicaţiile care le veţi crea în C++ vor rula în memoria RAM, sau pe scurt, memorie. Atunci când o aplicaţie este închisă, sistemul de operare poate dispune de curăţarea zonei de memorie ocupată de acea aplicaţie.
Atunci când opriţi calculatorul conţinutul memoriei RAM este pierdut, spre deosebire de hard-disk al cărui conţinut se păstrează. Capacitatea memoriei se măsoară în bytes. Un byte are 8 biţi, iar un bit reprezintă cantitatea de bază a informaţiei din sitemele informatice şi din telecomunicaţii. (0 şi 1).
Fizic un bit este reprezentat în memoria RAM de o pereche formată dintr-un tranzistor şi un capacitor numită celulă de memorie. O celulă de memorie reprezintă 1 bit.
Dacă capacitorul este încărcat (stochează electroni), înseamnă că bitul este 1, iar dacă este descărcat (nu are electroni) înseamnă că bitul este 0.
Celulele de memorie sunt aranjate într-o matrice bidimensională, iar intersecţia dintre linia şi coloana celulei de memorie reprezintă adresa acesteia.
Cunoscând adresa de memorie procesorul, poate cere conţinutul (informaţia) celulei de memorie respective.
Dacă vreţi să ştiţi mai multe despre memoria RAM intraţi pe http://www.howstuffworks.com/ram.htm.

Codul sursă, compilator, IDE

Codul sursă este codul C++ (sau alt limbaj) folosit la scrierea unui program într-un fişier cu extensia - pentru C++ - .cpp sau .cc.
Înainte de a deveni executabil, acest fişier ce conţine codul sursă trebuie translatat într-un limbaj înţeles de calculator (codul maşină sau codul obiect). C++ este un limbaj de nivel înalt, adică este mai apropiat limbajului uman decât limbajului înţeles de calculator.
Compilatorul este un program special care traduce codul sursă în cod maşină (binar).
Mai multe detalii despre compilator: http://whatis.techtarget.com/definition/compiler.
Rezultatul procesului de compilare (şi linkeditare; vezi linkul de mai sus) este fişierul executabil.
Un IDE (Integrated Development Environment) este un program ce cuprinde un editor de text, un compilator, debugger şi builder. Veţi folosi un IDE ca să creaţi programe C++.
Pentru aceste tutoriale vă recomand să folosiţi Visual Studio Express. Puteţi folosi de asemenea şi CodeBlocks.
Sau puteţi folosi IDE-ul online IDEONE.

Tutorial creare proiect C++ în Visual Studio