Operatorul sizeof

- cuvntul cheie sizeof

- operator funcional n timpul compilrii
- determin dimensiunea (n bii) a unei tip de
variabile
- se poate utiliza pentru toate tipurile de
variabile (clase, structuri, uniuni, iruri, etc)
- sintaxa:
sizeof(tip);

unde tip este tipul de dat solicitat (clase, structuri,

uniuni, iruri, etc)
- exemplu:
#include<iostream>
using namespace std;
int main()
{
cout <<"dim. pentru char : "<<sizeof(char);
cout <<"dim. pentru int : "<<sizeof(int);
cout <<"dim. pentru float : "<<sizeof(float);
cout <<"dim. pentru double : "<<sizeof(double);
return 0;
}
cnd codul este compilat i executat se va afia
urmtorul rezultat:

dim. pentru char : 1

dim. pentru int : 4
dim. pentru float : 4
dim. pentru double : 8
Funcia setprecision

- funcie de manipulare a preciziei cu care se

reprezint valoarea unei variabile de tip float /
double
- funcie inclus n clasa iomanip
- necesit directiva de preprocesare
#include<iomanip>

iomanip = input/output manipulation

float valoare = 1.23456789;
for (int i=0; i<9;i++)
{
cout<<setprecision(i)<<valoare;
}
cnd codul este compilat i executat se va afia
urmtorul rezultat:
valoare = 1
valoare = 1.2
valoare = 1.23
valoare = 1.234
valoare = 1.2345
valoare = 1.23456
valoare = 1.234567
valoare = 1.2345678
valoare = 1.23456789
Pointer
- variabil ce conine adresa unei alte variabile

- intete ctre o alt variabil

- variabila poate fi de orice tip (obiect, structur,

etc.)
sintaxa

tip * nume;
- tip poate fi int, char, float, string, array, object,
etc
- semnific faptul c pointerul nume va pstra
adresa de memorie pentru o variabil de acel
tip
- simbolul * este indicativul pentru pointer
- apar doi operatori specifici n lucrul cu pointerii
- & - operatorul de referin (de adresare)
- * - operatorul de dereferin (de indirectare)
- operatorul de referin & n faa unei variabile
indic extragerea adresei de memorie a acelei
variabile
- operatorul de dereferin * se plaseaz
ntotdeauna n faa unui pointer
int * p; // se declar un pointer p de tip ntreg
int a; // se declar o variabila a de tip ntreg
a=10; // se atribuie valoarea de 10 variabilei a
p = &a; //se atribuie pointerului p adresa de
memorie a variabilei a (op. de referin &)
*p = 5; //se pune n adresa de memorie din
pointerul p valoarea 5
cout<<a; // variabila a are valoarea 5
- prin intermediul pointerilor avem acces direct
la valorile variabilelor
- aceste valori pot fi modificate
- int * p; aceast instruciune definete un
pointer cu numele p
- n cod prin p se nelege variabila pointer (care
conine adresa de memorie), iar prin *p se
nelege coninutul aflat la adresa de memorie
- ntotdeauna tipul pointerului declarat trebuie
s coincid cu tipul variabilei a crei adres o
conine
int * p;
float a = 2.56;
p = &a; // instruciune invalid (tipul pointerului
nu coincide cu tipul variabilei)
float * p;
float a = 2.56;
p = &a;
cout<<valoarea lui a =<<a;
cout<<valoarea lui &a =<<&a;
cout<<valoarea lui p =<<p;
cout<<valoarea lui *p =<<*p;
dup compilare i executare se va afia

valoarea lui a = 2.56

valoarea lui &a = 0xbfc601ac
valoarea lui p = 0xbfc601ac
valoarea lui *p = 2.56
- orice pointer are o valoare, adic conine o
adres de memorie

- n C++ un pointer poate s ia orice valoare,

chiar dac adresa nu conine o variabil valid

- exist pointeri neiniializai, deci valoarea lor

poate s fie adresa de memorie a oricrei date

- utilizarea operatorului de dereferin (*) pentru

un pointer neiniializat duce la erori, utilizndu-
se valori aleatorii
Pointerul void
- void nseamn n C++ absena tipului
- pointerii void au ca valoare adresa unor
variabile fr tip
- au lungime i proprieti de dereferin
nedeterminate
- sunt instrumente foarte flexibile; pot avea
adrese de memorie pentru orice tip de variabil
(de la ntregi la float, la string, etc.)
- datele dintr-un astfel de pointer totui nu pot fi
accesate direct cu op. de dereferin (*); orice
valoare dintr-un pointer void (adresa) trebuie s
fie transferat ctre alt pointer de un tip care
poate fi accesat cu operatorul de dereferin
Pointerul NULL

- se atribuie pentru o variabil a crei adres nu

este cunoscut nc

- atribuirea se face n momentul declarrii

variabilei

- este o constant, cu valoare egal cu zero

#include <iostream>
using namespace std;
int main ()
{
int * p = NULL;
cout << "valoarea lui p este " << p;
return 0;
}
se va afia
valoarea lui p este 0
- adresa de memorie cu valoarea de 0 este
rezervat sistemului de operare
- atribuirea acestei valori pentru pointerul NULL
este o indicaie c pointerul nu va avea o
adres de memorie accesibil
- prin convenie dac un pointer are valoarea
zero el va avea o adres de memorie ctre
nimic
- pointer NULL pointer void
- toi pointerii neutilizai primesc o valoare nul
i n general se evit utilizarea unui asemenea
pointer
- instruciunea if(p) permite trierea pointerilor
neutilizai
Operaiuni asupra pointerilor
- un pointer conine o adres cu o valoare
numeric; se pot realiza operaiuni aritmetice
asemntoare celor aplicate unor valori
numerice
- pointerii suport patru operaiuni aritmetice:
++, --, +, -
- ex.: avem int * p; p = 1000;
- dac avem valori ntregi n 32-bii atunci
aplicnd operaiunea aritmetic:
p++;
noua valoare a pointerului va fi 1004
- valoarea de 1004 reprezint nou adres de
memorie n care se poate afla un numr ntreg
- dac avem
char * p; p = 1000;
noua valoare dup instruciunea p++; va fi
p = 1001, noua adres de memorie n care se
poate afla un caracter
- se utilizeaz pointeri n loc de iruri, pentru c
acetia pot fi incrementai / decrementai
(irurile sunt asociai cu pointeri constani i nu
au aceast proprietate)
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int sir[MAX] = {1, 2, 3};
int *p; // adresa irului se pune n pointerul p
p = sir;
for (int i = 0; i < MAX; i++)
{
cout << "adresa lui sir[" << i << "] = ";
cout << p;
 cout << "valoarea lui sir[" << i << "] = ";
cout << *p;
p++;
}
return 0;
}
dup compilare i executare se obine
adresa lui sir[0] = 0xbfa088b0
valoarea lui sir[0] = 1
adresa lui sir[1] = 0xbfa088b4
valoarea lui sir[1] = 2
adresa lui sir[2] = 0xbfa088b8
valoarea lui sir[2] = 3
aceiai discuie se refer la operaiunea de
decrementare a unui pointer
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int sir[MAX] = {1, 2, 3};
int *p;
p = &sir[MAX-1];
for (int i = MAX; i > 0; i--)
{
cout << "adresa lui sir[" << i << "] = ";
cout << p;
cout << "valoarea lui sir["<< i < "] = ";
 cout << *p;
p--;
}
return 0;
}
dup compilare i executare se obine
adresa lui sir[2] = 0xbfdb70f8
valoarea lui sir[2] = 3
adresa lui sir[1] = 0xbfdb70f4
valoarea lui sir[1] = 2
adresa lui sir[1] = 0xbfdb70f0
valoarea lui sir[1] = 1
Compararea pointerilor
- pointerii pot fi comparai prin intermediul
operatorilor relaionali
==, <, <=, >, >=
- dac doi pointeri p1 i p2 au ca valori
adresele de memorie ale unor variabile aflate
ntr-o relaie (de exemplu sunt membre ale unui
ir), atunci pointerii p1 i p2 pot fi comparai
- exemplu un program ce incrementeaz un
pointer att timp ct adresa de memorie
asociat este mai mic sau egal dect adresa
ultimului element din ir
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int sir[MAX] = {1, 2, 3};
int *p;
p = sir; //se plaseaz adresa primului
// element n pointer
int i = 0;
while ( p <= &sir[MAX - 1] )
{
cout << "adresa lui sir[" << i << "] = ";
cout << p;
cout << "valoarea lui sir[" << i << "] = ";
 cout << *p;
p++;
i++;
}
return 0;
}
dup compilare i executare se obine
adresa lui sir[0] = 0xbfce42d0
valoarea lui sir[0] = 1
adresa lui sir[1] = 0xbfce42d4
valoarea lui sir[1] = 2
adresa lui sir[2] = 0xbfce42d8
valoarea lui sir[2] = 3
Legtura dintre pointeri i iruri
- pointerii i irurile se pot nlocui unii cu ceilali
n multe cazuri
- un pointer care are adresa de memorie a
primului element dintr-un ir poate accesa acel
ir utiliznd fie aritmetica pointerilor fie
indexarea specific irurilor
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int sir[MAX] = {1, 2, 3};
int *p;
 p = sir; // se pune adresa irului n pointer
for (int i = 0; i < MAX; i++)
{
cout << "adresa lui sir[" << i << "] = ";
cout << p;
cout << "valoarea lui sir["<< i << "] = ";
cout << *p;
p++; // se trece la urmtoarea adres
}
return 0;
}
dup compilare i executare se obine
adresa lui sir[0] = 0xbfa088b0
valoarea lui sir[0] = 1
adresa lui sir[1] = 0xbfa088b4
valoarea lui sir[1] = 2
adresa lui sir[2] = 0xbfa088b8
valoarea lui sir[2] = 3
Pointerii i irurile nu se pot schimba n orice
situaie
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int sir[MAX] = {1, 2, 3};
for (int i = 0; i < MAX; i++)
{
*sir = i; // sintax corect
sir++; // sintax incorect
}
return 0;
}
- se poate aplica operatorul * la irul sir, dar
este interzis modificarea valorii adresei (prin
sir++)
- prin declararea unei variabile tip sir se
genereaz automat un pointer constant (a crei
valoare va fi mereu adresa de memorie a
primului element din ir)
- se poate modifica valoarea unui element al
irului prin operatorul * prin intermediul adresei
de memorie
*(sir + 2) = 10; - instruciune corect, se
modific valoarea celui de-al treilea element
(sir[2] = 10), dar adresa de memorie a irului
(sir) rmne neschimbat
iruri de pointeri
- se poate defini un ir de pointeri, fiecare
element al irului fiind un pointer care are ca
valoare o adres de memorie n care se
stocheaz variabile de un anume tip

int * p[3];

- se definete un ir de pointeri cu numele p,

care are trei elemente iar aceste elemente sunt
pointeri care au ca valori adrese de memorie
pentru variabile de tip ntreg
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
int sir[MAX] = {1, 2, 3};
int *p[MAX];
for (int i = 0; i < MAX; i++)
{
p[i] = &sir[i]; // se atribuie ca valoare
// adresa irului de ntregi
}
for (int i = 0; i < MAX; i++)
{
cout << "valoarea lui sir[" << i << "] = ";
cout << *p[i];
}
return 0;
}
- cnd codul este compilat i executat se obine
rezultatul:
valoarea lui sir[0] = 1
valoarea lui sir[1] = 2
valoarea lui sir[2] = 3
Pointer la pointer
- este o form de indirectare multipl sau un
lan de pointeri
- primul pointer conine adresa celui de-al
doilea pointer, iar acesta conine adresa de
memorie a variabilei
pointer pointer variabil

adres adres valoare

- declararea acestuia
int **p;
#include <iostream>
using namespace std;
int main ()
{
int a;
int *p;
int **pp;
a = 10;
p = &a;
pp = &p;
cout << "valoarea lui a :" << a;
cout << "valoarea lui *p :" << *p;
cout << "valoarea la **pp:"<<**pp;
return 0;
}
cnd codul este compilat i executat se obine
rezultatul:
valoarea lui a = 10
valoarea lui *p = 10
valoarea la **pp = 10
Transmiterea unui pointer ctre o funcie
- se declar parametrul funciei ca fiind unul de
tip pointer
- se poate modifica valoarea unei variabile
transmise printr-un pointer de ctre o funcie
#include <iostream>
#include <ctime>
using namespace std;
void preiaSecunde(unsigned long int *p);
int main ()
{
unsigned long int secunde;
preiaSecunde(&secunde);
 cout << "numrul de secunde:" << secunde;
return 0;
}
void preiaSecunde(unsigned long int *p)
{
*p = time( NULL );
return;
}
cnd codul este compilat i executat se obine
rezultatul:
numrul de secunde :1294450468
- o funcie care accept un pointer ca argument
poate accepta i un ir ca argument
#include <iostream>
using namespace std;
double preiaMedia(int *p, int marime);
int main ()
{
int sir[5] = {1, 2, 3, 4, 5};
double media;
media = preiaMedia (sir, 5 ) ;
cout << "valoarea medie este: "<<media;
return 0;
}
double preiaMedia(int *p, int marime)
{
int i, suma = 0;
double media;
for (i = 0; i < marime; i++)
{
suma += p[i];
}
media = double(suma)/marime;
return media;
}
cnd codul este compilat i executat se
obine rezultatul:
valoarea medie este : 3
- un nume de ir reprezint un pointer constant
care are ca adres primul element al irului
double sir[10];
sir este considerat un pointer la adresa &sir[0],
care este adresa primului element din irul sir
double *p;
double sir[10];
p = sir;
- este corect utilizarea numelui irului n loc de
pointer constant i viceversa
- este corect urmtoarea echivalare
*(sir + 4) = sir[4]
- elementele irului pot fi accesate cu ajutorul
pointerilor, folosind *p, *(p+1), *(p+2) etc.
#include <iostream>
using namespace std;
int main ()
{
int sir[5] = {1, 2, 3, 4, 5};
int *p;
p = sir;
cout << "valorile irului utiliznd pointeri ";
for ( int i = 0; i < 5; i++ )
{
cout << "*(p + " << i << ") : ";
cout << *(p + i);
}
 cout << "valorile irului utiliznd adresa";
for ( int i = 0; i < 5; i++ )
{
cout << "*(sir + " << i << ") : ";
cout << *(sir + i) <<;
}
return 0;
}
cnd codul este compilat i executat se obine
rezultatul:
valorile irului utiliznd pointeri
*(p + 0) : 1
*(p + 1) : 2
*(p + 2) : 3
*(p + 4) : 5
valorile irului utiliznd adresa
*(sir + 0) : 1
*(sir + 1) : 2
*(sir + 2) : 3
*(sir + 3) : 4
*(sir + 4) : 5
- nu se poate transmite ca argument unei funcii
un ntreg ir
- se poate transmite un pointer la un ir
specificndu-se numele irului fr vreun index
- pentru a transmite ca argument unei funcii
un ir unidimensional exist trei variante
acceptabile
ca un pointer
void Functie (int *argument)
{
...
}
ca un ir cu dimensiunea menionat

void Functie (int argument[10])

{
...
}

ca un ir fr dimensiune
void Functie (int argument[ ])
{
...
}
#include <iostream>
using namespace std;
double preiaMedia(int a[ ], int marime);
int main ()
{
int sir[5] = {1, 2, 3, 4, 5};
double media;
media = preiaMedia (sir, 5 ) ;
cout << "valoarea medie este: "<<media;
return 0;
}
double preiaMedia(int a[ ], int marime)
{
int i, suma = 0;
double media;
for (i = 0; i < marime; i++)
{
suma += a[i];
}
media = double(suma)/marime;
return media;
}
cnd codul este compilat i executat se
obine rezultatul:
valoarea medie este : 3
Returnarea unui ir de ctre o funcie
- nu este permis returnarea unui ntreg ir de
ctre o funcie
- se poate returna un pointer ctre un ir prin
specificarea numelui irului fr niciun index
- pentru returnarea unui ir unidimensional,
trebuie s se declare c funcia returneaz un
pointer
- analog cu returnarea irului de ctre o funcie
se poate returna i un pointer
int * Functie ()
{ ...
}
- nu este permis returnarea adresei ctre o
variabil local n afara funciei
- variabila local trebuie declarat ca fiind static
#include <iostream>
#include <ctime>
using namespace std;
int * genAleatoare( )
{
static int r[5];
srand( (unsigned)time( NULL ) );
for (int i = 0; i < 5; i++)
{
r[i] = rand();
cout << r[i];
}
 return r;
}
int main ()
{
int *p;
p = genAleatoare();
for ( int i = 0; i < 5; i++ )
{
cout << "*(p + " << i << ") : ";
cout << *(p + i) << ;
}
return 0;
}
cnd codul este compilat i executat se obine
rezultatul:

624723190
1468735695
807113585
976495677
613357504
*(p + 0) : 624723190
*(p + 1) : 1468735695
*(p + 2) : 807113585
*(p + 3) : 976495677
*(p + 4) : 613357504
Referine
- o variabil referin este un alias, adic un alt
nume pentru o variabil deja existent
- odat ce o referin este iniializat cu o
variabil, atunci se poate utiliza fie numele
variabilei fie numele referinei

Exist trei diferene ntre referine i pointeri

- nu exist referine de tip NULL. ntotdeauna o
referin este legat de o adres de memorie
real
- dac o referin este iniializat la un obiect
dat, ea nu poate fi modificat pentru a se referi
la un alt obiect. Pointerii pot conine adresele
unui alt obiect n orice moment
- o referin trebuie s fie iniializat n
momentul n care a fost creat. Un pointer
poate fi iniializat n orice moment
Un nume de variabil este o etichet ataat
adresei de memorie a variabilei.
O referin este o a doua etichet ataat
aceleiai adrese de memorie
Coninutul variabilei poate fi accesat fie prin
nume fie prin referin
Declararea unei variabile ntregi
int a = 10;
Declararea unei referine la acea variabil
int& b = a;

b este o referin de tip int iniializat la

valoarea variabilei a
#include <iostream>
using namespace std;
int main ()
{
int a;
double b;
int& x = a;
double& y = b;
a = 10;
cout << "valoarea lui a : " << a;
cout << "valoarea referinei lui a : " << x;
b = 20.17;
cout << "valoarea lui b : " << b;
cout << "valoarea referinei lui b : " << y;
return 0;
}
cnd codul este compilat i executat se obine
rezultatul:
valoarea lui a : 10
valoarea referinei lui a : 10
valoarea lui b : 20.17
valoarea referinei lui b : 20.17

- referinele sunt utilizate n special la

transmiterea argumentelor ctre funcii i la
manipularea valorilor ntoarse de funcii
- sunt mai utile dect aplicarea variabilelor
obinuite
Referine ca argumente pentru funcii
#include <iostream>
using namespace std;
void swap(int& x, int& y);
int main ()
{
int a = 10;
int b = 20;
cout << "nainte de fct. swap, valoarea lui a :"
<< a;
cout << "nainte de fct. swap, valoarea lui b :"
<< b;
swap(a, b);
cout << "dup apelarea fct. swap, valoarea
lui a :" << a;
 cout << "dup apelarea fct. Valoarea lui
b :" << b;
return 0;
}
void swap(int& x, int& y)
{
int temp;
temp = x;
x = y;
y = temp;
return;
}
cnd codul este compilat i executat se obine
rezultatul:
nainte de fct. swap, valoarea lui a : 10
nainte de fct. swap, valoarea lui b : 20
dup apelarea fct. swap, valoarea lui a : 20
dup apelarea fct. swap, valoarea lui b : 10
- un program poate fi mai uor de citit/ntreinut
prin utilizarea referinelor dect prin utilizarea
pointerilor
- o funcie poate returna o referin n acelai
mod n care transmite un pointer
- cnd o funcie returneaz o referin, ea
returneaz un pointer implicit la valoarea
ntoars (adic un pointer care are ca valoare
adresa de memorie a variabilei ntoarse)
- astfel o funcie poate fi utilizat ntr-o
instruciune de atribuire
#include <iostream>
#include <ctime>
using namespace std;
double vals[ ] = {10.1, 10.2, 10.3, 10.4, 10.5};
double& setValues( int i )
{
return vals[i]; // ret. o referin la elementul I
}
int main ()
{
cout << "valoarea naintea schimbrii";
for ( int i = 0; i < 5; i++ )
{
cout << "vals[" << i << "] = ";
cout << vals[i];
}
 setValues(1) = 20.2;
setValues(3) = 20.4;
cout << "valoarea dup schimbare;
for ( int i = 0; i < 5; i++ )
{
cout << "vals[" << i << "] = ";
cout << vals[i];
}
return 0;
}
cnd codul este compilat i executat se obine
rezultatul:
valoarea naintea schimbrii
vals[0] = 10.1
vals[1] = 10.2
vals[2] = 10.3
vals[3] = 10.4
vals[4] = 10.5
valoarea dup schimbare
vals[0] = 10.1
vals[1] = 20.2
vals[2] = 10.3
vals[3] = 20.4
vals[4] = 10.5
Alocarea dinamic a memoriei
ntr-un program memoria alocat are dou
componente
- memoria stiv, care este utilizat de toate
variabilele declarate n funciile programului
- memoria heap (morman), care este memoria
neutilizat de cod i care poate fi folosit cnd
ruleaz un program

cnd este nevoie de memorie ntr-un program

se poate aloca dinamic memorie de tip heap
Operatorul new creaz memorie, iar operatorul
delete o elimin dup utilizarea acesteia
sintaxa generic pentru alocarea dinamic a
memoriei pentru orice tip de variabil este

new tip_data;

la tip_data poate fi orice tip de variabil

incorporat sau definit de utilizator
double *p = NULL;
p = new double;
- se genereaz un pointer p de tip double
- se solicit ca memoria s fie alocat n
momentul rulrii programului
- se aloc pointerului valoarea NULL pentru a
comunica c nu se utilizeaz memorie
- memoria trebuie alocat cu succes, prin
urmare se utilizeaz teste
- n cazul pointerilor
double* p = NULL;
if( !(p = new double ))
{
cout << "eroare: memorie insuficient.";
exit(1);
}
- dup finalizarea unui proces, memoria se
poate elibera prin comanda
delete p;
exemplu de aplicare a acestor operatori

#include <iostream>
using namespace std;
int main ()
{
double* p = NULL;
p = new double;
 *p = 29494.99;
cout << "valoarea lui p : " << *p;
delete p;
return 0;
}
dup compilare i rulare rezultatul este
valoarea lui p : 29494.99
- memoria se poate aloca dinamic i pentru
iruri
- pentru un ir de 10 elemente (caractere)
char* p = NULL;
p = new char[10];
- pentru a elibera memoria
delete [ ] p;
- pentru un ir bidimensional
double** p = NULL;
p = new double [3][4];
- pentru eliberarea memoriei
delete [ ] p;
Generarea numerelor aleatoare
- numere aleatoare reale
-numere pseudo-aleatoare
- se utilizeaz biblioteca #include<cstdlib> care
conine funcia rand()
-se pot genera numere pseudo-aleatoare ntre
0 i 32.767 (numere ntregi). Valoarea depinde
de bibliotec, dar este cel puin 32.727.
-valoarea real pentru fiecare compilator este
dat de RAND_MAX. Reprezint valoarea
maxim returnat de funcia rand().
-se verific valoarea acestuia prin comanda
cout<<RAND_MAX =<<RAND_MAX;

-se utilizeaz un domeniu standard de generare

de numere aleatoare.

-se utilizeaz operatorul % (modulo) pentru a

iniializa acest domeniu
Ex:
#include<iostream>
#include< cstdlib >
using namespace std;
int main ()
{
int r, t;
r=(rand()%100) +1; //numere pseudo-
aleatoare ntre 1 i 100
t = (rand()%6)+1; //numere pseudo- aleatoare
ntre 1 i 6
...;
return 0;
}
- aceste numere se repet mereu la fiecare
rulare a programului
-se utilizeaz numrul RAND_MAX care este
constant pentru compilatorul dat
-numrul returnat de funcia rand() este
dependent de valoarea iniial numit seed,
care rmne aceiai pentru fiecare rulare a
programului.
-secvena de numere aleatoare generate va fi
la fel pentru fiecare rulare a programului.
- o variant mai bun - utilizarea funciei
srand(seed) unde seed este un numr ntreg
foarte mare ales de utilizator

-funcia srand(n) genereaz (modific) de

fiecare dat numrul RAND_MAX care este
utilizat de rand() pentru generarea numerelor
pseudo-aleatorii.
srand (5463546);
r = (rand()%100 +1);
- i aceste numere se pot repeta
-numere complet aleatoare se pot obine
realiznd o legtur ntre ceasul intern al
procesorului i generatorul de numere
aleatoare
#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
int main ()
{
srand((int) time(0)); // srand ((int) time(NULL));
int r,t;
r = (rand()%100) +1;
t= (rand()%6)+1;
return 0;
- funcia time() aparine clasei ctime
- este apelat de funcia srand(), utilizeaz
ceasul intern al procesorului
- transform n secunde timpul scurs de la ora 0
(1 ianuarie 1970)
- transmite valoarea ntreag ctre srand(),
care genereaz RAND_MAX complet aleatoriu
care este transferat catre rand()