ДИНАМИЧКА АЛОКАЦИЈА МЕМОРИЈЕ:

1. Направити програм који за унети низ (са тастатуре) рачуна збир тих елемената, при чему се прво уноси
број елемената у низу, а затим се уносе ти елементи.

#include <stdio.h>
#include<stdlib.h>

void main() {
int *pa, n, i, s;

// duzina niza
printf("Duzina niza : ");
scanf("%d", &n);

if (n < 1)
exit(1);

//alociraj memoriju za niz

pa = (int *)malloc(n *sizeof(int));

/* Kad god se vrsi alokacija memorije mora se

proveriti da li je alokacija uspesno izvrsena!!! */
if (pa == NULL){
printf("Nema slobodne memorije\n");
exit(1);
}

printf("unesi elemente niza\n");

//unesi niz
for(i=0; i<n; i++)
scanf("%d", &pa[i]);

//izracunaj zbir niza

for(s=i=0; i<n; i++)
s+=pa[i];

printf("suma=%d\n", s);

// oslobodi memoriju alociranu za niz

free(pa);

2. Направити програм који унети низ (са тастатуре) исписује у обрнутом поретку, при чему се прво уноси
број елемената (који није унапред познат нити ограничен) у низу, а затим се уносе елементи.

#include <stdio.h>
#include <stdlib.h>

void main() {
int n;
int i;
int *a;
 printf("Unesi broj clanova niza : ");
scanf("%d", &n);
/* Kao da smo mogli da deklarisemo
int a[n];
Alocira se n mesta za podatke tipa int.
Funkcija malloc vraca vrednost tipa void*
tako da vrsimo kastovanje.
*/
a = (int*)malloc(n*sizeof(int));

/* Kad god se vrsi alokacija memorije mora se

proveriti da li je alokacija uspesno izvrsena!!! */
if (a == NULL){
printf("Nema slobodne memorije\n");
exit(1);
}

/* Od ovog trenutka a koristimo kao obican niz */

for (i = 0; i<n; i++)
scanf("%d",&a[i]);

/* Stampamo niz u obrnutom redosledu */

for(i = n-1; i>=0; i--)
printf("%d",a[i]);

/* Oslobadjamo memoriju*/
free(a);
}

3. Програм демонстрира да функција сalloc иницијализује садржај меморије на 0, док функција malloc не.

#include <stdio.h>
#include <stdlib.h>
void main(){
int *m, *c, i, n;
printf("Unesi broj clanova niza : ");
scanf("%d", &n);

/* Niz m NE MORA garantovano da ima sve nule */

m = (int*) malloc(n*sizeof(int));

if (m == NULL) {
printf("Greska prilikom alokacije memorije!\n");
exit(1);
}

/* Niz c MORA garantovano da ima sve nule */

c = (int*) calloc(n, sizeof(int));

if (c == NULL) {
printf("Greska prilikom alokacije memorije!\n");
free(m);
exit(1);
}

/*Odstampace se sadrzaj neinicijalizovane memorije*/

for (i = 0; i<n; i++)
printf("m[%d] = %d\n", i, m[i]);

/*Odstampace se nule*/
 for (i = 0; i<n; i++)
printf("c[%d] = %d\n", i, c[i]);

/* Oslobadja se rezervisana memorija. */

free(m);
free(c);
}

4. Програм демонстрира креирање матрица помоћу динамичке алокације меморије.

#include <stdio.h>
#include <stdlib.h>

int main(){

//definisemo pokazivac na pokazivac na int

int **p;
// Ovaj pokazivac ce cuvati adresu prvog u nizu dinamicki alociranih pokazivaca na int-ove.

int m, n;
int i, j;

printf("Uneti broj vrsta matrice: ");

scanf("%d", &m);

printf("Unesite broj kolona matrice: ");

scanf("%d", &n);

/* Alociramo m pokazivaca na vrste matrice

Dinamicki alociramo niz od m pokazivaca na int-ove, i adresu prvog u
nizu smestamo u promenljivu p.
Ovi pokazivaci sluze da pokazuju na prve elemente nizova int-ova koji
predstavljaju dinamicki alocirane vrste.
*/

if((p = (int**)malloc(sizeof(int*) * m)) == NULL){

fprintf(stderr, "malloc() greska\n");
exit(1);
}

/* Alociramo m vrsta od po n int-ova

Svaku vrstu alociramo posebnim malloc-om, i povratnu adresu smestamo u i-ti
pokazivac u malopre alociranom nizu pokazivaca.
*/

for(i = 0; i < m; i++)

if((p[i] = (int*)malloc(sizeof(int) * n)) == NULL){
fprintf(stderr, "malloc() greska\n");
exit(1);
}

/* Primetimo da nizovi int-ova koji se alociraju nisu morali biti jednakih dimenzija
(ne moraju svi biti duzine n, kao sto je ovde receno). Ovo moze da bude
korisno, ako znamo da ce u nekoj vrsti biti korisceno samo nekoliko prvih elemenata,
tada mozemo alocirati manje za tu vrstu, i tako ustedeti prostor.
*/

/* U toku rada se elementima ovako alocirane matrice pristupa sa p[i][j] { p[i]

je i-ti pokazivac u nizu, a kako on pokazuje na pocetni element u i-toj vrsti,
tada je p[i][j] upravo j-ti element u i-toj vrsti.
*/
 /* Postavljamo p[i][j] na vrednost abs(i - j) */
for(i = 0; i < m ; i++)
for(j = 0; j < n; j++)
p[i][j] = i - j >=0 ? i - j : j - i;

/* Ispis matrice */
for(i = 0; i < m ; i++){
for(j = 0; j < n; j++)
printf("%3d ", p[i][j]);
putchar('\n');
}

/* Dealokacija se sastoji u brisanju svih vrsta, nakon cega se obrise i niz pokazivaca
(dakle, dealokacija ide u suprotnom redosledu od redosleda alokacije):
*/

/* Oslobadjanje vrsta matrice */

for(i = 0; i < m; i++)
free(p[i]);

/* Oslobadjanje niza pokazivaca */

free(p);
return 0;
}