Bahasa C adalah bahasa paras tinggi (high level language) yang mengandungi ciri-ciri bahasa paras rendah (low level language). C boleh digunakan untuk semua bidang dan boleh digunakan dengan semua teknik pengaturcaraan.
Pada akhir 80an, bahasa C telah menjadi begitu popular. Kebolehan dan kepantasan C menyebabkan ia menjadi bahasa yang paling digemari untuk penggunaan sistem operasi dan kejuruteraan. Sekarang ia menjadi bahasa yang paling popular untuk pembangunan perisian dan juga penggunaan biasa. Ini mungkin kerana masyarakat informasi pada ketika itu ini sedang menuju ke arah sistem terbuka (open system) dan sistem operasi yang berkait rapat dengan sistem terbuka ini adalah sistem operasi UNIX. Bahasa pengaturcaraan yang berkait rapat dengan UNIX pula ialah C, kerana sebahagian besar dari UNIX itu sendiri pada asalnya ditulis dalam bahasa C. Apabila UNIX semakin popular, bahasa C juga turut menjadi popular.
Pada ketika yang sama, pakej-pakej pengaturcaraan C untuk MS-DOS (Microsoft Disk Operating System), yang digunakan pada komputer-komputer peribadi IBM, telah muncul di pasaran. Di antara pakej-pakej yang popular ialah dari Borland International dan dan QuickC dari Microsoft. Turbo C dan QuickC adalah pakej-pakej C yang dilengkapi dengan (compiler), (linker) dan (editor) yang disatukan dalam sebuah (integrated environment).
Microsoft C ialah pakej untuk digunakan dalam sekitaran baris arahan (Command Line Environment). Jadi sebuah yang berasingan diperlukan. Turbo C juga dibekalkan dengan satu set penyusun dan penyambung (Compiler and Linker) untuk penggunaan seumpama ini.
Tahun-tahun 90an menyaksikan kemunculan pakej-pakej pengaturcaraan C yang disepadukan dengan sekitaran pembangunan aturcara berorientaasikan objek (Object Oriented Programming environment). Pada masa yang sama, suatu versi baru bahasa C yang berorientasikan objek (object oriented) telah muncul, iaitu C++.
Dari C++ pula telah muncul JAVA, iaitu bahasa pengaturcaraan yang sedang meningkat popularitinya dengan mendadak. Tidaklah perlu saya bicarakan tentang hal ini kerana banyak tapak-tapak web yang dikhususkan untuk Java dan lain-lain hal yang berkaitan.
Contoh 1.1 : Sebuah Aturcara C Yang Mudah
/* Ini adalah aturcara C kita yang pertama */
#include
main()
{
printf("\n Ini adalah aturcara C kita yang pertama");
}
Ini adalah sebuah aturcara yang mudah dan pendek. Daripada contoh 1 ini dapatlah kita mencetak maklumat seperti di bawah ke paparan:
Ini adalah aturcara C kita yang pertama
Bahagian permulaan (kepala) aturcara ini terdiri daripada:
#include
dan
main()
Arahan "#include
Selain daripada baris-baris di atas, aturcara ini juga mengandungi baris komen sebagai maklumat tambahan. Lihat bagaimana semua perkataan di antara /* dan */ ditulis supaya kita atau orang lain mengetahui tujuan aturcara kita. Baris komen seperti ini tidak semestinya berada di baris permulaan aturcara akan tetapi boleh ditempatkan di mana-mana sahaja asalkan ia berada di antara aksara-aksara /* dan */. Adalah baik jika daripada permulaan lagi anda membiasakan diri supaya menggunakan baris komen ini dengan banyaknya. Ini akan menjelaskan perjalanan dan fungsi setiap blok pernyataan C anda. Cara begini adalah dianggap sebagai cara yang digunakan oleh seorang pengaturcara yang berpengalaman, mahir dan teratur hasil kerjanya.
Perhatikan juga bahawa terdapat tanda left curly braces dan right curly braces ({ dan }) untuk menandakan blok aturcara bagi fungsi main() yang merupakan rutin utama bagi aturcara ini. Di dalam contoh di atas, blok ini mengandungi satu sahaja pernyataan, iaitu pernyataan printf() yang merupakan panggilan kepada suatu fungsi output piawai yang diisytiharkan dalam fail stdio.h. Ini menjelaskan kenapa kita memasukkan fail tersebut dalam penyusunan. Perhatikan rentetan yang ditulis di antara dua simbol double quote ( "...." ) dalam printf(). Fungsi ini akan mencetak semua aksara yang terdapat dalam rentetan berkenaan. Akan tetapi terdapat simbol-simbol tertentu yang mempengaruhi nya. Dalam contoh di atas, terdapat simbol \n supaya rentetan kita dicetak pada baris yang baru.
2. Struktur Data C
2.1 Jenis-Jenis Data Asas
Jenis-jenis data asas dalam C boleh dibahagikan kepada tiga:
int = integer
float = nombor nyata
char = aksara
2.1.1 Jenis Int
Jenis int mewakili integer. Terdapat pula kata-kata kunci tertentu yang boleh digabungkan kepada int untuk membentuk jenis-jenis data yang lebih khusus lagi. Kata-kata kunci berkenaan ialah:
short = nombor integer 16 bit
long = nombor integer 32 bit
unsigned = nombor integer tanpa tanda
Kata kunci short dan long menentukan saiz yang digunakan untuk menyimpan data yang ditakrifkan. Untuk Turbo C misalnya, menggunakan 16 bit ruang ingatan, int (tanpa short atau long) juga 16 bit dan long int menggunakan 32 bit ruang ingatan. Saiz ini bergantung kepada sistem perisian dan yang digunakan. Bagi sebuah komputer mini, mungkin menggunakan 64 bit ruang ingatan. Saiz data menentukan kejituan. Lebih banyak bilangan bit yang digunakan, lebih jitu sesuatu nombor (data) itu. Tetapi ini juga bermakna lebih banyak ruang ingatan yang digunakan. Dengan pengisytiharan int, short int dan long int, data-data yang diisytiharkan adalah bertanda (signed), iaitu samada positif
atau negatif. Contohnya untuk satu int bersaiz 16 bit, nilai-nilai yang boleh diwakili olehnya ialah dari -32768 hingga 32767. Kata kunci unsigned digunakan untuk mengabaikan tanda positif atau negatif ini. Dengan mengabaikan tanda ini, julat nilai nombor berkenaan menjadi dua kali ganda iaitu dari 0 hingga 65535, walaupun ruang ingatan yang digunakan masih lagi 16 bit. Kata kunci unsigned ditambah kepada kata-kata kunci di atas untuk membentuk kombinasi berikut:
unsigned int
unsigned short int
unsigned long int
Oleh kerana short int dan long int masing-masing boleh diringkaskan kepada short dan long, maka dari jenis integer kita ada:
int
short
long
unsigned int
unsigned short
unsigned long
2.1.2 Jenis Float
Jenis float adalah untuk mewakili nombor nyata, atau dalam sistem komputer ia dikenali sebagai nombor titik apungan (floating point numbers). Bentuk nombor-nombor float ialah seperti salah satu yang berikut:
3.14559
6.63e-34 atau 6.63E-34 (E menandakan eksponen 10)
100
0.001
Julat nombor nyata dan kejituan yang boleh diwakili oleh sesatu nombor float itu bergantung kepada ruang ingatan yang digunakannya, biasanya 16 bit. Jenis float mempunyai dua versi yang lebih besar, iaitu (double precision, 32 bit) dan long double (64 bit). Jadi hanya tiga jenis float sahaja yang kita ada, iaitu:
float
double
long double
Tiada jenis-jenis lain seperti "unsigned float", "short double" dan sebagainya.
2.1.3 Jenis Char
Jenis char adalah untuk mewakili aksara (abjad, angka, simbol dan sebagainya). Abjad ialah huruf-huruf ABC hinga Z. Angka ialah nombor-nombor 0123 hingga 9. Manakala simbol-simbol pupla ialah seperti @, #, $ dan sebagainya.
Jenis char boleh juga dianggap sebagai int yang terhad untuk nilai-nilai dari -128 hingga 127 kerana setiap aksara diwakili oleh satu kod (nombor) tertentu. Oleh itu kata kunci unsigned boleh digunakan bersama char (menjadi unsigned char) untuk mendapatkan nilai-nilai 0 hingga 255. Penggunaan char dan int boleh ditukar-ganti jika nilai yang digunakan adalah kecil, iaitu untuk integer yang bernilai antara –128 hingga 127 atau integer tak bertanda (unaigned int) yang bernilai antara 0 dan 255.
2.2 Pengisytiharan Pembolehubah
Setiap pemblehubah yang digunakan dalam aturcara C perlu diisytiharkan, seperti kebanyakan bahasa pengaturcaraan yang lain tetapi tidak seperti di dalam BASIC dan FORTRAN di mana pembolehubah- pembolehubahnya tidak perlu diisytiharkan.
Bentuk pengisytiharan pembolehubah C ialah:
jenis NamaPembolehubah;
Contohnya:
int nombor;
float peratus;
char gred;
unsigned long nombor_matrik;
Nama pembolehubah boleh terdiri dari sebarang huruf atau nombor. Kebanyakan simbol-simbol tidak boleh digunakan dalam nama pembolehubah (dan sebarang pengcam lain) kerana ia mempunyai kegunaan-kegunaan tertentu dalam atrucara C. Tetapi simbol garis bawah (under-score '_') adalah satu pengecualian dan ia sering digunakan dalam nama-nama pembolehubah yang panjang. Contohnya seperti pembolehubah nombor_matrik di atas. Dengan menggunakan nama-nama yang panjang dan deskriptif seperti ini, kegunaan pembolehubah berkenaan akan lebih mudah difahami.
2.3 Pengawalan Dan Umpukan
Semasa sesuatu pembolehubah itu disytiharkan, ia boleh diberi nilai yang tertentu. Pengisytiharan dengan cara ini dinamakan pememulaan (initialization). Contoh- contohnya adalah seperti berikut:
int nombor = 1;
float peratus = 0.5;
char gred = 'A';
Dengan menggunakan pememulaan seperti ini, pembolehubah-pembolehubah berkenaan boleh digunakan terus tanpa memerlukan umpukan terlebih dahulu. Umpukan (assignment) dilakukan sama seperti pememulaan tetapi tanpa kata kunci jenisnya. Jadi contoh-contoh berikut adalah untuk umpukan:
nombor = 2;
peratus = 10;
gred = 'B';
Nilai-nilai dari pembolehubah lain, hasil dari pengiraan, hasil dari sesuatu fungsi tertentu dan sebagainya boleh juga diumpukkan kepada sesuatu pembolehubah itu. Ini juga boleh dilakukan semasa pememulaan. Jadi contoh-contoh berikut ini adalah sah:
int x = wherex();
int y = wherey();
int a = x + y;
x = wherex() + a;
y = x + a;
Nota: Andaikan wherex() dan wherey() adalah fungsi- fungsi yang tertakrif.
2.4 Operator Dan Fungsi Matematik
Operator digunakan untuk melakukan pengiraan dan manipulasi data yang mudah. Dalam C terdapat operator-operator aritmatik dan tokokan (increment). Selain dari itu terdapat pula fungsi-fungsi matematik piawai yang boleh digunakan untuk pengiraan yang lebih kompleks (Lihat BAB 3).
2.4.1 Operator Aritmatik
Senarai operator aritmatik C adalah seperti dalam bahasa-bahasa pengaturcaraan yang lain juga, iaitu:
OPERASI
SIMBOL
CONTOH
Tambah (plus)
+
x = a + b
Tolak (minus)
-
x = a - b
Darab (multiply)
*
x = a * b
Bahagi (divide)
/
x = a / b
Baki (mod)
%
x = a % b
NOTA: x ialah pembolehubah; a dan b boleh jadi pembolehubah atau nilai yang sama jenis dengan x.
Penulisan operasi yang ditunjukkan di atas adalah yang sebaik-baiknya. Akan tetapi, aksara-aksara ruang tidak memberi kesan ke atas hasil operasi. Pernyataan-pernyataan berikut adalah setara:
a+b
a+ b
a + b
Cara yang terbaik ialah menulisnya supaya tidak menimbulkan kekeliruan, seperti dalam contoh terakhir yang ditunjukkan di atas.
2.4.2 Menggabungkan Operator Aritmatik
Operasi-operasi aritmatik boleh digabungkan untuk membuat pengiraan yang lebih kompleks. Apabila digabungkan, pengiraan dilakukan dalam jujukan tertentu. Operator-operator darab dan bahagi diberi keutamaan berbanding operator-operator tambah dan tolak. Contohnya:
6 + 4 / 2 = 6 + 2 = 8
( 6 + 4 ) / 2 = 10 / 2 = 5
Perhatikan bahawa kita menggunakan tanda kurungan untuk mengubah jujukan pengiraan. Dalam contoh pertama di atas, 4 dibahagi 2, kemudian ditambah 6. Dalam contoh kedua, 6 ditambah 4, kemudian jumlahnya dibahagi dengan 2.
2.4.2 Operator Tokokan
Operator-operator tokokan adalah singkatan kepada operator-operator aritmatik yang telah dinyatakan sebelum ini. Berikut ialah senarai operator-operator tokokan:
SIMBOL
CONTOH
OPERASI SETARA
++
x++
x = x+1
--
x--
x = x-1
+=
x += a
x = x+a
-=
x -= a
x = x-a
*=
x *= a
x = x*a
/=
x /= a
x = x/a
%=
x %= a
x = x%a
Operator-operator tokokan tambahan dan tolakan boleh digabungkan dengan umpukan seperti berikut:
PERNYATAAN
PERNYATAAN SETARA
y = a + x++;
y = a + x;
y = x + 1;
y = a + x--;
y = a + x;
y = x - 1;
Untuk melakukan tokokan terlebih dahulu sebelum umpukan, tanda ++ atau -- boleh diletakkan di depan pembolehubah seperti berikut:
PERNYATAAN
PERNYATAAN SETARA
y = ++x;
x = x + 1;
y = x;
y = a + ++x;
x = x + 1;
y = a + a;
2.4.3 Penukaran Jenis Data
Dalam kes-kes tertentu kita perlu menukar jenis data dari satu jenis ke satu jenis yang lain, umpamanya kita ingin mengumpukkan hasil pengiraan yang menghasilkan nombor int kepada satu pembolehubah dari jenis float. Dalam C penukaran jenis data dilakukan seperti berikut:
(jenis) nilai;
dengan jenis ialah jenis data yang baru; dan nilai ialah satu nilai tertentu samada nombor, hasil operasi matematik dan sebagainya. Contohnya:
int a;
float x;
.
.
.
x = (float) a / x;
Dalam contoh di atas, nilai a ditukarkan kepada float terlebih dahulu sebelum dibahagikan dengan x. Hasilnya diumpukkan kepada x.
2.4.4 Fungsi Matematik
Terdapat beberapa fungsi matematik yang telah tertakrif secara piawai dalam perpustakaan C. Antaranya yang sering digunakan ialah
:
NAMA
FUNGSI
cos
kosinus
log
logaritma asas e
sin
sinus
sqr
kuasa dua
sqrt
punca kuasa dua
Prototaip bagi fungsi-fungsi ini terdapat dalam fail HEADER math.h. Oleh itu ia perlu disertakan dalam aturcara dengan menggunakan arahan prapemproses #include. Contohnya:
#include
float x, y;
int a;
.
.
.
y = sqrt( x );
x = sin( (float) a );
Ia boleh juga digabungkan dengan operator-operator aritmatik seperti berikut:
y = 1.5 + sqrt( x ) * sin ( x );
Senarai lengkap fungsi-fungsi matematik yang biasanya terdapat dalam math.lib disenaraikan dalam lampiran teks ini.
2.5 Pemalar
Pemalar ialah nilai yang tetap, berlawanan dengan pembolehubah yang mana nilainya kita hendak ubah-ubahkan bergantung kepada keadaan. Antara pemalar-pemalar yang kita gunakan dalam masalah-masalah matematik dan kejuruteraan ialah seperti nilai PI, pemalar Planck, Boltzman, halaju cahaya, cas elektron dan sebagainya. Jika nilai-nilai ini ingin kita gunakan dalam pengiraan, kita boleh isytiharkannya sebagai pemalar. Terdapat dua cara untuk mengisytiharkan pemalar dalam C. Cara pertama adalah dengan menggunakan #define dan cara yang kedua ialah dengan kata kunci const.
Untuk mengisytiharkan nilai PI misalnya kita boleh tulis:
#define PI = 3.1415927
atau:
const float pi = 3.1415927;
Perhatikan bahawa dengan #define kita tidak menggunakan tanda umpukan (=) dan tidak perlu meletakkan tanda ';' di hujungnya. Ini adalah kerana #define adalah arahan pengkompilasi dan bukan sebahagian dari pernyataan C. Semasa penyusunan aturcara, pengkompilasi akan menggantikan semua pemalar yang ditakrifkan dengan #define ke dalam aturcara. Jadi, kesannya adalah sama seperti kita menulis pemalar itu terus ke dalam aturcara, cuma di sini, kerja kita diringkaskan sedikit. Kita tidak perlu menulis angka-angka yang sebenar tetapi hanya perlu menulis nama yang kita beri kepadanya sahaja. Contohnya sebagai ganti menulis pengiraan seperti berikut:
x = sin( 3.145927 );
kita boleh menulisnya begini sahaja:
x = sin( PI );
Perhatikan juga bahawa dengan arahan #define kita tidak perlu menulis jenis data pemalar yang kita takrifkan. Ini juga kerana sebab yang dinyatakan tadi. Bagi const kita perlu menyatakan jenis data pemalar kita kerana pernyataan ini melibatkan peruntukan ruang ingatan seperti pembolehubah juga. Cuma bezanya kita tidak boleh mengubah nilai pemalar sebagaimana yang boleh kita lakukan terhadap pembolehubah melalui umpukan. Jika jenis pemalar tidak dinyatakan, maka pemalar itu dianggap sebagai pemalar int. Berikut adalah beberapa contoh pengisytiharan pemalar menggunakan const:
const maxint = 32767;
const char gred = 'A';
const char nama[] = "AHMAD";
(NOTA: Lihat tajuk RENTETAN untuk penerangan tentang pengisytiharan nama[] di atas)
Penggunaan sebenar #define adalah lebih luas daripada mentakrifkan pemalar dalam bentuk nombor sahaja. Malah ia boleh digunakan untuk menggantikan baris-baris aturcara. Berikut adalah beberapa contoh pentakrifan dengan #define:
#define MAXINT 32767
#define GRED A
#define NAMA AHMAD
#define FORMAT "\n %d %f "
(NOTA: Lihat aturcara contoh 7 untuk penerangan tentang pentakrifan FORMAT di atas)
Adalah menjadi kelaziman iaitu pemalar-pemalar yang ditakrif dengan menggunakan #define ditulis dalam huruf-huruf besar dan yang diisytihar dengan const ditulis dalam huruf-huruf kecil seperti pembolehubah-pembolehubah lain. Ini adalah bertujuan untuk memudahkan penulis aturcara dan juga orang lain memahami penggunaan pemalar-pemalar berkenaan.
2.6 Tatasusunan
Tatasusunan (arrays) ialah senarai berindeks bagi satu-satu jenis data tertentu. Contohnya tatasusunan bagi int ialah satu senarai nombor-nombor integer yang boleh kita rujuk melalui indeksnya. Bentuk tatasusunan dalam C ialah seperti berikut:
jenis nama[saiz];
dengan jenis ialah jenis data yang digunakan untuk membentuk tatasusunan; nama ialah nama yang diberikan kepada tatasusunan; dan saiz ialah bilangan unsur di dalam tatasusunan. Contohnya untuk membentuk tatasusunan sepuluh integer kita tulis pengisytiharan berikut:
int nombor[10];
Di sini nombor ialah nama bagi tatasusunan kita. Kita boleh berikan nilai awal kepada tatasusunan ini melalui pememulaan seperti berikut:
int nombor = { 10,20,30,40,50,60,70,80,90,100 };
Untuk menggunakan satu dari unsur dalam tatasusunan di atas, kita rujuk melalui indeksnya. Indeks pertama adalah bermula dari sifar dan indeks terakhir adalah saiz - 1. Jadi untuk tatasusunan nombor
nombor[0]
nombor[1]
nombor[2]
.
.
.
nombor[9]
Kita boleh umpukkan nilai dari unsur pertama kepada satu pembolehubah integer x misalnya:
x = nombor[0];
atau kita beri nilai baru kepadanya:
nombor[0] = 111;
Secara umum, kita boleh menggunakan tatasusunan seperti menggunakan data jenis biasa, tetapi ia mempunyai kelebihan iaitu boleh dirujuk melalui indeksnya. (Lihat aturcara contoh 15 untuk melihat penggunaan tatasusunan dalam aturcara). Kita boleh membentuk tatasusunan dari jenis-jenis data lain seperti char dan float; termasuk jenis-jenis data penunjuk dan struktur (lihat BAB 5).
2.7 Rentetan Aksara (string of characters)
Di dalam C tidak terdapat jenis data rentetan (string) secara khusus tetapi ianya boleh dibina di dalam C dengan mengisytiharkan pembolehubah aksara dalam bentuk tatasusunan (array) atau penunjuk (pointer). Di sini penggunaan tatasusunan akan ditunjukkan kerana ia lebih mudah difahami. Penggunaan penunjuk ditunjukkan dalam BAB 5.
Bentuk pengisytiharan pembolehubah dari jenis rentetan ialah seperti berikut:
char NamaRentetan[n];
dengan n mewakili panjang rentetan (dalam bilangan aksara) yang dikehendaki.
Contohnya:
char nama[30];
char alamat[100];
Pembolehubah-pembolehubah yang diisytiharkan dari jenis rentetan boleh digunakan dengan merujuk kepada namanya sahaja. Akan tetapi oleh kerana rentetan adalah suatu tatasusunan, operasi-operasi umpukan yang biasa tidak boleh dilakukan ke atasnya, kecuali semasa pememulaan. Contohnya, kita boleh tulis pernyataan seperti ini:
char nama[30] = "Ahmad";
tetapi tidak umpukan seperti ini:
nama = "Ahmad";
Untuk tujuan umpukan seperti ini, kita perlu menggunakan fungsi khas strcpy() (string copy):
strcpy( nama, "Ahmad" );
Semasa pememulaan, jika panjang rentetan tidak dinyatakan, panjang rentetan asal akan diambil sebagai panjang rentetan berkenaan. Contohnya:
char poskod[] = "43000";
Panjang rentetan poskod di atas ialah lima aksara.
2.8 Fungsi-fungsi Piawai
Dua fungsi asas untuk dalam C ialah printf() untuk output dan scanf() input. Fungsi-fungsi ini dinamakan sedemikian rupa kerana pada asasnya, printf() mencetak (print) sesuatu pada paparan dalam bentuk tertentu (formatted) dan scanf() pula mengimbas (scan) sesuatu dari , juga dalam bentuk tertentu.
NOTA: Dalam C++, fungsi-fungsi printf() dan scanf() biasanya digantikan dengan pernyataan-pernyataan cout dan cin.
2.8.1 Fungsi printf()
Bentuk penggunaan fungsi printf() ialah:
printf(
Dengan:
Contohnya, untuk memaparkan nilai suatu pembolehubah jumlah dari jenis int, kita boleh tulis seperti ini:
printf("\n Jumlah = %d \n", jumlah);
Dengan:
"\n Jumlah = %d \n" ialah string format.
jumlah ialah data yang hendak dipaparkan.
Jika kita perhatikan dalam string format di atas, kita akan dapati selain dari perkataan "Jumlah", terdapat beberapa simbol lain yang dinamakan spesifikasi format dan mempunyai makna yang tertentu kepada fungsi printf(). Simbol ‘%d’ menandakan bahawa data yang hendak dipaparkan ialah dari jenis integer dalam bentuk . (Tanda ‘%’ menandakan bahawa ada data yang dilampirkan, dan huruf ‘d’ yang digabungkan kepadanya menunjukkan bahawa data berkenaan adalah dari jenis integer dan hendak ditulis dalam bentuk .)
Simbol ‘\n’ pula mewakili aksara 13 dan 10 dalam ASCII iaitu aksara Carriage Return dan Line Feed. Secara ringkas, simbol ‘\n’ ini menyebabkan kurser bergerak ke permulaan baris output yang baru. Jika diletakkan di permulaan teks (iaitu: "\n Jumlah = %d" ), ia menyebabkan data dipaparkan pada baris yang baru. Jika diletakkan di hujung teks (iaitu: "Jumlah = %d \n" ), sebarang data yang berikutnya akan dipaparkan pada baris yang baru.
Simbol-simbol seperti ‘\n’, ‘\t’ dan sebagainya dinamakan jujukan escape (escape sequence). Ia mewakili aksara-aksara khas yang terdapat dalam kod ASCII. Jadual-jadual yang mengandungi senarai dan jujukan Escape terdapat dalam LAMPIRAN. Sila ambil perhatian bahawa oleh kerana tanda % digunakan untuk spesifikasi format, maka untuk memaparkan tanda % kita gunakan %%. Contohnya, jika air ialah pembolehubah integer dengan nilai 10, maka:
printf(" Kandungan air = %d %%", air);
memberikan output:
Kandungan air = 10 %
Bagi jujukan Escape pula, untuk memaparkan tanda '\' (back slash), kita perlu tulis '\\' iaitu menulis simbol back slash itu secara berganda atau dua kali berturut-turut; dan untuk memaparkan tanda '"' (double quote), kita perlu tulis '\"' (back slash + double quote).
2.8.2 Mengawal Format Output
Lebar ruang (medan) yang digunakan untuk memaparkan data (item) boleh ditentukan dengan meletakkan satu nombor antara tanda % dan huruf dalam spesifikasi format berkenaan. Contohnya untuk memaparkan satu pembolehubah (jumlah) dalam empat ruang aksara, kita boleh tulis:
printf(" Jumlah = %4d", jumlah);
Jika jumlah ialah 10, ini memberikan output:
Jumlah = __10
NOTA: Simbol '_' menunjukkan aksara ruang (space) yang ditambah oleh printf(). Dalam output sebenar, tanda ini tidak kelihatan. Ia diletakkan dalam contoh di atas untuk memudahkan penerangan sahaja.
Seterusnya untuk data dari jenis string:
printf(" %10s = %5 ", "Jumlah", jumlah );
memberikan output:
____Jumlah = ___10
Untuk data dari jenis float, selain dari menentukan , kita juga boleh menentukan bilangan yang akan digunakan. Nilai lalai bagi bilangan nombor perpuluhan ialah enam. Contohnya, jika kita ada pembolehubah float nilai = 32000, maka:
printf("%f", nilai);
printf("%9.2f", nilai);
printf("%e", nilai);
printf("%6.1e", nilai);
masing-masing akan memberikan output:
32000.000000 (6 angka perpuluhan)
_32000.00 (9 aksara, 2 angka perpuluhan)
3.200000e+004 (6 angka perpuluhan)
3200.0e+002 (6 aksara, 1 angka perpuluhan)
2.8.3 Fungsi-fungsi output yang lain
Selain dari printf(), terdapat dua lagi piawai, iaitu puts() dan putchar(). Fungsi puts() ialah untuk memaparkan string sahaja (put string). Ia menambah aksara '\n' di hujung string yang dipaparkan. Ini menyebabkan kurser bergerak ke baris baru selepas string berkenaan dipaparkan. Secara umum, puts("string") adalah setara dengan printf("string\n") atau printf("%s\n", "string").
Fungsi putchar() pula ialah untuk sahaja. Secara umum, putchar( ch ) adalah setara dengan printf("%c", ch).
Selain dari itu, terdapat variasi dari fungsi-fungsi output ini seperti fprintf(), fputs() dan fputchar(). Fungsi-fungsi ini digunakan untuk output ke saluran-saluran output yang lain selain daripada , seperti fail pada cakera, pangkalan sesiri, pencetak dan sebagainya. Contohnya untuk mencetak pada , kita boleh tulis seperti ini:
fprintf( stdprn, "Hasil = %d", a );
dengan stdprn ialah pengcam piawai untuk saluran ke pencetak.
2.8.4 Fungsi scanf()
Secara umum, scanf() ialah untuk membaca data dari konsol atau papan kunci (keyboard). Bentuk penggunaannya ialah:
scanf(
Kecuali beberapa pengecualian kecil, bagi scanf() adalah sama seperti untuk printf() (Lihat jadual dalam LAMPIRAN).
scanf("%d", &a);
Dengan mengandaikan a sebagai pembolehubah int, maka &a adalah alamat baginya di dalam ingatan. Pembolehubah dari jenis string tidak memerlukan tanda '&' kerana nama bagi string merujuk kepada alamat. Jadi kita cuma perlu tulis:
scanf("%s", nama);
jika nama adalah satu pembolehubah string.
Untuk membaca beberapa nilai data, kita gunakan (sebagai contoh):
scanf("%d %d", &a, &b);
Ini membolehkan kita membaca dua integer dari konsol. Perhatikan: terdapat satu ruang (space) antara dua simbol %d di atas. Tanda ruang ini menandakan bahawa semasa input, nilai-nilai a dan b perlu dipisahkan oleh sekurang-kurangnya satu ruang (space), tab, "newline" ([Enter]) atau sebarang kombinasi dari ketiga-tiganya.
2.8.5 Fungsi-fungsi input yang lain
Fungsi-fungsi input yang lain ialah dan . Nyata sekali, gets() ialah untuk dan getch() untuk . Bentuk penggunaan kedua-duanya ialah:
gets( string );
ch = getch();
dengan string dan ch masing-masing ialah pembolehubah-pembolehubah string dan aksara. Perhatikan: getch() digunakan secara umpukan.
Fungsi gets() menerima masuk sebarang aksara yang ditaip pada , sehinggalah [Enter] ditekan. Perbezaan antara gets() dan scanf("%s") ialah: gets() membaca semua aksara, termasuk aksara ruang (space), tetapi scanf("%s"), walaupun ia juga membaca sehingga [Enter] ditekan, tetapi sebarang aksara selepas aksara ruang (space) pertama yang ditemuinya tidak akan disimpan. Contohnya jika kita ada:
scanf("%s", nama); dan gets(nama);
dan jika rentetan "Ali bin Ahmad" ditaipkan pada sebagai jawapan kepada fungsi-fungsi tadi, maka untuk kes printf(), pembolehubah nama akan mengadungi "Ali", tetapi untuk kes gets(), nama akan mengandungi keseluruhan "Ali bin Ahmad".
Fungsi getch() membaca satu aksara dari tanpa memaparkan aksara itu ke paparan. Variasi dari dari getch() ialah getche() (get character with echo). Dengannya, aksara yang ditaip akan dipaparkan ke paparan.
Variasi lain dari fungsi-fungsi input ini ialah fscanf(), fgets() dan sebagainya, untuk kegunaan pada saluran-saluran input yang lain selain daripada seperti fail pangkalan sesiri dan lain-lain.
Contoh-Contoh Aturcara 2
Contoh 2.1 : Pengisytiharan Pembolehubah
/* Aturcara kedua ini menunjukkan pengisytiharan
pembolehubah dan melaksanakan pengiraan mudah.
Hasilnya dipaparkan ke paparan. */
#include
int x, x2;
main()
{
x = 12;
x2 = x * x;
printf("\n %d %d", x, x2);
}
Aturcara ini mendedahkan kita kepada proses yang dapat dilaksanakan oleh aturcara C. Dalam aturcara ini kita mengisytiharkan dua x dan x2 seperti berikut:
int x, x2;
Perhatikan bahawa pengisytiharan ini dilakukan di luar blok fungsi main(). Kita boleh juga meletakkan pengisytiharan ini di dalamnya iaitu di bahagian awal blok selepas sahaja tanda pembuka blok seperti berikut:
main()
{
int x, x2;
Untuk aturcara yang mudah dan ringkas seperti ini, ia tidak akan memberi sebarang perubahan terhadap pelaksanaan aturcara. Kita juga ada dua iaitu:
x = 12;
x2 = x * x;
Pernyataan yang pertama di atas boleh kita gabungkan dalam pengisytiharan untuk membentuk satu seperti berikut:
int x = 12, x2;
Akan tetapi adalah menjadi satu kelaziman dalam pengaturcaraan C bahawa pememulaan dan pengisytiharan biasa tidak digabungkan. Ini adalah untuk mengelakkan kekeliruan bagi pengaturcara. Bagi penyusun, ianya adalah sama sahaja samada kita menulisnya seperti di atas atau kita menulisnya dalam bentuk yang lebih jelas seperti berikut:
int x = 12;
int x2;
Jika kita gunakan pememulaan seperti salah satu cara tadi maka pernyataan umpukan kita yang pertama di atas tidak diperlukan lagi. Pernyataan umpukan yang kedua pula ialah satu pengiraan pendek. Ia mengarahkan komputer supaya mendarabkan nilai pembolehubah x (iaitu 12) dengan nilainya sendiri. Jadi kita melakukan 12 dengan 12. Hasil pendaraban ini pula disimpan ke dalam pembolehubah x2. Pernyataan (fungsi) printf() mencetak kedua-dua nilai x dan x2 ke paparan. Perhatikan bahawa terdapat dua simbol %d di dalamnya. Simbol-simbol ini menandakan bahawa kita ingin mencetak dua nombor integer dalam bentuk desimal. Dalam penyusun-penyusun C yang mengikut draf piawaian ANSI, kita boleh menggantikan %d dengan %i. Akan tetapi simbol %d telah digunakan sekian lama dan inilah simbol yang sering digunakan.
Perhatikan juga terdapat ruang-ruang antara simbol-simbol \n, %d yang pertama dan %d yang kedua. Ini hanyalah untuk mendapatkan output yang lebih jelas. Kita boleh menulis simbol-simbol ini rapat-rapat tetapi tiada faedahnya.
3. STUKTUR ATURCARA C
3.1 Struktur Umum Aturcara C
Sebuah aturcara C terdiri daripada sekurang-kurangnya sebuah fungsi yang diberi nama main() dan boleh ditambah dengan beberapa fungsi lain dengan nama-nama yang tersendiri. Sebuah aturcara yang mudah mungkin mempunyai fungsi main() sahaja, manakala sebuah aturcara yang kompleks mungkin mengandungi sebuah fungsi main() serta berpuluh-puluh malah beratus-ratus fungsi lain.
main()
fungsi_1()
fungsi_2()
:
:
fungsi_n()
Rajah 4.1: Format Aturcara C
Sebuah fungsi pula, samada main() atau yang lainnya, adalah terdiri daripada bahagian kepala dan badan. Bahagian kepala mengandungi takrifan-takrifan, arahan-arahan preprosesor, berkenaan dan sebagainya. Secara umum, bahagian kepala ini mengandungi persiapan-persiapan awal bagi fungsi berkenaan. Bahagian badan pula hampir keseluruhannya mengandungi kod-kod aturcara bagi fungsi berkenaan. Terdapat juga takrifan-takrifan pembolehubah dan sebagainya yang diletakkan di bahagian badan sesuatu fungsi itu. Secara umum, bahagian badan ini menentukan apakah sebenarnya yang dilakukan oleh fungsi berkenaan.
Sebuah aturcara yang mudah, yang mengandungi hanya sebuah fungsi, iaitu fungsi main(), mungkin mempunyai struktur seperti ini:
#include
main()
{
int bil;
:
:
}
Rajah 4.2: Bentuk Sebuah Aturcara Mudah
Penerangan:
#include Arahan preprocessor untuk menyelit fail yang dinamakan dalam tanda <> (dalam contoh tadi, stdio.h)
main() Nama fungsi utama. Setiap aturcara C yang dilaksanakan, akan dimulakan dari fungsi main().
{ ) Di sini ia digunakan untuk membuka dan menutup blok bagi fungsi main().
int bil; Pernyataan C untuk pememulaan, seperti yang diterangkan dalam BAB 2.
Perkara-perkara penting yang perlu diperhatikan di sini ialah:
1. Nama fungsi mesti mengandungi tanda '(' dan ')'. Tanda ini sebenarnya ialah untuk mengisi parameter-parameter fungsi berkenaan. Oleh kerana fungsi main() yang kita gunakan ini tidak berparameter, maka ia dibiarkan kosong.
2. Setiap fungsi mesti mempunyai sekurang-kurangnya sepasang pembuka dan penutup blok.
3. Setiap satu pernyataan yang lengkap, seperti pememulaan dan panggilan kepada fungsi printf() dalam contoh tadi, mesti diakhiri dengan tanda ';'.
3.2 Komen
Untuk membuatkan aturcara mudah difahami oleh pengaturcara sendiri atau sesiapa yang membacanya, komen boleh ditambah. Di dalam C, komen diletakkan di antara tanda '/*' dan tanda '*/'. Contohnya:
/* Ini satu komen */
/* Ini
juga
satu komen
*/
Perhatikan: sesuatu komen itu tidak semestinya berada dalam satu baris sahaja. Tetapi penggunaan komen yang terlalu panjang dan melewati beberapa baris hendaklah dengan hati-hati.
Ada kompiler yang membenarkan komen-komen diletakkan secara bersarang seperti ini:
/* Komen pertama
/* komen kedua */
penutup komen pertama */
Ada kompiler yang tidak membenarkannya, dan ada yang memberi pilihan kepada pengguna. Secara umum, elakkan dari menggunakan komen bersarang ini, kecuali jika anda yakin ianya dibenarkan.
Komen-komen biasanya digunakan untuk menerangkan tujuan dan penggunaan aturcara, penggunaan sesuatu pernyataan, menandakan penutup takrifan fungsi dan sebagainya. (Lihat contoh-contoh aturcara dalam BAB 6 untuk melihat bagaimana komen-komen diletakkan).
3.3 Kawalan Aturcara
Apabila set pernyataan-pernyataan dalam sesuatu aturcara itu dilaksanakan, ia akan dimulakan dari bahagian atas set itu dan bergerak satu demi satu ke bawah set, sehingga ke pernyataan yang terakhir. Semua bahasa pengaturcaraan mempunyai pernyataan-pernyataan kawalan yang boleh digunakan untuk mengubah haluan pelaksanaan sesuatu aturcara itu. Ada pernyataan kawalan yang membolehkan pangaturcara membuat gelungan (loops), iaitu melaksanakan satu set pernyataan tertentu berkali-kali; membuat pilihan (selection), membuat perbandingan dan sebagainya. Di dalam C terdapat empat set pernyataan kawalan, iaitu if & if-else, for, while & do-while, dan switch-case.
3.3.1 Pernyataan Kawalan (pilihan) if dan if-else
Pernyataan if digunakan untuk melakukan perbandingan dan pilihan. Contohnya jika kita hendak menentukan samada sesuatu nombor itu positif, kita boleh membandingnya dengan sifar. Jika nombor itu lebih besar dari sifar misalnya, kita boleh laksanakan satu set pernyataan tertentu. Kita boleh gunakan pernyataan if untuk tujuan ini. Bentuk penggunaan if ialah seperti berikut:
if ( syarat ) pernyataan;
Penerangan:
1. Syarat biasanya ialah satu perbandingan, tetapi boleh jadi juga hasil dari sesuatu operasi matematik atau suatu fungsi.
2. Pernyataan ialah sebarang pernyataan atau set pernyataan-pernyataan C.
Contoh:
if ( a > 0 ) printf("\n a positif");
Dalam contoh di atas, perbandingan dibuat antara pembolehubah a dan sifar, iaitu samada a lebih besar daripada sifar atau tidak. Jika a lebih besar daripada sifar, maka pernyataan (fungsi) printf() selepas perbandingan itu akan dilaksanakan. Operator-operator yang boleh digunakan untuk perbandingan ialah:
OPERATOR
MAKNA
CONTOH
==
Persamaan
if ( a == b )
<
Kurang daripada
if ( a < b )
>
Lebih daripada
if ( a > b )
<=
Kurang atau sama
if ( a <= b )
>=
Lebih atau sama
if ( a >= b )
!=
Tidak sama dengan
if ( a != b )
Jadual 3.1: Operator-operator Perbandingan
Pernyataan if boleh digabungkan dengan pernyataan else untuk menyambung proses perbandingannya. Bentuk pernyataan if-else ialah:
if ( syarat )
pernyataan1;
else
pernyataan2;
Jika syarat adalah benar, maka pernyataan1 akan dilaksanakan, dan jika tidak pernyataan2 akan dilaksanakan. Contohnya:
if ( x == 0 )
printf("\n X adalah sifar");
else
printf("\n X bukan sifar");
Pernyataan if-else ini boleh dikembangkan lagi menjadi seperti berikut:
if ( x == 0 )
printf("\n X adalah sifar");
else if ( x > 0 )
printf("\n X adalah positif");
else
printf("\n X adalah negatif");
Sebenarnya untuk syarat yang telah dinyatakan, tidak semestinya satu perbandingan dilakukan. Syarat itu boleh diletakkan sebagai satu pembolehubah sahaja misalnya. Pernyataan if hanya akan memeriksa hasil syarat yang diletakkan, samada sifar atau bukan. Operasi-operasi perbandingan akan memberikan nilai bukan sifar jika perbandingan adalah benar, dan sifar jika tidak benar. Jadi, perbandingan dengan sifar boleh digantikan dengan pembolehubah yang hendak dibandingkan itu sahaja. Jadi:
if( a!=0 ) adalah setara dengan if ( a )
Dan lagi, pernyataan:
if (1)
akan sentiasa memberikan jawapan "benar".
Jika kita inginkan satu set pernyataan dilaksanakan, pernyataan-pernyataan ini perlulah di letakkan di dalam satu blok seperti ini:
if ( syarat )
{
pernyataan_1;
pernyataan_2;
.
.
pernyataan_n;
}
3.3.2 Pernyataan Kawalan (gelungan) while dan do-while
Pernyataan while digunakan untuk melakukan gelungan, iaitu melaksanakan satu pernyataan atau satu set pernyataan tertentu, selagi tertentu dipenuhi. Bentuk penggunaan pernyataan while ialah:
while ( syarat ) pernyataan;
Syarat dan pernyataan ialah seperti yang telah dinyatakan di bawah tajuk yang lalu. Contohnya, jika i ialah satu pembolehubah integer bernilai sifar:
while ( i < 10 ) i++;
Gelung while di atas tidak melakukan apa-apa kecuali menambah nilai i dengan satu sehinggalah i mencapai nilai sepuluh. Biasanya satu pernyataan sahaja tidak mencukupi, seperti yang ditunjukkan di atas, dan biasanya pembolehubah yang digunakan sebagai pembilang atau diumpukkan dengan nilai tertentu sebelum pernyataan while. Contohnya:
i = 0;
while ( i < 10 )
{
printf(" %d", i);
i++;
}
Dalam contoh ini, satu senarai nombor dari sifar hingga ke sembilan dipaparkan pada paparan.
Variasi kepada pernyataan while ialah do-while. Bentuknya ialah seperti berikut:
do pernyataan;
while ( syarat );
Untuk mendapatkan output seperti contoh yang lalu, kita tulis seperti ini:
i = 0;
do
{
printf(" %d", i);
i++;
} while ( i < 10 );
Perbezaan antara while dan do-while ialah kedudukan pemeriksaan syaratnya. Bagi while, syarat diperiksa sebelum gelungan dilakukan, tetapi bagi do-while, syarat diperiksa selepas gelungan dilakukan. Jadi do-while akan melakukan sekurang-kurangnya satu gelungan. Contohnya, gelungan while yang berikut ini tidak akan memberikan sebarang output:
i = 0;
while ( i )
{
printf(" %d", i);
i = 1;
}
Contoh yang berikut ini pula akan memaparkan angka sifar, kemudiannya angka satu secara berterusan ( 0 1 1 1 1 1.....), walaupun syarat yang digunakan adalah sama seperti untuk gelungan while tadi:
i = 0;
do
{
printf(" %d", i);
i = 1;
} while ( i );
3.3.3 Pernyataan Kawalan (gelungan) for
Pernyataan for digunakan untuk melakukan gelungan dengan bilangan tertentu. Bentuk penggunaannya ialah:
for ( pememulaan; syarat; perubahan syarat)
pernyataan;
Contohnya, jika i adalah satu pembolehubah integer:
for ( i = 0; i < 10; i++)
printf(" %d", i );
Pememulaan adalah sama seperti pernyataan umpukan dalam baris-baris aturcara yang biasa. Jadi pembolehubah yang digunakan di dalam pememulaan mestilah diisytiharkan terlebih dahulu. Jangan terkeliru dengan pememulaan yang dinyatakan dalam BAB 2. Di sini, umpukan berkenaan dinamakan pememulaan kerana ia menentukan nilai permulaan . Di dalam contoh di atas, pembolhubah pememulaan ialah i, dan ia dimulakan pada nilai sifar.
Syarat adalah seperti yang dinyatakan dalam tajuk yang lalu. Ia menentukan had atau bilangan gelungan. Perubahan syarat biasanya ialah pernyataan yang digunakan untuk mengubah nilai Dalam contoh di atas (i++) nilai i ditokok dengan satu selepas setiap gelungan. Ringkasnya, apa yang dilakukan oleh pernyataan for ialah:
1. Lakukan pememulaan
2. Laksanakan pernyataan (atau set pernyataan)
3. Lakukan perubahan
4. Periksa syarat, jika syarat benar, ulang langkah 2
5. Tamat gelungan
Jadi, untuk contoh tadi, ianya adalah setara dengan contoh kedua gelungan while di bawah tajuk yang lalu.
3.3.4 Pernyataan Kawalan (pilihan) switch-case
Switch-case digunakan untuk menggantikan pernyataan-pernyataan if-else berganda yang berbentuk seperti berikut:
if ( a == nilai1 ) pernyataan1;
else if ( a == nilai2 ) pernyataan2;
else if ( a == nilai3 ) pernyataan3;
...
else pernyataan_n;
Ini adalah setara dengan bentuk pernyataan switch dan case berikut:
switch ( a )
{
case nilai1 : pernyataan1;
break;
case nilai2 : pernyataan2;
break;
case nilai3 : pernyataan3;
break;
...
default : pernyataan_n;
}
Dengan menggunakan pernyataan switch-case, aturcara akan lebih berstruktur dan memudahkan pengaturcaraan. Contohnya, andaikan pembolehubah int pilih ialah pilihan yang dimasukkan oleh seorang pengguna dari sebuah menu yang kita paparkan kepadanya. Kita boleh melaksanakan pilihan berkenaan dengan menggunakan pernyataan switch dan case seperti ini:
switch ( pilih )
{
case 1 : fungsi_pilihan1();
break;
case 2 : fungsi_pilihan2();
break;
case 3 : fungsi_pilihan3();
break;
...
default : printf("\n Tiada dalam pilihan");
}
Jika beberapa pernyataan hendak diletakkan dalam sesuatu case tertentu, ia boleh diletakkan tanpa memerlukan pembuka dan penutup blok ( { dan } ). Contohnya:
case nilai_k :
pernyataan_k1;
pernyataan_k2;
pernyataan_k3;
...
pernyataan_kn;
break;
Biasanya, urutan pernyataan dalam sesuatu case tertentu ditamatkan dengan pernyataan break. Dengan adanya break, perlaksanaan arahan akan tamat dan keluar daripada struktur switch-case berkenaan. Jika break tidak diletakkan, seperti contoh di bawah, maka pernyataan-pernyataan dalam case yang berikutnya juga akan dilaksanakan.
case 1 : printf("\n satu");
printf("\t SATU");
case 2 : printf("\n dua");
printf("\t DUA");
break
Dalam contoh di atas, jika case yang menepati syarat ialah 1, output yang dipaparkan ialah:
satu SATU
dua DUA
Perlaksanaan tidak terhenti setakat set pernyataan yang pertama sahaja kerana pernyataan break tidak diletakkan selepas printf("\t SATU");.
:: Contoh-contoh
:: 4. Fungsi
4 Fungsi
Sesuatu aturcara biasanya dipecahkan kepada beberapa modul untuk memudahkan penulisan. Modul-modul ini boleh jadi dalam bentuk fail-fail yang berasingan, subrutin-subrutin, fungsi-fungsi dan sebagainya. Subrutin-subrutin atau fungsi-fungsi ini boleh digunakan berkali-kali dalam aturcara dengan cara memanggilnya dari rutin utama. Subrutin-subrutin ini pula boleh memanggil subrutin yang lain, dan begitulah seterusnya. Aturcara
Subrutin 1
Subrutin 2
:
:
Subrutin n
Rajah 4.1: Aturcara Dipecahkan Kepada Beberapa Subrutin
Dalam C, semua subrutin dinamakan fungsi (function). Sebuah aturcara C bolehlah dikatakan sebagai satu set fungsi-fungsi yang berinteraksi antara satu dengan lain. Rutin utama bagi C ialah fungsi main() . Pelaksanaan aturcara akan bermula dari fungsi main() ini. Fungsi main() kemudiannya akan memanggil fungsi-fungsi lain bergantung kepada cara aturcara itu ditulis. Terdapat fungsi-fungsi yang telah tertakrif secara piawai seperti printf() , scanf() dan sebagainya. Pengaturcara hanya menggunakannya sahaja tanpa perlu mengetahui bagaimana ia dibina. Untuk fungsi-fungsi yang ditakrif sendiri, ianya diberi nama tertentu untuk memudahkan penggunaannya. Nama-nama fungsi dalam C adalah tidak terhad, tetapi mesti mempunyai bentuk sekurang-kurang seperti berikut
namafungsi()
Biasanya hanya huruf-huruf kecil digunakan kerana di dalam C huruf kecil dan besar adalah dibezakan. Aksara "garis bawah" boleh digunakan untuk menamakan fungsi yang panjang, seperti "pengiraan_polinomial()" dan sebagainya. Partameter atau argumen, iaitu nilai-nilai yang hendak dihantar ke satu-satu fungsi itu, (bergantung kepada takrifan fungsi tersebut) diletakkan di dalam tanda kurungan "(" dan ")". Contohnya sebuah fungsi yang telah ditakrif dalam perpustakaan untuk mengira punca kuasa dua sesuatu nombor float, dipanggil seperti ini:
punca = sqrt( 10 );
dengan punca adalah satu nombor float. Dalam contoh tadi, nombor 10 adalah argumen yang dihantar ke fungsi sqrt(), dan nilai yang dipulangkan oleh sqrt() diumpukkan kepada pembolehubah nilai. Sesuatu fungsi yang dibina itu tidak semestinya mempunyai parameter dan memulangkan nilai. Ianya boleh ditakrifkan tanpa berparameter dan tanpa memulangkan sebarang nilai; dan walaupun ianya dibina supaya memulangkan sesuatu nilai, nilai itu boleh diabaikan. Contohnya fungsi getch() yang tertakrif secara piawai untuk membaca satu aksara dari papan kunci dan memulangkan nilai aksara ini ke pemanggilnya. Terdapat dua cara untuk memanggil fungsi ini:
ch = getch(); atau getch();
Cara pertama adalah dengan anggapan pembolehubah ch adalah dari jenis char atau int ( getch() tidak berparameter). Di sini, aksara yang dimasukkan pada papan kunci akan diumpukkan kepada ch. Dalam cara yang kedua, getch() hanya akan menunggu sehingga satu aksara dimasukkan pada papan kunci. Walaupun ada data yang dipulangkan, ianya diabaikan. Jadi, fungsi dalam C boleh digunakan seperti tatacara (procedure) dalam Pascal atau subrutin dalam FORTRAN.
4.1 Pengisytiharan Fungsi
Fungsi yang memanggil satu fungsi lain mestilah mengetahui tentang kewujudan fungsi yang dipanggilnya itu. Jadi, sesuatu fungsi yang akan dipanggil oleh fungsi yang lain perlulah diisytiharkan. Biasanya pengisytiharan dilakukan di awal aturcara supaya fungsi berkenaan boleh dipanggil dari sebarang tempat dalam aturcara. #include
:
pengisytiharan fungsi
:
main()
{
...
}
Rajah 4.2: Pengisytiharan Fungsi Di Awal Aturcara
Terdapat dua kaedah untuk mengisytiharkan fungsi (atau disebut juga sebagai menulis prototaip bagi fungsi), iaitu kaedah "Klasik" dan kaedah "Modern". Kaedah "Modern" lebih baik dari segi kawalan ralat, walaupun bentuknya lebih panjang. Kedua-dua kaedah ini boleh digunakan dalam satu-satu aturcara dan kedua-duanya akan ditunjukkan di sini.
Bentuk pengisytiharan "Klasik" ialah seperti berikut:
jenis namafungsi();
dengan jenis ialah jenis data yang akan dipulangkan oleh fungsi, samada int, float, char dan sebagainya. Jika tiada nilai yang dipulangkan, jenis void digunakan. namafungsi() ialah nama bagi fungsi berkenaan seperti yang telah diterangkan.
PERHATIAN: Tanda ';' (semicolon) perlu diletakkan di hujung pengisytiharan seperti dalam contoh-contoh berikut:
int get_parms();
float kira_nisbah();
void output_nisbah();
Kaedah pengisytiharan "Modern" ialah seperti berikut:
jenis namafungsi( pinfo, pinfo, etc..);
jenis dan namafungsi() adalah sama seperti yang telah dinyatakan. Di sini terdapat komponen tambahan iaitu pinfo, iaitu maklumat (informasi) parameter. Maklumat parameter berbentuk seperti salah satu yang berikut:
jenis - memberikan jenis data parameter.
jenis namaparm - memberikan jenis data dan nama parameter.
... - (tiga noktah) digunakan sebagai parameter terakhir jika bilangan parameter adalah berubah-ubah.
Contoh:
void get_parms( float, float );
void get_parms( float *p1, float *p2 );
float kira_nisbah( int p1, int p2 );
Jelas di sini, kaedah "Modern" memberikan lebih banyak maklumat kepada kepada compiler dan juga kepada penulis aturcara sendiri. Dengan maklumat-maklumat tambahan ini, penyusun akan dapat mengesan sekiranya pengaturcara melakukan kesilapan dengan menghantar parameter yang salah kepada fungsi berkenaan. Terdapat beberapa pengecualian dari segi keperluan mengisytiharkan fungsi. Bagi fungsi-fungsi yang semua parameternya dan nilai yang dipulangkannya terdiri dari jenis int, ia tidak perlu diisytiharkan. Dengan kata lain, fungsi-fungsi yang tidak diisytiharkan akan dianggap sebagai fungsi-fungsi integer.
4.2 Pentakrifan Fungsi
Pentakrifan fungsi ertinya, secara ringkas, menulis kod-kod aturcara bagi fungsi yang telah diisytiharkan. Dengan kata lain, pentakrifan fungsi menentukan apa yang dilakukan oleh sesuatu fungsi itu. Biasanya pentakrifan ini diletakkan di bawah fungsi yang akan memanggilnya. Tetapi ia boleh diletak di mana sahaja kerana sesuatu fungsi yang telah diisytiharkan itu adalah tertakrif secara umum (global). Kaedah pentakrifan fungsi juga ada dua, iaitu kaedah "Klasik" dan kaedah "Modern", seperti dalam pengisytiharannya.main()
{
...
fungsi_1();
...
}
<-- panggilan fungsi
fungsi_1()
{
...
fungsi_2();
...
} <-- pengisytiharan
fungsi
<-- panggilan fungsi
fungsi_2()
{
...
} <-- pengisytiharan
fungsi
Rajah 4.3: Pentkrifan Fungsi Biasanya Diletakkan Di Bawah Fungsi yang Memanggilnya
Kaedah pentakrifan "Klasik" adalah seperti berikut:
jenis namafungsi( nama parameter... )
pentakrifan parameter...;
{ ....
pernyataan-pernyataan ...
....
}
jenis dan namafungsi adalah seperti yang telah diterangkan dalam pengisytiharan.
nama parameter adalah senarai nama parameter-parameter yang boleh dihantar kepada fungsi.
pentakrifan parameter ialah pentakrifan jenis data bagi parameter-parameter yang disenaraikan dalam nama parameter.
pernyataan-pernyataan ialah pernyataan-pernyataan C yang sah, termasuk panggilan ke fungsi-fungsi yang lain.
Contoh:
float kira_nisbah( p1, p2 )
int p1, p1;
{
...
}
Bentuk pentakrifan "Modern" adalah seperti berikut:
jenis namafungsi( pinfo, pinfo, ... )
{
...
}
Komponen pinfo menggantikan nama parameter dan pentakrifan parameter dalam pentakrifan "Klasik". Contoh pentakrifan "Modern" ialah seperti berikut:
float kira_nisbah( int p1, int p2 )
{
return p1/p2;
}
Perhatikan bahawa dalam kaedah "Modern", pengisytiharan menyerupai bahagian atas pentakrifan, kecuali dalam pengisytiharan terdapat tanda ';' (semicolon) dihujungnya (sebagai penamat kepada pernyataan).
4.3 Data Dalam Fungsi
Parameter-parameter sesuatu fungsi boleh digunakan untuk membuat pengiraan. Contohnya:
void jumlah( int p1, int p2 )
{
printf("\n %d + %d = %d", p1, p2, p1 + p2 );
}
Dengan menggunakan kata kunci return, data boleh dipulangkan kepada pemanggilnya:
int jumlah( int p1, p2 )
{
return( p1 + p2 );
}
Pembolehubah-pembolehubah boleh diisytiharkan dalam fungsi untuk memudahkan pengiraan:
int jumlah( int p1, p2 )
{
int jum;
jum = p1 + p2;
return (jum);
}
Pembolehubah yang diisytiharkan sebagai pembolehubah tempatan hanya boleh digunakan di dalam fungsi di mana ia diisytiharkan. Pembolehubah-pembolehubah boleh digunakan di mana saja dalam aturcara. Jadi, selain dari data yang dipulangkan dengan return, pembolehubah-pembolehubah umum juga boleh digunakan untuk memindahkan data dari dalam fungsi ke pemanggilnya. Satu cara lagi ialah dengan mengisytiharkan parameternya sebagai penunjuk. Ini ditunjukkan dalam BAB 5.
4.4 Menghadkan Capaian Fungsi
Di dalam Pascal, sesuatu fungsi boleh ditakrifkan di dalam satu fungsi lain untuk menghadkan capaiannya kepada fungsi berkenaan sahaja. Fungsi ini dinamakan fungsi bersarang (nested function). Di dalam C tidak terdapat fungsi bersarang. Capaian kepada sesuatu fungsi boleh dihadkan dengan meletakkan pengisytiharannya dalam dalam sebuah fungsi yang lain. Dengan ini, jika satu fungsi A diisytiharkan dalam fungsi B, maka hanya fungsi B sahaja yang boleh memanggil fungsi A. Akan tetapi kaedah ini tidak boleh digunakan bagi fungsi-fungsi "integer".
Satu cara untuk mengatasi masalah ini ialah dengan meletakkan fungsi-fungsi berkenaan serta takrifan-takrifannya dalam satu fail sumber yang lain dan menggunakan kata kunci static. Akan tetapi perbincangan tentang hal ini adalah melewati skop teks ini. Walaupun begitu, pengisytiharan fungsi di dalam fungsi ini sering digunakan kerana ia menjelaskan konteks penggunaan sesuatu fungsi yang terlibat terhadap fungsi yang lain; dan lagi, jika perlu, perubahan senang dilakukan.
:: Contoh-contoh
:: 5. Struktur dan Penunjuk
5. Struktur dan Penunjuk
5.1 Struktur
Struktur ialah satu set nilai-nilai yang boleh dirujuk secara berkelompok (kolektif). Nilai-nilai dalam set dikenali sebagai struktur dan boleh terdiri daripada jenis-jenis data yang berlainan. Untuk menggunakan pembolehubah dari jenis struktur, ia perlu ditakrifkan terlebih dahulu. Bentuk pentakrifan umumnya ialah:
struct namastruktur {
jenis1 nama_ahli_1;
jenis2 nama_ahli_2;
...
};
Contohnya:
struct tarikh {
int hari;
char bulan[3];
int tahun;
};
Contoh tadi membina sebuah struktur bernama tarikh yang boleh digambarkan seperti berikut:
tarikh
hari
integer
bulan
char
tahun
integer
Rajah 5.1: Struktur Tarikh
5.1.1 Pengisytiharan Pembolehubah
Untuk menggunakan struktur yang telah ditakrif, pembolehubah-pembolehubah untuknya perlu diisytihar seperti juga mengisytihar pembolehubah-pembolehubah untuk jenis-jenis int, char dan sebagainya. Untuk contoh struktur yang telah kita takrifkan tadi, pembolehubah-pembolehubah baginya boleh diisytiharkan seperti berikut:
struct tarikh hariini;
struct tarikh esok, semalam;
Pengisytiharan di atas menyediakan ruang-ruang untuk pembolehubah-pembolehubah hariini, esok dan semalam dari jenis struktur tarikh. Perhatikan bahawa kata kunci struct diperlukan sekali lagi, iaitu kali pertama ia diperlukan dalam pentakrifan, dan kali kedua ia diperlukan dalam pengisytiharan pembolehubahnya.
5.1.2 Umpukan Nilai Kepada Struktur
Untuk mengumpukkan data kepada ahli struktur, bentuknya ialah seperti ini:
nama_pembolehubah.nama_ahli = nilai;
Contohnya untuk pembolehubah hariini yang telah kita isytiharkan tadi:
hariini.hari = 19;
strcpy( hariini.bulan, "JUL" );
hariini.tahun = 2002;
Perhatikan bahawa untuk ahli bulan, kita gunakan fungsi strcpy() kerana ia adalah dari jenis string. Umpukan nilai di atas boleh kita gambarkan seperti meletakkan data-data dalam ruang pembolehubah struktur berkenaan.
tarikh
hari
19
bulan
JUL
tahun
2002
Rajah 5.2: Mengumpukkan Nilai Kepada Struktur
5.1.3 Pememulaan Struktur
Seperti pembolehubah-pembolehubah dari jenis lain, pembolehubah-pembolehubah dari jenis struktur juga boleh diumpukkan dengan nilai-nilai permulaan ketika ia disytiharkan. Umpukan seumpama ini yang dikkenali sebagai pememulaan adalah berbentuk seperti berikut:
static struct namastruktur nama_pembolehubah = { nilai1, nilai2, ... };
Contoh:
static struct tarikh hariini = { 2, "OGS", 2002 };
Perhatikan: Kata kunci static diperlukan dalam pememulaan struktur.
Contoh atrucara berikut ini menunjukkan bagaimana struktur ditakrif, dimulakan dan diumpukkan:
struct tarikh {
int hari;
char bulan[3];
int tahun;
};
main()
{
struct tarikh hariini = { 26, "SEP", 2002 };
int hariakhir = 31;
char bulanakhir = "DIS";
printf("\n Hari ini %d %s %d", hariini.hari,
hariini.bulan, hariini.tahun };
hariini.hari = hariakhir;
strcpy( hariini.bulan, bulanakhir );
printf("\n Hari terakhir tahun ini %d %s %d",
hariini.hari, hariini.bulan, hariini.tahun };
}
Aturcara 5.1: Pengisytiharan, Pememulaan dan Umpukan Kepada Struktur
Output bagi contoh aturcara di atas ialah:
Hari ini 26 SEP 2002
Hari terakhir tahun ini 31 DIS 2002
5.1.4 Operasi Ke Atas Struktur
Kita telah lihat bahawa ahli-ahli dalam struktur boleh diumpukkan dengan nilai tertentu. Jika kita ada dua pembolehubah dari jenis struktur yang sama, kita boleh lakukan umpukan secara terus, iaitu struktur kepada struktur. Contohnya jika hariini dan esok adalah dua pembolehubah dari jenis struktur tarikh yang telah kita takrifkan tadi, maka kita boleh umpukkan hariini kepada esok seperti berikut:
esok = hariini;
Ini adalah setara dengan:
esok.hari = hariini.hari;
strcpy( esok.bulan, hariini.bulan );
esok.tahun = hariini.tahun
Untuk operasi-operasi lain selain dari umpukan, ianya perlu dilakukan ahli demi ahli. Contohnya untuk operasi perbandingan, kita tidak boleh lakukan seperti ini:
if ( hariini == esok ) ... /* SALAH! */
Ianya mesti ditulis sepenuhnya seperti ini:
if ( ( hariini.hari == esok.hari ) &&
( strcmp( hariini.bulan, esok.bulan )==0 )&&
( hariini.tahun == esok.tahun ) )
...
Struktur boleh dijadikan parameter dalam fungsi dengan mengisytiharkannya dalam senarai parameter fungsi berkenaan. Selepas itu ia boleh digunakan seperti menggunakan data-data dari jenis lain dalam fungsi berkenaan.
5.2 Penunjuk (pointers)
Penunjuk ialah pembolehubah yang "menunjuk" kepada pembolehubah atau fungsi yang lain. Penunjuk bukan suatu nilai sebenar seperti int atau float, tetapi ianya ialah alamat bagi ingatan yang mengandungi nilai seperti int, float atau lain-lain. Jika kita ada satu pembolehubah tertentu, kita boleh dapatkan penunjuk baginya dengan meletakkan tanda (operator) '&' di hadapan nama pembolehubah itu. Contohnya untuk pembolehubah nombor dari jenis int, penunjuknya ialah &nombor.
&nombor --------> nombor
(penunjuk)-------> (integer)
Rajah 5.3: Penunjuk Bagi Integer
5.2.1 Pengisytiharan Pembolehubah
Pembolehubah dari jenis penunjuk diisytiharkan dengan meletakkan tanda '*' di hadapan namanya. Contohnya untuk mengisytihar penunjuk dari jenis int, kita tulis seperti ini:
int *pen_int;
Pembolehubah pen_int yang diisytiharkan di atas dinamakan penunjuk kepada int (integer). Untuk mendapatkan nilai integer yang ditunjukinya tanda '*' perlu digunakan seperti ini:
printf(";%d", *pen_int );
Jadi, secara ringkas, kita boleh hubungkan penunjuk dan nilainya seperti dalam rajah berikut:
PENUNJUK NILAI (int)
&nombor ---------> nombor
pen_int ---------> *pen_int
Rajah 5.4: Hubungan Antara Penunjuk dan Nilainya
5.2.2 Penggunaan Penunjuk
Kaedah penggunaan penunjuk seperti tadi adalah serupa untuk semua jenis pembolehubah seperti float, char dan sebagainya. Dalam contoh-contoh yang berikut ini, pembolehubah int akan digunakan tetapi kaedah yang serupa boleh digunakan untuk pembolehubah-pembolehubah dari jenis lain. Jika kita ada pengisytiharan dan umpukan seperti ini:
int *pen_int;
int nombor = 100;
maka nombor akan bernilai 100 dan pen_int akan bernilai nul iaitu tidak menunjuk kepada sebarang nilai. pen_int NUL
nombor 100
Jika dilakukan umpukan supaya pen_int menunjuk kepada pembolehubah nombor seperti ini (ingat bahawa penunjuk bagi nombor ialah &nombor) :
pen_int = &nombor;
maka kita boleh gambarkan keadaannya seperti ini: pen_int ¤ -------> nombor 100
Rajah 5.5: Mengumpukkan Nilai Kepada Penunjuk
Jika cuba mendapatkan nilai bagi *pen_int maka kita akan dapat 100, iaitu nilai nombor. Seterusnya kita boleh mengubah nilai nombor melalui pen_int:
*pen_int = 200;pen_int ¤ -------> nombor 200
Rajah 5.6: Mengubah Nilai Melalui Penunjuknya
Jadi, pernyataan *pen_int = 200; adalah setara dengan nombor = 200; dan penggunaan *pen_int dan nombor boleh ditukar-ganti. Akan tetapi penggunaan pen_int dan &nombor tidak boleh ditukar-ganti. &nombor memberikan alamat bagi nombor sahaja dan bukan nilai bagi pen_int. Jika kita ingin mengubah nilai pen_int kita perlu mengumpuknya secara langsung.
5.2.3 Penunjuk Sebagai Parameter
Dalam C, parameter fungsi yang dihantar adalah dalam bentuk nilai. Ini bermakna jika di dalam fungsi itu kita mengubah nilai parameter tersebut, pembolehubah sebenar yang dihantar di tempatnya tidak akan berubah. Ada ketikanya kita perlu mengubah nilai parameter yang dihantar. Contohnya untuk saling menukar nilai-nilai dalam dua pembolehubah. Andaikan kita menulis sebuah fungsi seperti berikut ini untuk tujuan tersebut:
void saling_tukar( int x1, int x2 )
{
int temp;
temp = x1;
x1 = x2;
x2 = temp;
}
Jika fungsi ini dipanggil dengan tujuan untuk saling menukar nilai dua pembolehubah integer seperti berikut ini, kita tidak akan berjaya.
int a = 100, b = 100;
saling_tukar( a, b );
Nilai-nilai asal a dan b masih kekal. Ini adalah kerana nilai-nilai yang saling ditukar dalam fungsi di atas hanyalah nilai-nilai yang sah di dalam fungsi itu sahaja. Kita perlu menukarkan pentakrifan (dan pengisytiharan) fungsi di atas supaya ia berfungsi seperti yang dikehendaki.
void saling_tukar( int *x1, int *x2 )
{
int temp;
temp = *x1;
*x1 = x2;
*x2 = temp;
}
Dalam fungsi yang baru ini, parameternya adalah penunjuk. Perhatikan bahawa nilai-nilai yang saling ditukar dalam fungsi itu masih lagi nilai sebenar, iaitu nilai-nilai yang ditunjuk oleh parameter-parameternya. Seterusnya cara panggilan fungsi ini juga berubah iaitu seperti berikut:
saling_tukar( &a, &b );
Perhatikan bahawa nilai-nilai yang dihantar kepada fungsi berkenaan ialah penunjuk. Di dalamnya nilai-nilai yang ditunjuk oleh penunjuk-penunjuk berkenaan akan saling ditukar. Nilai-nilai ini sebenarnya ialah nilai pembolehubah-pembolehubahnya. Jadi yang akan saling ditukar ialah nilai pembolehubah-pembolehubah itu sendiri. Kes di atas juga menjelaskan kenapa pembolehubah-pembolehubah yang digunakan dalam scanf() perlu disenaraikan dalam bentuk penunjuk.
5.2.4 Penunjuk Kepada Tatasusunan
Di dalam BAB 2 telah ditunjukkan cara mendapatkan data jenis string dengan mengisytiharkannya sebagai tatasusunan dari jenis aksara. Juga telah dinyatakan bahawa nama bagi string yang dibentuk itu adalah sebenarnya sebuah alamat atau penunjuk. Ini juga adalah benar untuk semua jenis tatasusunan, samada float, int atau yang lainnya. Nilai-nilai dalam sebuah tatasusunan boleh dicapai dengan menggunakan indeks. Seterusnya, oleh kerana namanya adalah sebuah penunjuk, maka dengan menambah tanda '*' di depan namanya, kita boleh mendapatkan nilai bagi tatasusunan berkenaan. Andaikan kita ada char rentet[10]; maka kita boleh mencapai aksara pertama dalam rentet dengan kedua-dua cara berikut:
char rentet[10];
char a, b;
a = rentet[0]; /* CARA 1 */
b = *rentet; /* CARA 2 */
Sekarang kita isytiharkan pula satu penunjuk dari jenis char (supaya serasi dengan tatasusunan char di atas) dan kita tunjukkan ia ke string berkenaan.
char *pen_char;
pen_char = rentet;
pen_char ¤ -------> rentet[0]
rentet[2]
:
rentet[9]
Rajah 5.6: Penunjuk Kepada Tatasusunan
Sekarang kita boleh pula mencapai aksara pertama dalam rentet dengan menulis begini:
a = *pen_char;
Seterusnya untuk mencapai aksara kedua melalui kita boleh menokok nilai pen_char:
pen_char++;
a = *pen_char;
Oleh kerana penunjuk bukan data jenis biasa seperti int, float, char dan sebagainya maka apabila ia ditokok nilainya tidak bertambah dengan satu tetapi ditambah dengan suatu nilai sebesar saiz datanya. Untuk penunjuk kepada aksara, nilainya ditokok dengan saiz satu aksara supaya ia menunjuk kepada aksara yang berikutnya dalam ingatan. Untuk kes di atas, oleh kerana pada asalnya ia menunjuk kepada aksara pertama dalam sebuah string, maka apabila ia ditokokkan, ia menunjuk kepada aksara kedua pula. Begitulah seterusnya apabila ia ditokokkan lagi untuk menunjuk kepada nilai ketiga, keempat dan seterusya. Ciri ini amat berguna jika kita ingin menyalin satu rentetan ke satu rentetan yang lain misalnya. Pelaksanaannya adalah lebih pantas berbanding dengan menggunakan indeks.
:: Contoh-contoh Aturcara C
Contoh-contoh Aturcara C
Setelah mempelajari bentuk aturcara C dan hanya beberapa pernyataan C, kita mungkin hadapi kesukaran dan gangguan dalam menulis aturcara C. Bab ini adalah ditujukan untuk mereka yang agak tidak begitu selesa dengan pengetahuan C mereka setakat ini. Bab ini akan membolehkan anda menulis aturcara C yang lengkap. Selain daripada itu ianya adalah bertujuan menyenangkan pembelajaran bahasa C menerusi contoh. Kita akan bermula daripada aturcara yang pendek, mudah dan lengkap; dan akan mendedahkan pernyataan C daripada yang mudah hinggalah kepada yang sukar dan kompleks. Anda adalah dinasihatkan bermula dari contoh yang pertama jika anda baru sahaja didedahkan kepada aturcara C.
Bagi anda yang sudah pernah menulis aturcara C maka bab ini mungkin perkara yang sudah anda ketahui dan bolehlah anda langkau beberapa contoh permulaan dalam bab ini ataupun melangkau kesemuanya sekali.
Bahagian A
Sebuah Aturcara C Yang Mudah
Pengisytiharan Pembolehubah
Gelung... Pernyataan For
Gelung... Pernyataan While
Gelung... Pernyataan Do-While
Mengeluarkan Tajuk Lajur
Menggunakan #Define Untuk Menentukan Format Output
Sebuah Jadual Punca Kuasa Dua
Menggunakan Nombor Nyata
Bahagian B
Membaca Satu Nombor Dan Mengeluarkan Kuasa Dua Dan Punca Kuasa Dua
Membaca Berulang Kali Daripada Papan Kunci
Penggunaan Fungsi
Input Nombor Negatif Untuk Punca Kuasa Dua
Kesimpulan Pernyataan Dari Contoh A1 Hingga B4
Bahagian C
Penggunaan Tatasusunan
Tatasusunan Dua Dimensi
Penggunaan Fungsi Dan Tatasusunan
Manipulasi Aksara Dan Rentetan C
Penggunaan Rentetan Dan Tatasusunan
Penggunaan Struktur
Teknik-teknik Pengaturcaraan C
Bab ini disediakan untuk menerangkan beberapa perkara yang boleh dikategorikan sebagai sebagai peringkat tinggi dalam penagaturcaraan C. Penerangan dibuat dengan cara yang mudah difahami dan disertakan dengan contoh-contoh yang dapat memberikan gambaran yang terbaik tentang perkara-perkara diperbincangkan. Pautan ke laman-laman web yang berkaitan juga disertakan di mana yang sesuai.
Peruntukan Ingatan Secara Dinamik
(Dynamic Memory Allocation)
Kadang-kala terdapat keperluan bagi pengaturcara untuk menentukan dengan secara khusus ruang ingatan yang diperuntukkan kepada pembolehubah-pembolehubah tertentu. Contohnya, katakanlah kita menulis sebuah aturcara yang melakukan pemprosesan data yang banyak dan besar. Ruang ingatan yang digunakan adalah terhad dan tidak mungkin dapat memuatkan semua data yang digunakan dalam satu-satu masa.
Jika peruntukan ruang ingatan dibiarkan sahaja dilakukan secara automatik oleh pengkompil, sudah tentu ruang ingatan yang semaksima mungkin akan dibuat olehnya. Kadang-kala, dengan cara ini, pengkompil tidak berjaya membuat peruntukan yang diperlukan kerana saiz ingatan yang ada pada sistem komputer yang digunakan adalah terhad. Jika pun berjaya diperuntukkan, penggunaan ingatan itu nanti adalah tidak cekap dan boleh menghasilkan aturcara yang terlalu besar dan kurang pantas.
Jika ruang ingatan boleh diperuntukkan (allocate) apabila diperlukan dan dibebaskan (free) apabila tidak lagi diperlukan, maka penggunan ruang ingatan boleh dioptimumkan. Aturcara yang terhasil akan lebih kecil dan lebih pantas.
Teknik seumpama ini, yang memperuntukkan dan membebaskan ruang ruang ingatan secara khusus dalam aturcara, dinamakan Dynamic Memory Allocation. Secara umum, peruntukan ingatan dinamik digunakan dalam kes-kes berikut:
Ingatan komputer terhad -- ruang yang sama digunakan secara perlbagai
Menggunakan ingatan komputer secara maksimum -- data dimasukkan ke dalam ingatan selagi mana ruang masih ada. Lebih besar ingatan, lebih banyak data yang boleh dimuatkan.
Fungsi utama yang telah dibentuk untuk teknik ialah malloc().
Fungsi malloc()
Andaikan kita mentakrifkan pembolehubah untuk menyimpan maklumat nombor pendaftaran dan tahun pengajian pelajar-pelajar seperti berikut:
struct maklumat {
int daftar;
int tahun;
};
Kita boleh memperuntukkan ruang ingatan untuk seorang pelajar seperti berikut:
#include /* diperlukan untuk menggunakan malloc() */
main()
{
struct maklumat *pelajar;
pelajar = malloc(sizeof *pelajar);
pelajar->daftar = 1001;
pelajar->tahun = 4;
}
Dalam aturacara di atas, ungkapan sizeof *pelajar digunakan untuk mendapatkan saiz yang sesuai bagi satu unit struct pelajar. Perhatikan penggunaan tanda * pada awalan pelajar kerana ianya ialah penunjuk.
Bagaimana jika kita tidak mempunyai cukup ruang ingatan untuk tujuan di atas? Fungsi malloc() mengembalikan nilai null jika ruang ingatan tidak dapat diperuntukkan. Jadi, aturcara di atas boleh dikembangkan menjadi:
#include
#include /* diperlukan untuk menggunakan malloc() */
struct maklumat {
int daftar;
int tahun;
};
main()
{
struct maklumat *pelajar;
pelajar = malloc(sizeof *pelajar);
if (pelajar == NULL)
printf("Ruang ingatan telah habis!!!");
else {
pelajar->daftar = 1001;
pelajar->tahun = 4;
}
}
