Tutorial C++: Input / Output cu CIN şi COUT

Output cu COUT

Am văzut că pentru a putea folosi obiectele cout (console output) şi cin avem nevoie de biblioteca (library) iostream. Ca să putem folosi această bibliotecă trebuie să includem următoarele linii la începutul programului:

#include <iostream>
using namespace std;

Afişarea numerelor sau stringurilor pe ecran (consolă) se face cu obiectul cout şi operatorul de inserţie <<. De exemplu:

cout << "Quick wafting zephyrs vex bold Jim\n"
     << "The five boxing wizards jump quickly.\n";

cout afişează datele aşa cum le daţi. cout nu formatează nimic, nu adaugă spaţii între cuvinte, nu adaugă new line, etc. Exemplu:

cout << "Quick" << "wafting" << "zephyrs";

Se va afişa:

Quickwaftingzephyrs

Dacă vrem spaţii între cuvinte atunci adăugăm şi spaţii:

cout << "Quick" << " " << "wafting" << " " << "zephyrs";

Lanţul cout poate fi oricât de lung vreţi. Nu e obligatoriu să-l aveţi pe un singur rând (vezi primul exemplu). Trebuie să se termine cu punct şi virgulă.
Puteţi, de asemenea, să aveţi expresii într-o instrucţiune cout:

cout << "Aria cercului este:" << (PI * raza * raza);

Practic orice obiect care are o reprezentare string poate fi afişat pe ecran cu cout.
Aţi văzut că un rând nou se inserează cu secvenţa escape '\n'. Ei bine, mai este o metodă cu endl. De exemplu:

cout << "Quick wafting zephyrs vex bold Jim" << endl << "The five boxing wizards jump quickly.\n";

Atunci când vreţi să afişaţi numere double s-ar putea să nu obţineţi ceea ce vreţi.

double phi = 4.893654;
cout << phi;

Se va afişa 4.893654. Dar poate vreţi să afişaţi doar primele două zecimale. Cum faceţi asta? Cu următoarele instrucţiuni:

cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(2);

Prima instrucţiune ne permite să folosim funcţia precision doar pentru partea fracţionară (de după punct); altfel ar fi luat în considerare tot numărul.
A doua instrucţiune afişează punctul zecimal de fiecare dată - chiar şi pentru numere întregi.
A treia instrucţiune setează precizia numărului la 2 zecimale. Se fac rotunjiri! Argumentul funcţiei trebuie să fie pozitiv şi număr întreg sau o expresie evaluată la int.
După aceste instrucţiuni puteţi folosi cout normal ca să afişaţi numerele reale în noul format:

cout << phi; // 4.89

Puteţi folosi opţiunea ios::scientific ca să afişaţi în notaţie ştiinţifică:

double phi = 0.0000123;
cout.setf(ios::scientific);
cout.setf(ios::showpoint);
cout.precision(2);
cout << phi; // 1.23e-005

Input cu CIN

Similar putem folosi cin (console input) pentru operaţii de input, adică de obţinere a datelor de la tastatură (de la user). Se foloseşte cu operatorul de extracţie >>.

int a, b;
cout << "Introduceti doua numere: ";
cin >> a >> b; 
cout << "Suma lor este: " << (a + b);

Atunci când întâlneşte instrucţiunea cin, programul aşteaptă inputul de la user. Atribuie prima valoare primei variabile, a doua valoare variabilei a doua, etc.
Programul nu citeşte datele de intrare decât după ce utilizatorul apasă ENTER la tastatură. În acest fel userul se poate corecta folosind backspace.
Obiectul cin foloseşte spaţiile albe (space, enter, tab, etc.) ca delimitatoare. Asta înseamnă că datele de intrare trebuie despărţite prin câte un spaţiu sau rând nou (new line).
cin ignoră - şi elimină din fluxul (stream) de intrare - toate spaţiile albe până întâlneşte un input valid.
Deoarece ignoră spaţiile albe, nu puteţi citi propoziţii de cuvinte cu cin. Trebuie să folosiţi funcţia getline (care citeşte până când întâlneşte un caracter new line pe care îl extrage din stream şi-l ignoră). Se foloseşte cu tipul string:

string fullname;
getline(cin, fullname);
cout << "\nNumele tau este: \n" 
     << fullname << endl;

Primul parametru trebuie să fie cin pentru că citiţi de la tastatură.
Al doilea parametru este o variabilă string în care va fi salvat şirul.
Streamul (fluxul) de intrare (input stream) reprezintă şirul datelor de intrare. Imaginaţi-vă un flux de informaţii care curge către calculator. Aceste date vin nu numai de la tastatură, ci şi de la alte dispozitive de intrare: mouse, scanner, mircofon, etc.
cin se ocupă numai de tastatură.
Similar, cout scrie în streamul de ieşire (output stream) care este afişat pe ecran.
Exemplu: Se citesc de la tastatură trei numere naturale. Să se afişeze suma lor.
Pentru datele de intrare: 14 89 99 se va afişa 202.

#include <iostream>
using namespace std;

int main()
{
    int a, b, c;
    cin >> a >> b >> c;
    cout << a + b + c;  // parantezele pot lipsi

    system("PAUSE"); 
    return 0;
}

Cu cin puteţi citi numere întregi şi reale, stringuri şi caractere, etc.

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.