Intrări și ieșiri standard

in limbajul C

C++
C++ Preliminarii
› Pentru afișarea informației alfanumerice pe ecran (ieșirea la
consolă), precum și pentru citirea datelor de la tastatură
(intrarea de la consolă), în limbajul standard C sunt utilizate două
funcții standard ale limbajului – printf() și scanf().
› O variantă a acestor comenzi (fprintf() și fscanf()) permite,
de asemenea, operații de intrare/ieșire cu fișierele.
› O altă variantă (sprintf() și sscanf()) realizează operații de
intrare/ieșire cu șiruri de caractere (funcția sscanf() este
deosebit de utilă).
› Toate acestea, precum și multe alte funcții de intrare/ieșire sunt
declarate în fișierul antet standard <stdio.h>.
C++
› Utilizarea lui scanf() este mai complicată decât printf(). Acest
lucru se datorează forțării la un alt tip de date, astfel încât orice tip
mai mic decât int este forțat la int atunci când este afișat cu
printf, iar argumentele de tip floats sunt forțate la double (cu
excepția cazului în care argumentele sunt modificate de un prefix de
dimensiune).
› printf() (print formated – tipărire formatată) din limbajul C, scrie un
șir de caractere de tip cstring în stdout (ieșirea standard). Șirul de
caractere furnizat poate conține specificatori de format, care încep cu
caracterul %.
› Dacă există specificatori de format, aceștia sunt înlocuiți cu
argumentele care urmează la apelul lui printf(). Acești specificatori
de format pot conține, de asemenea, lungimea, precizia și alte
indicatoare.
C++ Sintaxă
int printf (const char* c-string, ...);

› Valoare returnată: Dacă funcția se execută cu succes, returnează

numărul total de caractere scrise la ieșirea standard. Dacă apare
o eroare, este returnat un număr negativ (-1).
› Argumente: c-string este șirul transmis funcției de tipărire ca
argument. Pot exista argumente suplimentare după c-string,
dacă există specificatori (descriptori).
C++
%[flags][width][.precision][length]specifier 

› Parametrul flags
- Valoarea va fi aliniată la stânga (implicit la dreapta)
+ Forțează afișarea semnului și pentru numerele pozitive (pentru
numere: int, float, etc.)
# Modifică suplimentar afișarea (vezi explicație la fiecare
specificator)
0 Completează cu zerouri până la atingerea lățimii câmpului
(pentru numere)
C++
› Parametrii width (lățime) și precision (precizie) sunt
specificate fie prin întregi, fie prin caracterul *, caz în care vor fi
trimise ca parametri. De exemplu:
printf("%*d", 10, i);
› va afișa întregul i pe 10 poziții.
printf("%i + %i = %i\n", 2, 3, (2+3));
› va produce următoarea ieșire (prin conversia celor trei
argumente întregi în șiruri utilizând formatarea implicită):
2 + 3 = 5
C++
› Specificatorii de lungime:
hh char
h short
l long
ll long long
L long double
C++ Funcția de ieșire printf()
› Funcția printf() permite scrierea cu format pentru orice tip de date.
› Sintaxă: int printf(format, arg1, arg2,... );
› Afișează pe ecran valorile expresiilor din lista argumentelor, conform
formatului specificat. Argumentele pot fi constante, variabile, expresii.
Dacă nu apare nici un argument, pe ecran se tipăresc doar caracterele
din șirul format.
› Parametrul format este un șir de caractere care trebuie să includă
câte un descriptor de format pentru fiecare din argumente.
Сaracterele din format care nu fac parte din descriptori se tipăresc pe
ecran. Funcția returnează numărul de valori tipărite sau EOF în cazul
unei erori.
C++ Specificatori de format
Tipuri de date Specificatori de format
int %d sau %i
char %c
float %f
double %lf
short int %hd
unsigned int %u
long int %li
long long int %lli
unsigned long int %lu
unsigned long long int %llu
signed char %c
unsigned char %c
long double %Lf
C++

printf("Caractere: %c %c \n", 'a', 65);

printf("Intregi: %d %ld\n", 1977, 650000L);
printf("Precedat de spatii : %10d \n", 1977);
printf("Precedat de zerouri: %010d \n", 1977);
printf("Diferite sisteme de numeratie: %d %x %o %#x %#o \n",100,100,100,100,100);
printf("Reale: %4.2f %+.0e %E \n", 3.1416, 3.1416, 3.1416);
printf("Truc cu latimea: %*d \n", 5, 10);
printf("%s \n", "Un sir de caractere! ");

Caractere: a A
Intregi: 1977 650000
Precedat de spatii : 1977
Precedat de zerouri: 0000001977
Diferite sisteme de numeratie: 100 64 144 0x64 0144
Reale: 3.14 +3e+000 3.141600E+000
Truc cu latimea: 10
Un sir de caractere!
C++
Specificatori Descriere
format
%d întreg zecimal cu semn
%i întreg zecimal, octal (0) sau hexazecimal (0x, 0X)
%o întreg în octal, fără 0 la început
%u întreg zecimal fără semn
%x, %X întreg hexazecimal, fără 0x/0X; cu a-f pentru %x, A-F pentru %X
%c caracter
%s șir de caractere, până la '\0' sau număr de caractere dat ca precizie
%f, %F real fără exponent; precizie implicită 6 poziții; la precizie 0: fără
punct real (posibil cu exponent)
%e, %E numere reale cu mantisă și exponent (al lui 10); precizie implicită 6
poziții; la precizie 0: fără punct
%g, %G numere reale în format %f sau %e, funcție de valoare real, ca %e, %E
dacă exponentul<-4 sau precizia; altfel ca %f. Nu tipărește zerouri
sau punct zecimal în mod inutil

%p pointer, în formatul tipărit de printf

%ld, %li numere întregi lungi
%lf, %le, %lg numere reale în precizie dublă (double)
%Lf, %Le, %Lg numere reale de tip long double
%% caracterul procent
C++ Afișare număr întreg
#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
int x = 123;
printf("Afisare 123 folosind %%0d ca format %0d\n", x);
printf("Afisare 123 folosind %%1d ca format %1d\n", x);
printf("Afisare 123 folosind %%2d ca format %2d\n", x);
printf("Afisare 123 folosind %%3d ca format %3d\n", x);
printf("Afisare 123 folosind %%4d ca format %4d\n", x);
printf("Afisare 123 folosind %%5d ca format %5d\n", x);
printf("Afisare 123 folosind %%6d ca format %6d\n", x);
printf("Afisare 123 folosind %%7d ca format %7d\n", x);
printf("Afisare 123 folosind %%8d ca format %8d\n", x);
printf("Afisare 123 folosind %%9d ca format %9d\n", x);
  return 0;
}
C++ Afișare număr întreg

Afisare 123 folosind %0d ca format 123

Afisare 123 folosind %1d ca format 123
Afisare 123 folosind %2d ca format 123
Afisare 123 folosind %3d ca format 123
Afisare 123 folosind %4d ca format 123
Afisare 123 folosind %5d ca format 123
Afisare 123 folosind %6d ca format 123
Afisare 123 folosind %7d ca format 123
Afisare 123 folosind %8d ca format 123
Afisare 123 folosind %9d ca format 123
C++ Afișare număr real
#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
float x = 3.141592;
printf("Afisare 3.141592 folosind %%f \t\t ca format %f\n", x);
printf("Afisare 3.141592 folosind %%1.1f \t ca format %1.1f\n", x);
printf("Afisare 3.141592 folosind %%1.2f \t ca format %1.2f\n", x);
printf("Afisare 3.141592 folosind %%3.3f \t ca format %3.3f\n", x);
printf("Afisare 3.141592 folosind %%4.4f \t ca format %4.4f\n", x);
printf("Afisare 3.141592 folosind %%4.5f \t ca format %4.5f\n", x);
printf("Afisare 3.141592 folosind %%09.3f \t ca format %09.3f\n", x);
printf("Afisare 3.141592 folosind %%-09.3f \t ca format %-09.3f\n", x);
printf("Afisare 3.141592 folosind %%9.3f \t ca format %9.3f\n", x);
printf("Afisare 3.141592 folosind %%-9.3f \t ca format %-9.3f\n", x);
  return 0;
}
C++ Afișare număr real

Afisare 3.141592 folosind %f ca format 3.141592

Afisare 3.141592 folosind %1.1f ca format 3.1
Afisare 3.141592 folosind %1.2f ca format 3.14
Afisare 3.141592 folosind %3.3f ca format 3.142
Afisare 3.141592 folosind %4.4f ca format 3.1416
Afisare 3.141592 folosind %4.5f ca format 3.14159
Afisare 3.141592 folosind %09.3f ca format 00003.142
Afisare 3.141592 folosind %-09.3f ca format 3.142
Afisare 3.141592 folosind %9.3f ca format 3.142
Afisare 3.141592 folosind %-9.3f ca format 3.142
C++ Afișare diferite tipuri de date
printf ("\n"); // trecere la o noua linie
printf ("\n Eroare \n"); // scrie "Eroare " pe o linie noua
int a=3;
printf ("%d\n",a); // scrie "3" ca intreg si trece la linia urmatoare
a=5; int b=7;
printf ("a=%d b=%d\n", a, b); //scrie "a=5 b=7" si trece la linia urmatoare
int g=30, m=5, s=2;
printf ("%2d grade %2d min %2d sec\n", g,m,s);
// scrie "30 grade 5 min 2 sec" si schimba linia
int anInt = 12345;
float aFloat = 55.6677;
double aDouble = 11.2233;
char aChar = 'a';
char aStr[] = "Salut!";
printf("int: %d.\n", anInt);
printf("real: %f.\n", aFloat);
printf("double: %f.\n", aDouble);
printf("char: %c.\n", aChar);
printf("string: %s.\n", aStr);
printf("int (in hex): %x.\n", anInt);
printf("double (stiintific): %e.\n", aDouble);
printf("float (stiintific): %E.\n", aFloat);
C++ Afișare diferite tipuri de date

Eroare
3
a=5 b=7
30 grade 5 min 2 sec
int: 12345.
real: 55.667702.
double: 11.223300.
char: a.
string: Salut!.
int (in hex): 3039.
double (stiintific): 1.122330e+001.
float (stiintific): 5.566770E+001.
C++ Afișare diferite tipuri de date
// Exemplu de utilizare a optiunii "0" pentru a scrie intotdeauna doua
// cifre, chiar si pentru numere de o singura cifra:
int ora=9, min=7, sec=30;
printf ("%02d:%02d:%02d\n",ora, min, sec); // scrie 09:07:30
// Exemplu ce afiseaza 10 spatii
printf("afisez 10 spatii: %*c",10," ");
// Exemplu de utilizare a optiunii "-" pentru aliniere siruri la stanga:
char a[] = "unu", b[] ="cinci", c[]= "sapte" ;
printf (" %-10s \n %-10s \n %-10s \n", a, b, c);
int i1 = 12345, i2 = 678;
printf("Hello, first int is %d, second int is %5d.\n", i1, i2);
// Hello, first int is 12345, second int is 678.
printf("Hello, first int is %d, second int is %-5d.\n", i1, i2);
// Hello, first int is 12345, second int is 678.
int a1=203, b1=5, c1=16;
printf ("%10d \n %10d \n %10d \n",a1,b1,c1);
char msg[] = "Salut";
printf("xx%10sxx\n", msg); // xx Salutxx
printf("xx%-10sxx\n", msg); // xxSalut xx
C++ Afișare diferite tipuri de date

09:07:30
afisez 10 spatii: 4 unu
cinci
sapte
Hello, first int is 12345, second int is 678.
Hello, first int is 12345, second int is 678 .
203
5
16
xx Salutxx
xxSalut xx
C++ Observații
› În general trebuie să existe o concordanță între numărul și tipul
variabilelor și formatul de citire sau scriere din funcțiile scanf şi
printf, dar această concordanță nu poate fi verificată de
compilator și nici nu este semnalată ca eroare la execuție, dar se
manifestă prin falsificarea valorilor citite sau scrise.
› O excepție notabilă de la această regulă generală este
posibilitatea de a citi sau scrie corect numere de tip double cu
formatul "%f" (pentru tipul float), dar nu și numere de tip
long double (din cauza diferențelor de reprezentare internă a
exponentului).
C++ Funcția scanf()
› Funcția scanf() permite citirea cu format pentru orice tip de date.
Sintaxă: int scanf ( format, adr1, adr2, ... );
› Citește informațiile tastate pe care le interpretează conform
specificatorilor din format, memorând valorile citite la adresele
transmise ca parametri.
› Parametrul format este un șir de caractere care trebuie să includă
câte un descriptor de format pentru fiecare dintre valorile citite.
› Adresele sunt pointeri sau adresele variabilelor ale căror valori se
citesc. Adresa unei variabile se obține folosind operatorul de adresare
&, astfel: &nume_variabila
› Valorile întregi sau reale consecutive introduse de la tastatură trebuie
separate de cel puțin un spațiu alb (Enter, Spate, Tab)
› Returnează numărul de valori citite sau EOF dacă s-a tastat Ctrl/Z.
C++ Descriptorii de format din funcția scanf()
Specificatori format Descriere
%d întreg zecimal cu semn
%i întreg zecimal, octal (0) sau hexazecimal (0x, 0X)
%o întreg în octal, precedat sau nu de 0
%u întreg zecimal fără semn
%x, %X întreg hexazecimal, precedat sau nu de 0x, 0X
%c orice caracter; nu sare peste spații (doar " %c")
%s șir de caractere, până la primul spațiu alb. Se
adaugă '\0'.
%e, %E, %f, %F, %g, %G, %a, %A real (posibil cu exponent)
%p pointer, în formatul tipărit de printf
%ld, %li numere întregi lungi
%lf numere reale în precizie dublă (double)
%Lf numere reale de tip long double
%[…] şir de caractere din mulţimea indicată între
paranteze
%[^…] șir de caractere exceptând mulțimea indicată între
paranteze
%% caracterul procent
C++ Citire cu scanf()
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int n,a,b;
scanf("%d", &n); // citeste un intreg in variabila n
scanf("%d%d", &a, &b); // citeste doi intregi in a și b
float rad;
scanf("%f", &rad); // citeste un numar real in rad
char c;
scanf("%c", &c); // citeste un caracter in c
int anInt;
float aFloat;
double aDouble;
printf("Introduceti un int: "); // Mesaj afisat
scanf("%d", &anInt); // citeşte un întreg în variabila anInt
printf("Valoarea introdusa este %d.\n", anInt);
printf("Introduceti un float: "); // Mesaj afisat
scanf("%f", &aFloat); // citeşte un float în variabila aFloat
printf("Valoarea introdusa este %f.\n", aFloat);
printf("Introduceti un double: "); // Mesaj afisat
scanf("%lf", &aDouble); // citeşte un întreg în variabila aDouble
printf("Valoarea introdusa este %lf.\n", aDouble);
return 0;
}
C++
C++