Alokasi Memori

Yuliana Setiowati
Alokasi Memori
 Menyediakan fasilitas untuk membuat ukuran
buffer dan array secara dinamik.
• Dinamik artinya bahwa ruang dalam memori
akan dialokasikan ketika program dieksekusi
(run time)
• Fasilitas ini memungkinkan user untuk
membuat tipe data dan struktur dengan
ukuran dan panjang berapapun yang
disesuaikan dengan kebutuhan di dalam
program.
sizeof()
• Untuk mendapatkan ukuran dari berbagai
tipe data, variabel ataupun struktur.
•Return value : ukuran dari obyek yang
bersangkutan dalam byte.
•Parameter dari sizeof() : sebuah obyek
atau sebuah tipe data
main() typedef struct employee_st {
{ char name[40];
int myInt; int id;
Employee john; } Employee;
printf("Size of int is %d\n",sizeof(myInt));
printf("Size of int is %d\n",sizeof(int));
printf("Size of Employee is %d\n",sizeof(Employee));
printf("Size of john is %d\n",sizeof(john));
printf("Size of char is %d\n",sizeof(char));
printf("Size of short is %d\n",sizeof(short));
printf("Size of int is %d\n",sizeof(int));
printf("Size of long is %d\n",sizeof(long));
printf("Size of float is %d\n",sizeof(float));
printf("Size of double is %d\n",sizeof(double));
return 0;
}
Hasil Program
 Fungsi malloc()
• Untuk mengalokasikan memori
• Bentuk prototypenya adalah
void *malloc(int jml_byte);

Return value :
• Berhasil : sebuah pointer yang tak bertipe (pointer to void)
yang menunjuk ke buffer yang dialokasikan

• Gagal : return value berupa sebuah pointer NULL.

• Pointer tersebut haruslah dikonversi kepada tipe yang sesuai
(dengan menggunakan type cast) agar bisa mengakses data
yang disimpan dalam buffer.
main()
{
char s1[] = "This is a sentence";
char *pblok;
pblok = (char *) malloc(strlen(s1) + 1);
if (pblok == NULL) printf("Error on malloc\n");
else {
strcpy(pblok,s1);
printf("s1: %s\n", s1);
printf("pblok: %s\n", pblok);
return 0;
}
}
malloc( )
int *p;
double *q;
Date *r;
p = (int*) malloc(sizeof(int));
q = (double*) malloc(sizeof(double));
r = (Date*) malloc(sizeof(Date));

*p *r
p 3 r 2 2 2002
*q
q 3.14
malloc( ), closer look
sizeof(int) = the
number of bytes
int *p; occupied by an int

p = (int*) malloc(sizeof(int));
Malloc mengalokasikan
storage dengan ukuran 4
byte (int)

p = (int*) malloc(…)
Pointer tersebut haruslah
dikonversi kepada tipe yang sesuai
malloc( )
#include <stdlib.h>
int main () { p ?
int *p; int a=2; *p
 p = (int*) malloc(sizeof(int));  p
*p = 4;
*p += a;
… Menghapus sel yang
free(p); ditunjuk p
p = NULL;
}
 Fungsi free()
• Jika bekerja dengan menggunakan memori yang
dialokasikan secara dinamis, maka memori harus dibebaskan
kembali setelah selesai digunakan untuk dikembalikan
kepada sistem.
• Setelah suatu ruang memori dibebaskan, ruang tersebut
bisa dipakai lagi untuk alokasi variabel dinamis lainnya.
• Bentuk deklarasi
void free(void *pblok);
dengan pblok adalah pointer yang menunjuk ke memori yang
akan dibebaskan.
• Dalam hal ini, pointer pblok tidak perlu di-cast kembali ke
void terlebih dahulu. Compiler otomatis telah menangani
proses ini.
Fungsi free()
main()
{
char *pblok;
pblok = (char *) malloc(500 * sizeof(char));
if (pblok == NULL)
puts("Error on malloc");
else { puts("OK, alokasi memori sudah dilakukan");
puts("------");
free(pblok);
puts("Blok memori telah dibebaskan kembali");
}
}
free( )
#include <stdlib.h>
int main () { p ?
int *p; int a=2; *p
p = (int*) malloc(sizeof(int)); p
*p = 4;
*p += a;  p ?
… Menghapus sel yang
 free(p); ditunjuk p
p = NULL;
} Pada saat variabel dinamik tidak
digunakan lagi kita perlu
membebaskannya. Kompiler tidak
mendealokasi storage space secara
otomatis
NULL
#include <stdlib.h>
int main () { p ?
int *p; int a=2; *p
p = (int*) malloc(sizeof(int)); p
*p = 4;
*p += a; p ?
…
free(p);  p
 p = NULL;
}
#include <stdlib.h>
#include <stdlib.h>
int main () {
int *p; int a=2;
p = (int*) malloc(sizeof(int));
*p = 4;
*p += a;
…
free(p); Menggunakan fungsi malloc(),
p = NULL; free() dan NULL harus
} mengincludekan stdlib.h.
*q = *p
int *p, *q; *p
p = (int*)malloc(sizeof(int)); p 3
q = (int*)malloc(sizeof(int));
*p = 3; *q
q 3
*q = *p;
q=p
*p
p 3

int *p, *q; *q

p = (int*) malloc(sizeof(int)); q
q = (int*) malloc(sizeof(int));
*p = 3; *q
*p
q = p; p 3

q
Example (A)
#include <stdlib.h> p *p
int main () { 3 *r
r
int *p, *q;
int *r; q 6 *q
p = (int*) malloc(sizeof(int));
r = p; (B) p
q = (int*) malloc(sizeof(int)); ?
r
*p = 3;
*q = *p + *r; (A) q 6 *q
free(r); (B)
r = NULL; (C) (C) p
} ?
r
q 6 *q
Latihan
#include <stdlib.h>
int main () {
int *p, *q;
int *r; int *s;
p = (int*) malloc(sizeof(int));
r = p; *p = 5;
p = (int*) malloc(sizeof(int));
q = p; s = r; *q = *s + 1;
*r = *p * 2;
(A)
free(r); r = NULL;
free(q); q = NULL;
(B)
}
Memory Leak
#include <stdlib.h> (A) p 3 *p
int main () {
int *p, *q;
p = (int*) malloc(sizeof(int));
*p = 1+2; (A) (B) p 3
q = p; or free(p);
8 *p
p = (int*) malloc(sizeof(int));
scanf("%d", p); (B)
free(p); p = NULL; (C) (C) p 3
}

Pada saat p=NULL; maka *p

tidak dapat diakses lagi
Pointer yang tidak valid
#include <stdlib.h> (A)
int main () { p *p
int *p, *q; q 3 *q
p = (int*) malloc(sizeof(int));
q = p;
*q = 3; (A)
free(q);
q = NULL; (B) (B) p
printf("%d %d", *p, *q); q ?
*p = 999;
*q = 999; 
}
Setelah free(q), sel *p (dan *q) tidak
ada. Oleh sebab itu kita tidak dapat
menggunakan *p atau *q.
Free sel yang tidak digunakan hanya
satu kali
#include <stdlib.h> (A)
p *p
int main () {
q 3 *q
int *p, *q;
p = (int*) malloc(sizeof(int));
q = p;
(B) p
*q = 3; (A)
free(q); q ?
q = NULL; (B)
free(p);  (C)
p = NULL; (C) p
} Free untuk tiap sel yang tidak q
digunakan hanya dilakukan
satu kali (Bukan free tiap
pointer satu kali)
Jangan Free() Variabel Static
#include <stdlib.h> (A)
p 3 *p
int main () {
int *p, *q; q 5 *q
int a = 5; a
p = (int*) malloc(sizeof(int));
(B) p
q = &a;
*p = 3; (A) q 5 *q
free(p); p = NULL; (B) a
free(q); 
q = NULL; (C) (C) p
} q 5
Kita hanya perlu membebaskan a
variabel dinamik. Bukan variabel
biasa. Ingat Free() untuk malloc()
saja.
 Fungsi realloc()
• Untuk mengalokasikan ulang memori yang dipesan
• Fungsi ini akan mengalokasikan kembali pointer yang
sebelumnya telah diatur untuk menunjuk sejumlah lokasi,
memberinya ukuran yang baru (bisa jadi lebih kecil atau lebih
besar).
• Bentuk deklarasi :
...
pblok = (char *) malloc(500 * sizeof(char));
...
pblok = realloc(pblok, 600 * sizeof(char));
 Fungsi realloc()
• fungsi ini memberikan return value berupa
pointer yang sama, meng-copy data lama ke
lokasi baru dan mengarahkan pointer ke sejumlah
lokasi baru tersebut
• membebaskan blok memori yang lama.
• Jika berhasil : melakukan relokasi baru.
• Jika tidak berhasil : return value berupa NULL.
• Cara terbaik adalah mengecek hasil realloc()
untuk memastikan hasilnya bukan NULL pointer,
sebelum kemudian menumpuki pointer lama
dengan return value dari realloc().