Alokasi Memori

Click to add Text

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()

typedefstructemployee_st{

charname[40];

intmyInt;

intid;

Employeejohn;

}Employee;

printf("Sizeofintis%d\n",sizeof(myInt));
printf("Sizeofintis%d\n",sizeof(int));
printf("SizeofEmployeeis%d\n",sizeof(Employee));
printf("Sizeofjohnis%d\n",sizeof(john));
printf("Sizeofcharis%d\n",sizeof(char));
printf("Sizeofshortis%d\n",sizeof(short));
printf("Sizeofintis%d\n",sizeof(int));
printf("Sizeoflongis%d\n",sizeof(long));
printf("Sizeoffloatis%d\n",sizeof(float));
printf("Sizeofdoubleis%d\n",sizeof(double));
return0;
}

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
int*p;
*p;
double
double*q;
*q;
Date
Date*r;
*r;
pp== (int*)
(int*) malloc(sizeof(int));
malloc(sizeof(int));
qq== (double*)
(double*)malloc(sizeof(double));
malloc(sizeof(double));
rr==(Date*)
(Date*) malloc(sizeof(Date));
malloc(sizeof(Date));
p
q

*p
*q

3
3.14

*r

2 2 2002

malloc( ), closer look

sizeof(int) = the
number of bytes
occupied by an int

int
int *p;
*p;
pp == (int*)
(int*) malloc(sizeof(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
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p;
*p; int
inta=2;
a=2;
pp== (int*)
(int*) malloc(sizeof(int));
malloc(sizeof(int));
*p
*p== 4;
4;
*p
*p+=
+= a;
a;
Menghapus

Menghapussel
selyang
yang

ditunjuk
pp
ditunjuk
free(p);
free(p);
pp== NULL;
NULL;
}}

?
*p

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
voidfree(void*pblok);
dengan pblok adalah pointer
memori yang akan dibebaskan.

yang

menunjuk

ke

Dalam hal ini, pointer pblok tidak perlu di-cast

kembali ke void terlebih dahulu. Compiler otomatis

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
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p;
*p; int
inta=2;
a=2;
pp== (int*)
(int*) malloc(sizeof(int));
malloc(sizeof(int));
*p
*p== 4;
4;
*p
*p+=
+= a;
a;
Menghapus

Menghapussel
selyang
yang

ditunjuk
pp
ditunjuk
free(p);
free(p);
pp== NULL;
NULL;
}} Pada saat variabel dinamik tidak

?
*p

digunakan lagi kita perlu

membebaskannya. Kompiler tidak
mendealokasi storage space secara
otomatis

NULL

#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p;
*p; int
inta=2;
a=2;
pp== (int*)
(int*) malloc(sizeof(int));
malloc(sizeof(int));
*p
*p== 4;
4;
*p
*p+=
+= a;
a;

free(p);
free(p);
pp== NULL;
NULL;
}}

?
*p

p
p

#include <stdlib.h>

#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p;
*p; int
inta=2;
a=2;
pp== (int*)
(int*) malloc(sizeof(int));
malloc(sizeof(int));
*p
*p== 4;
4;
*p
*p+=
+= a;
a;

Menggunakan fungsi malloc(),

free(p);
free(p);
free() dan NULL harus
pp== NULL;
NULL; mengincludekan stdlib.h.
}}

*q = *p
int
int*p,
*p, *q;
*q;
pp== (int*)malloc(sizeof(int));
(int*)malloc(sizeof(int));
qq== (int*)malloc(sizeof(int));
(int*)malloc(sizeof(int));
*p
*p== 3;
3;
*q
*q== *p;
*p;

p
q

*p
*q

3
3

q=p
p
int
int*p,
*p,*q;
*q;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
qq==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
*p
*p==3;
3;
qq==p;
p;

p
q

*p

*q
*q
*p
3

Example
#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p,
*p,*q;
*q;
int
int*r;
*r;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
rr==p;
p;
qq==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
*p
*p==3;
3;
*q
*q==*p
*p++*r;
*r; (A)
(A)
free(r);
free(r); (B)
(B)
rr==NULL;
NULL; (C)
(C)
}}

(A)

(B)

(C)

p
r
q

*p
3

*r

*q

p
r
q

p
r
q

*q

*q

Latihan
#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p,
*p,*q;
*q;
int
int*r;
*r; int
int*s;
*s;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
rr==p;
p; *p
*p==5;
5;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
qq==p;
p;ss==r;r;*q
*q==*s
*s++1;
1;
*r*r==*p
*p**2;
2;
(A)
(A)
free(r);
free(r); rr==NULL;
NULL;
free(q);
free(q); qq==NULL;
NULL;
(B)
(B)
}}

Memory Leak
#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p,
*p,*q;
*q;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
*p
*p==1+2;
1+2;(A)
(A)
q = p; or free(p);
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
scanf("%d",
scanf("%d",p);
p);(B)
(B)
free(p);
free(p); pp==NULL;
NULL;(C)
(C)
}}

(A)

(B)

3
8

(C)

Pada
Padasaat
saat p=NULL;
p=NULL; maka
maka *p
*p
tidak
tidakdapat
dapatdiakses
diakseslagi
lagi

*p

*p

Pointer yang tidak valid

#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p,
*p,*q;
*q;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
qq==p;
p;
*q
*q==3;
3; (A)
(A)
free(q);
free(q);
qq==NULL;
NULL; (B)
(B)
printf("%d %d", *p, *q);
*p = 999;

*q = 999;
}}

(A)

(B)

Setelah
Setelahfree(q),
free(q),sel
sel*p
*p(dan
(dan*q)
*q)tidak
tidak
ada.
ada.Oleh
Olehsebab
sebabitu
itukita
kitatidak
tidakdapat
dapat
menggunakan
menggunakan*p
*patau
atau*q.
*q.

p
q

p
q

*p
3

*q

Free sel yang tidak digunakan

hanya satu kali
#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p,
*p,*q;
*q;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
qq==p;
p;
*q
*q==3;
3;(A)
(A)
free(q);
free(q);
qq==NULL;
NULL; (B)
(B)
free(p);

pp==NULL;
NULL;(C)
(C)
}}
Free untuk tiap sel yang tidak

Free untuk tiap sel yang tidak

digunakan
digunakanhanya
hanyadilakukan
dilakukan
satu
satukali
kali(Bukan
(Bukanfree
freetiap
tiap
pointer
pointersatu
satukali)
kali)

(A)

(B)

(C)

p
q
p
q
p
q

*p
3

*q

Jangan Free() Variabel Static

#include
#include<stdlib.h>
<stdlib.h>
int
intmain
main()(){{
int
int*p,
*p,*q;
*q;
int
intaa==5;
5;
pp==(int*)
(int*)malloc(sizeof(int));
malloc(sizeof(int));
qq==&a;
&a;
*p
*p==3;
3;(A)
(A)
free(p);
free(p); pp==NULL;
NULL;(B)
(B)
free(q);

qq==NULL;
NULL; (C)
(C)
}}

Kita
Kitahanya
hanyaperlu
perlumembebaskan
membebaskan
variabel
variabeldinamik.
dinamik.Bukan
Bukanvariabel
variabel
biasa.
biasa.Ingat
IngatFree()
Free()untuk
untukmalloc()
malloc()
saja.
saja.

(A)

(B)

(C)

p
q
p
q
p
q

*p
5 *q
a
3

a
5

*q

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