Tutorial C++: Constante - Operatori Aritmetici - Atribuire compusă - Type Casting

Constante

O constantă, sau constantă literală, este o reprezentare a unei valori fixe în program. O parte din constante le-aţi folosit în tutorialul anterior la iniţializarea variabilelor.
Constantele de tip int sunt numere întregi: 45, -123, 0, 8965 etc.
Constantele de tip double (floating-point - virgulă mobilă) sunt numere reale: 3.14, 1.6867, 0.0001, 7.0 etc. Numerele reale mai pot fi exprimate şi prin notaţia ştiinţifică.
De exemplu, numărul 1.5 * 104 poate fi reprezentat în C++ prin constanta 1.5e4, unde e înseamnă 10 la puterea.
Numărul de după e reprezintă exponentul şi, deci, nu poate conţine punct zecimal. Poate fi negativ.
Atenţie! În C++ numerele fracţionare nu pot conţine virgulă, ci doar punct zecimal.
Constantele de tip caracter (char) sunt de forma: 'caracter', unde caracter reprezintă un singur caracter ASCII.
De exemplu, 'a', 'x', 'G', 'P'. Caracterele se pun întotdeauna între două apostrofuri.
Stringurile, şirurile de caractere, se pun între ghilimele. Exemplu: "Sunt un string.".
Atenţie! Simbolul "B" este un string, nu un caracter de tip char. Următoarea atribuire este ilegală: char s = "F"; // Gresit.
Secvenţele formate din backslash \ şi un singur caracter se numesc secvenţe escape. Sunt folosite pentru a exprima caracterele imposibil de reprezentat printr-un singur simbol. Acestea sunt cele mai folosite şi utile secvenţe escape:

Secvenţă escape	Semnificaţie
\n	Rând nou - new line
\t	Tab orizontal
\\	Backslash
\'	Apostrof
\"	Ghilimele
\a	Alertă (Sunet)

Secvenţele escape sunt tratate ca un singur caracter (deşi au două), deci se pun între apostrofuri. Pot fi incluse în stringuri.
De exemplu, următoarea secvenţă de cod afişează textul pe două rânduri:

cout << "Acesta este\n" << "un exemplu.";

Stringurile sunt memorate fie în vectori de caractere, fie în obiecte de tip string (aceste tipuri vor fi prezentate în tutorialele viitoare).
Constantele booleane sunt true şi false. Reprezintă cele două valori pentru tipul bool.
C++ ne permite să declarăm variabile constante (constante declarate) cu ajutorul modificatorului const. Exemplu:

const int MAX_PLAYERS = 500;
const double PI = 3.14159;

După ce au fost definite, aceste constante declarate nu pot fi modificate de nimic în timpul execuţiei programului, nici măcar de o atribuire ulterioară (acest lucru va genera o eroare de compilare).
Acest mod de a defini constante în program este foarte util. Dacă folosiţi o valoare de mai multe ori în program este bine să-i daţi un nume şi să folosiţi numele în loc de valoarea fixă propriu-zisă. Astfel veţi putea modifica mai uşor valoarea constantei în program.
Modificatorul const poate fi folosit cu orice tip. Se numeşte modificator deoarece modifică (restricţionează) variabila declarată.
Deşi C++ nu impune acest lucru, prin convenţie constantele declarate se scriu cu litere mari şi cuvintele ce le alcătuiesc se despart prin underscore (_).

#include <iostream>
#include <string>  // Necesar pentru tipul string
using namespace std;

int main()
{
    const double PI = 3.14159;
    double raza;
    string mesaj = "Introduceti raza cercului: ";

    // cin este folosit pentru a obtine date de la user
    cout << mesaj << '\n'; cin >> raza;

    double aria = PI * raza * raza;

    cout << "Aria cercului este: " << aria;
    cout << '\n';

    system("PAUSE"); // PAUZA
    return 0;
}

Executaţi acest program.

Operatorii aritmetici

O expresie este formată din variabile, constante, operatori şi apeluri de funcţii.
Operatorii aritmetici definiţi în C++ sunt: + (adunare), - (scădere), * (înmuţire), / (împărţire) şi % (modulo).
Modulo este operaţia prin care se obţine restul împărţirii unui număr la alt număr. Exemplu: 5 % 2 returnează 1.
Ambii operanzi pentru operatorul % trebuie să fie de tip întreg.
Tipul rezultatului returnat de operatorii aritmetici depinde de tipul operanzilor.
Dacă ambii operanzi sunt de tip int atunci şi rezultatul va fi tot de tip int.

int result = 8 / 5; // 1

Dar dacă unul dintre operanzi este de tip double atunci rezultatul va fi de tip double.

8.0 / 5 // 1.6

Regulile de evaluare sunt ca la matematică. Operatorii de înmulţire şi împărţire au prioritate.
Puteţi altera ordinea evaluării folosind paranteze.
Operanzii nu trebuie să fie neapărat numere, pot fi de asemenea subexpresii:

double res = (3 + 2) / 2.0 * 3; // 7.5

Dacă nu sunteţi siguri de ordinea în care vor fi evaluate expresiile, vă recomand să folosiţi parantezele. Nu strică şi nu scad performanţa programului.
Operatorul ++ creşte valoarea variabilei cu 1, iar operatorul -- scade valoarea variabilei cu 1.
Când sunt folosiţi ca prefix, operatorii returnează noua valoare a variabilei, iar când sunt folosiţi ca sufix operatorii returnează valoarea curentă a variabilei. În ambele cazuri variabila este modificată, diferenţa constă în valoarea returnată. Exemplu:

int a = 2, b = 2;
int x = a++;  // sufix: se returneaza 2
int y = ++b;  // prefix: se returneaza 3

cout << x << ' ' << y << '\n';  // 2 3
cout << a << ' ' << b;  // 3 3

Aceşti operatori vor fi folosiţi cel mai des în structurile iterative (for, while etc.). Au prioritatea mai mare ca înmulţirea şi împărţirea!
Tabelul cu prioritatea operatorilor.

Atribuire compusă | Type casting

Atunci când vrem să actualizăm valoarea unei variabile vom folosi probabil această expresie a = a + b, unde a creşte cu valoarea lui b.
Există totuşi o notaţie prescurtată pentru acest tip de atribuire:

variabila operator= expresie;

De exemplu:

int a = 4, b = 2;
a += b + 1; // echivalent cu: a = a + (b + 1);
a *= b - 2; // echivalent cu: a = a * (b - 2);
a %= (b - 1) + 5; // echivalent cu: a = a % ((b - 1) + 5);

Type casting sau conversia de tip este metoda prin care puteţi converti o valoare de un tip într-un alt tip. Se realizează cu operatorul static_cast. De exemplu, dacă avem un int şi vrem să-l convertim în double, folosim:

int a = 7; double x;
x = static_cast<double>(a);

Sintaxa generală:

static_cast<tip>(expresie);

Acest operator nu modifică valoarea variabilei convertite, ci o returnează ca o valoare nouă convertită în tipul specificat. Folosind conversia puteţi afla valoarea ASCII a unui char:

int val; char p = 'A';
val = static_cast<int>(p); // 65

Metoda învechită, aproximativ echivalentă cu cea de sus, este următoarea:

int val; char p = 'A';
val = (int)p;
// sau
val = int(p);

Atunci când convertiţi din double (sau float) într-un tip întreg (int, short, long etc.) veţi pierde partea fracţionară (de după punctul zecimal). Nu se fac rotunjiri! Exemplu:

double epsilon = 4.9565;
int alpha = static_cast<int>(epsilon); // 4

Sfat: Oriunde puteţi avea o constantă literală în program, puteţi avea şi o expresie, deoarece expresia, în cele din urmă, va fi evaluată la o singură valoare.