Vector alocat dinamic
Citiți n (1 ≤ n ≤ 10 000), alocați cu malloc un vector de n întregi, citiți valorile în el și afișați suma lor. La final eliberați memoria.
3
1 2 36Până acum, dimensiunea datelor era fixată la scrierea programului. Alocarea dinamică permite stabilirea ei în timpul execuției, cerând memorie exact atunci când este nevoie și eliberând-o când nu mai este utilă.
malloc, calloc, realloc și freenew și delete din C++La declararea unui tablou, dimensiunea trebuie să fie o constantă cunoscută la compilare. Aceasta duce la două probleme opuse:
| Situație | Consecință |
|---|---|
| Se declară un tablou mult mai mare decât e nevoie | memorie ocupată inutil |
| Numărul real de elemente depășește dimensiunea declarată | trebuie modificat codul și recompilat |
Memoria unui program este împărțită în zone specializate, adresate prin regiștri de segment (CS, DS, ES, SS):
| Zonă | Ce conține | Când se alocă | Când se eliberează |
|---|---|---|---|
| Segment de cod (CS) | instrucțiunile executabile | la încărcarea programului | la terminare |
| Segment de date (DS) | variabile globale și statice | la încărcare | la terminare |
| Stivă (SS) | variabile locale, parametri, adrese de revenire | la intrarea în bloc | automat, la ieșire |
| Heap | date alocate dinamic | la apelul malloc / new | manual, prin free / delete |
| Funcție | Prototip | Efect |
|---|---|---|
malloc | void* malloc(size_t n) | alocă n octeți, neinițializați |
calloc | void* calloc(size_t nr, size_t dim) | alocă nr×dim octeți, puși pe zero |
realloc | void* realloc(void* p, size_t n) | redimensionează o zonă deja alocată |
free | void free(void* p) | eliberează zona indicată |
int *v = (int *)malloc(n * sizeof(int)); // 1. alocare
if (v == NULL) { // 2. VERIFICARE obligatorie
printf("Memorie insuficienta!\n");
return 1;
}
/* ... utilizare ... */ // 3. folosire
free(v); // 4. eliberare
v = NULL; // 5. evita folosirea accidentala
malloc returnează NULL. Folosirea rezultatului fără verificare duce la
dereferențierea unui pointer nul și oprirea brutală a programului.v = realloc(v, ...) direct: dacă alocarea eșuează, se returnează NULL,
iar adresa veche se pierde definitiv. Folosiți o variabilă temporară.Selectați ținta pentru a vedea diferența dintre un pointer valid, unul care indică spre altă zonă și unul pus pe NULL după eliberare.
free repetat pe aceeași adresă produce
coruperea structurilor interne ale alocatorului. Atribuirea v = NULL transformă o eroare
subtilă într-una imediat vizibilă.| Operație | C | C++ |
|---|---|---|
| Alocare pentru o valoare | p = (int*)malloc(sizeof(int)); | p = new int; |
| Alocare cu inițializare | alocare + atribuire separată | p = new int(42); |
| Alocare pentru un tablou | v = (int*)malloc(n*sizeof(int)); | v = new int[n]; |
| Eliberare valoare | free(p); | delete p; |
| Eliberare tablou | free(v); | delete[] v; |
malloc se
eliberează cu free; cea obținută cu new, cu delete.
Pentru tablouri se folosește obligatoriu delete[] - altfel destructorii elementelor
nu se apelează.| Eroare | Cauză | Efect |
|---|---|---|
| Memory leak | lipsa free | consum crescător de memorie; programele lungi ajung să epuizeze sistemul |
| Double free | eliberare de două ori | corupere internă a alocatorului, oprire imprevizibilă |
| Use after free | acces după eliberare | date aleatoare sau blocare; vulnerabilitate de securitate |
| Buffer overflow | scriere peste dimensiunea alocată | suprascrierea structurilor vecine din heap |
| Alocare neverificată | lipsa testului == NULL | dereferențierea unui pointer nul |
malloc trebuie să aibă exact un
free corespunzător, iar fiecare new exact un delete.
Scrieți-le pereche, chiar în momentul alocării, ca să nu le uitați.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n;
printf("Cate elemente? ");
if (scanf("%d", &n) != 1 || n <= 0) {
printf("Valoare invalida\n");
return 1;
}
int *v = (int *)malloc(n * sizeof(int)); // alocare exacta
if (v == NULL) { // verificare obligatorie
printf("Alocare esuata!\n");
return 1;
}
for (int i = 0; i < n; i++) {
printf("v[%d] = ", i);
scanf("%d", &v[i]);
}
long suma = 0;
for (int i = 0; i < n; i++) suma += v[i];
printf("\nSuma = %ld, media = %.3f\n", suma, (double)suma / n);
free(v); // eliberare
v = NULL; // protectie impotriva folosirii accidentale
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int capacitate = 4, nr = 0;
int *v = (int *)malloc(capacitate * sizeof(int));
if (!v) return 1;
printf("Introduceti numere (0 = stop):\n");
int x;
while (scanf("%d", &x) == 1 && x != 0) {
if (nr == capacitate) { // s-a umplut: dublam capacitatea
capacitate *= 2;
int *temp = (int *)realloc(v, capacitate * sizeof(int));
if (temp == NULL) { // NU atribuim direct lui v!
printf("Redimensionare esuata\n");
free(v);
return 1;
}
v = temp;
printf(" [capacitate marita la %d]\n", capacitate);
}
v[nr++] = x;
}
printf("\nAti introdus %d valori: ", nr);
for (int i = 0; i < nr; i++) printf("%d ", v[i]);
printf("\n");
free(v);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int linii, coloane;
printf("Linii si coloane: ");
scanf("%d %d", &linii, &coloane);
// 1. tablou de pointeri catre linii
int **m = (int **)malloc(linii * sizeof(int *));
if (!m) return 1;
// 2. cate o linie pentru fiecare pointer
for (int i = 0; i < linii; i++) {
m[i] = (int *)malloc(coloane * sizeof(int));
if (!m[i]) { // eliberam ce am alocat deja
for (int k = 0; k < i; k++) free(m[k]);
free(m);
return 1;
}
}
for (int i = 0; i < linii; i++)
for (int j = 0; j < coloane; j++)
m[i][j] = (i + 1) * (j + 1); // tabla inmultirii
for (int i = 0; i < linii; i++) {
for (int j = 0; j < coloane; j++) printf("%5d", m[i][j]);
printf("\n");
}
// eliberare in ordine INVERSA alocarii
for (int i = 0; i < linii; i++) free(m[i]);
free(m);
return 0;
}
#include <iostream>
using namespace std;
int main()
{
int n;
cout << "Cate elemente? ";
cin >> n;
int *v = new int[n]; // fara conversie, fara sizeof
for (int i = 0; i < n; i++) v[i] = (i + 1) * (i + 1);
for (int i = 0; i < n; i++) cout << v[i] << " ";
cout << endl;
delete[] v; // OBLIGATORIU cu paranteze patrate
// alocare cu initializare
int *p = new int(42);
cout << "*p = " << *p << endl;
delete p; // fara paranteze, pentru o singura valoare
return 0;
}
În modul Pas cu pas, panoul din dreapta are o secțiune heap: acolo apar blocurile alocate cu malloc și se vede exact când devin „eliberate”.
free(v); și rulați din nou: programul funcționează la fel. Tocmai de aceea scurgerile de memorie sunt periculoase - nu se văd. Acum mutați free(v); înainte de bucla de afișare și veți primi o eroare clară.Aici scrieți voi codul. Butonul ✓ Verifică rulează programul pe mai multe seturi de date și vă arată imediat unde diferă rezultatul. La final trimiteți traseul ales, iar profesorul îl notează automat.
Fiecare exercițiu are programul deja început, iar comentariile vă spun ce mai trebuie adăugat. Scrieți codul, apăsați ✓ Verifică și citiți ce spune fiecare test picat. Dacă v-ați blocat, deschideți câte un indiciu. Puteți afișa și mesaje pentru utilizator (de tipul Introduceti n:), testul se uită la ce afișați la final.
Citiți n (1 ≤ n ≤ 10 000), alocați cu malloc un vector de n întregi, citiți valorile în el și afișați suma lor. La final eliberați memoria.
3
1 2 36Citiți n și alocați cu calloc un vector de n întregi (toate devin 0). Apoi citiți k perechi poziție valoare și scrieți valorile la pozițiile date. Afișați vectorul.
5
2
1 7
3 90 7 0 9 0Citiți un cuvânt. Alocați dinamic exact câți octeți îi trebuie unei copii (inclusiv '\0'), copiați cuvântul cu strcpy și afișați copia și numărul de octeți alocați.
meremere 5În C++, citiți n, alocați cu new un vector de n valori reale, citiți-le și afișați media cu două zecimale. Eliberați memoria cu delete[].
3
1.5 2.5 3.52.50Citiți numere întregi până la valoarea 0 (care nu face parte din date). Păstrați-le într-un vector alocat dinamic care își dublează capacitatea cu realloc când se umple. Afișați câte numere sunt, apoi numerele în ordine inversă.
5 8 2 03
2 8 5Problemele pornesc de la un main gol. Formatul ieșirii trebuie respectat exact (spațiile și rândurile noi nu contează, dacă enunțul nu spune altfel), deci nu afișați mesaje pentru utilizator. Testele vizibile acoperă doar cazurile simple; la notare se rulează și teste ascunse, alese să prindă cazurile limită.
Citiți n m (1 ≤ n, m ≤ 100) și o matrice n × m de întregi, alocată dinamic ca vector de pointeri către rânduri. Afișați suma fiecărei coloane, pe un rând. Eliberați corect memoria.
2 3
1 2 3
4 5 65 7 9Citiți n (1 ≤ n ≤ 100) și apoi n cuvinte (fiecare cel mult 50 de litere). Construiți un șir alocat dinamic, de lungime exactă, care conține cuvintele unite prin -. Afișați șirul și lungimea lui.
3
unu doi treiunu-doi-trei 12Citiți un vector sortat crescător de n întregi, apoi altul de m întregi (pe fiecare rând întâi lungimea). Alocați dinamic un vector de n + m elemente, interclasați-i în el și afișați rezultatul.
3 1 4 9
2 2 51 2 4 5 9Citiți n (1 ≤ n ≤ 30). Alocați dinamic un „triunghi”: rândul i are exact i + 1 elemente. Completați triunghiul lui Pascal și afișați primele n rânduri.
41
1 1
1 2 1
1 3 3 1malloc pentru o cerere absurd de mare (de exemplu 10¹⁰ octeți).malloc și cu calloc, imediat după alocare.realloc când se umple.free într-o buclă și observați creșterea memoriei în Task Manager.new și delete[].malloc este egal cu numărul de apeluri free la terminarea programului.