1) Jurnal berkaitan dengan proses pengajaran dan pembelajaran pengaturcaraan
komputer


A CONSTRUCTIVIST APPROACH TO OBJECT-ORIENTED DESIGN AND PROGRAMMING

Said Hadjerrouit

Kajian ini menerangkan mengenai rangka kerja pedagogi dengan menggunakan kaedah konstruktivisme dalam pengajaran rekabentuk berorientasikan objek dan pengaturcaraan . Keperluan untuk membangunkan metod pengajaran konstruktivisme disedari kerana pengajaran menggunakan kaedah tradisional tidak lagi berkesan dalam proses pengajaran dan pembelajaran.

Pembelajaran pendekatan berorientasikan objek dirasakan sukar oleh kebanyakan pelajar "novis", kerana ia lebih asbtrak berbanding dnegan pendekatan pengajaran biasa. Kaedah pengajaran ini memerlukan pelajar menukar cara berfikir dan cuba untuk berfikir dengan lebih mendalam, terutamanya apabila menganalisis dan merekabentuk kepada pkoding dan apabila ingin menyelesaikan masalah.

Dalam kajian ini, ia menekankan tiga jenis pengetahuan dimana ia relevan untuk pendekatan berorientasikan objek iaitu konsep berorientasikan objek dimana objek, kelas, pengabstrakan, warisan, polimortisme, pengikatan, dinamik dan kemodulan. Konsep ini boleh digunakan bagi memahami situasi bermasalah, untuk merekabentuk model berorientasikan objek dan untuk memilih kaedah yang sesuai untuk pelaksanaan. Tambahan pula, pelajar perlu belajar untuk menggunakan konsep berorientasikan objek dengan menggabungkan objek dalam bentuk yang boleh digunakan semula, serentak dan interaktif.

Kemudian, ia memerlukan bahasa berorientasikan objek untuk melaksanakan konsep berorientasikan objek. Pada masa sekarang, Java merupakan bahasa berorientasikan objek yang paling popular. Akhirnya, kita memerlukan pelbagai situasi masalah dimana kita dapat meningkatkan pengetahuan masalah spesifik yang relevan dan memenuhi keperluan konsep berorientasikan objek.

Implikasi ke atas proses pengajaran dan pembelajaran pengaturcaraan komputer adalah kaedah pengajaran ini lebih sesuai diajar kepada pelajar di institusi pengajian tinggi dimana mereka sepatutnya diterapkan dengan sikap suka meneroka dan belajar sendiri dan melalui kawan tanpa mengharapkan 100% pertolongan pensyarah.



TEACHING ROLES OF VARIABLES IN ELEMENTARY PROGRAMMING COURSES


Marja Kuittinen & Jorma Sajanemi


Pengaturcaraan komputer adalah teknik yang sukar bagi kebanyakan pelajar dan kaedah serta teknik baru untuk membantu pelajar novis mempelajari pengaturcaraan adalah diperlukan. Kajian ini menerangkan mengenai peranan pemboleh ubah sebagai konsep baru yang boleh digunakan untuk membantu dalam pembelajaran dan memberikan arahan terperinci berkenaan dengan teknik untuk mempersembahkan peranan kepada novis. Kaedah ini adalah berdasarkan kepada teori pembelajaran sekarang dan mereka perlu menggunakan dalam eksperimen bilik darjah untuk membezakan kaedah pengajaran tradisional dengan pengajaran berasaskan peranan.

Satu eksperimen telah dilakukan ke atas penggunaan peranan dalam pengajaran. Seramai 91 orang pelajar semester pertama dibahagikan kepada tiga kumpulan yang diajar menggunakan kaedah pengajaran yang berbeza iaitu melalui kaedah tradisional, menggunakan peranan melalui kursus dan menggunakan peranan dengan menggunakan animasi dalam latihan. Hasil dapatan kajian menunjukkan penggunaan peranan dan animasi amat membantu pelajar dalam memahami subjek pengaturcaraan.

Implikasi terhadap proses pengajaran dan pembelajaran pengaturcaraan komputer adalah para pensyarah atau tenaga pengajar seharusnya menggunakan kaedah pengajaran yang mudah difahami oleh pelajar kerana telah diketahui umum bahawa pengaturcaraan adalah suatu bidang yang amat sukar untuk dikuasai.


LEARNING STYLES AND PERFORMANCE IN THE INTRODUCTORY PROGRAMMING SEQUENCE

Lynda Thomas, Mark Ratcliffe, John Woodbury and Emma Jarman



Kajian ini melaporkan mengenai implikasi terhadap gaya pembelajaran ke atas tahap pencapaian pelajar dalam subjek pengenalan pengaturcaraan dan bagaiman untuk mengatasi masalah gaya pembelajaran yang berbeza.

Pelajar telah diberikan ujian gaya pembelajaran dan kemudian gaya pembelajaran yang digunakan dibandingkan dengan tahap pencapaian mereka dalam peperiksaan dan latihan pengaturcaraan. Hasil dapata ujian tersebut menunjukkan bahawa terdapat perbezaan pencapaian yang ketara antara kumpulan pelajar tersebut.

Keputusan akan membawa kepada dua kemungkinan, antaranya adalah gaya pembelajaran pelajar adalah bersesuaian untuk mempelajari pengaturcaraan. Kajian ini empat gaya pembelajaran antaranya adalah :
  • The Myers-Briggs Type Indicator (MBTI) yang mengkategorikan pelajar berdasarkan kepada kedudukan dan pencapaian mereka.
  • Kolb's Learning Style Model pula mengklasifikasikan individu berpandukan kepada skala untuk pengalaman konkrit atau konsep abstrak (bagaimana maklumat diambil) dan eksperimen aktif atau pemerhatian reflektif.
  • The Herrmann Brain Dominance Instrument (HBDI) pula menggunakan teori tentang fungsi otak untuk mengklasifikasikan pembelajaran pelajar menggunakan otak kanan atau otak kiri.
  • The Felder Silverman Learning Style Model mengklasifikasikan pelajar sebagai pelajar yang aktif dan menggunakan semua deria dalam proses pengajaran dan pembelajaran.
Implikasi ke atas proses pengajaran dan pembelajaran subjek pengaturcaraan komputer adalah pelajar seharusnya didedahkan dengan gaya pembelajaran supaya pelajar belajar meneroka tanpa bergantung sepenuhnya kepada pensyarah.


TEACHING AND LEARNING PROGRAMMING WITH A PROGRAMMING BY EXAMPLE SYSTEM

Nicolas Guibert & Patrick Girard


Kajian ini menerangkan mengenai proses pembelajaran pengaturcaraan yang pada kebiasaanya melibatkan penerangan algoritma statik dan abstrak dalam bahasa yang berkaitan. Programmimg by Example adalah algoritma tidak diterangkan secara abstrak, tetapi didemonstrasikan dalam contoh yang konkrit. Semenjak dari itu, "programming by example" dan teknik mencabar yang lain seperti metafora dan dunia mikro digunakan dalam setiap eksperimen untuk pengaturcara novis.

Kajian ini juga membincangkan mengenai gaya pembelajaran dan model diktatik yang berhubungan dengan paradigma setiap pengaturcaraan; perbezaannya adalah melibatkan gaya pembelajaran pelajar, dan kajian ini akan cuba menerangkan paradigma pengaturcaraan boleh digabungkan untuk memberikan perekabentuk sokongan yang lebih baik dalam proses pengaturcaraan.



2) Buku yang berkaitan dengan Pengaturcaraan


INTRODUCTION TO C PROGRAMMING - A MODULAR APPROACH

DAVID M.COLLOPY (2003)


BAB 1 – KONSEP ASAS

Bab ini menerangkan mengenai pengenalan kepada komputer dan pengaturcaraan dimana komputer digunakan dalam pelbagai urusan dalam kehidupan seharian dan atucara pula berperanan dalam memberikan arahan dan seterusnya berkomunikasi dengan komputer.

Pengaturcaraan bermaksud perancangan, penjadualan atau pelaksanaan sesuatu tugas atau peristiwa. Pengaturcaraan dalam bidang komputer ialah merencana suatu alat komputer agar ia dapat melakukan tugas tertentu. Oleh itu pengaturcaraan komputer boleh didefinisikan sebagai suatu proses merancangn satu jujukan arahan untuk dilaksanakan oleh komputer. Manakala aturcara komputer pula ialah jujukan arahan yang menggariskan langkah-langkah yang akan dilaksanakan oleh komputer.

BAB 2 – ALGORITMA

2.1 Pengenalan kepada algoritma

Algoritma ialah suatu tatacara langkah demi langkah untuk menyelesaikan suatu masalah dalam masa yang terhingga. Langkah terhingga bermaksud langkah ini mempunyai kesudahan yang akan berakhir . Pada setiap langkah, tindakan yang akan dilaksanakan seterusnya harus dapat ditentukan secara unik oleh arahan dan data yang diperolehi pada waktu itu.

Contoh pembinaan algoritma (membakar kek)

  1. Mula
  2. Panaskan ketuhar pada 240C
  3. Sediakan acuan
  4. Pukul marjerin bersama telur
  5. Campurkan telur dan esen vanilla
  6. Masukkan tepung ke dalam acuan
  7. Tuang ke dalam acuan
  8. Masukkan ke dalam ketuhar
  9. Tamat

Sekiranya langkah dalam contoh diatas tidak dilaksanakan mengikut jujukan, kita tidak akan berjaya menghasilkan sebiji kek. Langkah pertama untuk merumuskan algoritma ialah memahami masalah. Kita perlu mengenalpasti langkah utama yang menunjukkan gambaran keseluruhan penyelesaian masalah.

2.2 Perwakilan Algoritma

Algoritma bersifat konseptual ataupun abstrak. Rajah dan gambar merupakan cara terbaik untuk mewakilkan sesuatu algoritma. Terdapat dua unsur penting dalam suatu perwakilan iaitu sintaks yang merujuk kepada perwakilan dan semantic yang merujuk kepada konsep yang ingin diwakilkan. Terdapat dua perwakilan algoritma yang popular dan biasa digunakan oleh pengaturcara. Perwakilan algoritma yang dimaksudkan ialah carta alir dan kod pseudo.

2.3 Kaedah Pembinaan Algoritma

Kaedah pembinaan algoritma akan dibincangkan berpandukan kepada garis panduan berikut:

  1. Mengenalpasti input dan output bagi sesuatu masalah

- Proses untuk mendapatkan suatu penyelesaian bagi kebanyakan masalah lazimnya terdiri daripada tiga peringkat, iaitu mendapatkan input, melakukan pemprosesan ke atas input dan memaparkan output atau keputusan yang diperolehi.

  1. Mengenalpasti dan menyenaraikan submasalah. Setiap satu mesti diselesaikan untuk mendapatkan keputusan yang dikehendaki.

- Seringkali masalah yang kita temui bukanlah merupakan masalah yang dapat diselesaikan dengan mudah. Untuk menyelesaikan masalah yang kompleks, kita perlu memecahkankannya kepada submasalah yang lebih kecil. Setiap submasalah mesti diselesaikan untuk mendapatkan keputusan yang dikehendaki.

  1. Untuk setiap submasalah, kenalpasti dan senaraikan langkah yang mesti dilakukan untuk menyelesaikannya.

- Untuk setiap submasalah, kita perlu mengenalpasti dan menyenaraikan langkah-langkah yang mesti dilakukan untuk menyelesaikannya. Kita akan membincangkan kaedah untuk menyelesaikan submasalah dengan merujuk kepada contoh masalah nombor sempurna. Kaedah ini dipanggil penghalusan langkah demi langkah.

BAB 3 – PENGENALAN KEPADA PENGATURCARAAN C

3.1 Bahasa Pengaturcaraan

Pengaturcara menggunakan bahasa pengaturcaraan untuk menulis aturcara komputer. Walaupun terdapat pelbagai jenis bahasa pengaturcaraan, yang paling popular dan sering digunakan ialah bahasa aras tinggi. Untuk memahami kelebihan bahasa paras tinggi berbanding dengan bahasa lain, kita perlu memahami bagaimana computer berkomunikasi. Bahasa paras tinggi membolehkan pengaturcara menulis satu arahan sahaja untuk melaksanakan tugas tertentu seperti dalam contoh mengira gaji kasar. Kodnya boleh terus ditulis dalam bentuk persamaan :

Gajikasar = Gajipokok + GajiLebihMasa

3.2 Sejarah Bahasa C

Bahasa C muncul daripada dua bahasa pengaturcaraan iaitu BCPL dan B. BCPL dibangunkan oleh Martin Richards sebagai bahasa untuk menulis sistem pengoperasian dan pengkompil pada tahun 1967. B pula dibangunkan oleh Ken Thompson untuk membangunkan sistem pengoperasian UNIX di Bell Laboratories pada tahun 1970an. C bermula daripada bahasa B dan dibangunkan oleh Ritchie di Bell Laboratories pada tahun 1972. Ia kemudiannya digunakan untuk membangunkan sistem pengoperasian UNIX.

Terdapat pelbagai jenis variasi bahasa C yang dibangunkan oleh pembangun yang berbeza. Untuk membolehkan atur cara dalam bahasa C bersifat mudah alih, kita memerlukan suatu piawai. American National Standards Institute (ANSI) memberikan C piawai yang dipanggil ANSI C.

3.3 Asas kepada Sekitaran C

Pada amnya, semua sistem C terdiri daripada tiga bahagian iaitu sekitarannya, bahasanya dan pustaka piawai C (standard libraries). Sekitaran menerangkan tentang kaedah untuk menulis dan melaksanakan suatu atur cara C. Bahasa pula merupakan peraturan mengenai sintaks atau perwakilan algoritma dalam bahasa C. pustaka piawai C terdiri daripada fungsi-fungsi bantuan yang harus disediakan untuk membolehkan suatu aturcara C dilaksanakan pada mana-mana mesin. Contoh fungsi yang terdapat dalam pustaka piawai ialah fungsi matematik seperti sin () dan sqrt (), fungsi untuk menginput dan mencetak, fungsi untuk keperluan grafik dan lain-lain lagi.

3.4 Contoh Aturcara C

/* Atur cara ini mencetak ucapan

Selamat Datang Ke UKM */

#include

void main (void) {

printf (“Selamat Datang ke UKM!\n”);

}

Aturcara diatas akan dijelaskan baris demi baris. Ini bertujuan untuk memberi kefahaman tentang apa yang dilakukan oleh pengkompil terhadap setiap baris arahan dalam aturcara.

/* Atur cara ini mencetak ucapan

Selamat Datang Ke UKM */

Dua baris pertama atur cara merupakan komen. Teks yang terkandung diantara symbol /* dan */ dianggap sebagai komen dan tidak akan diproses oleh pengkompil. Komen merupakan dokumentasi yang bertujuan untuk memberitahu pembaca atur cara mengenai tugas yang dilakukan oleh atur cara tersebut.

#include

Baris yang bermula dengan symbol # dipanggil arahan prapemproses. Arahan #include menyebabkan prapemproses memasukkan satu salinan fail pengepala (header file) piawai stdio.h ke dalam atur cara pada baris dimana arahan tersebut ditemui.

Fail pengepala ini dibekalkan oleh sistem C. kurungan <…> menunjukkan fail ini boleh ditemui di tempat biasa. Tempat biasa ini bergantung kepada sistem komputer yang digunakan. Dalam sekitaran UNIX, lazimnya dinyatakan dalam fail .profile. dalam sekitaran DOS, ia dinyatakan dalam fail autoexec.bat.

void main (void)

Ini merupakan pengisytiharan fungsi utama. Setiap aturcara mempunyai fungsi bernama main () dimana perlaksanaan arahan bermula. Tanda kurungan selepas main () dimana perlaksanaan arahan bermula. Tanda kurungan selepas main() memberitahu pengkompil bahawa ia adalah suatu fungsi.

Perlaksanaan simpanan void yang kedua menunjukkan bahawa fungsi main() tidak menerima apa-apa data daripada sistem pengoperasian.

{……………….}

Kurungan berlekuk { menunjukkan permulaan badan fungsi main(). Kurungan berlekuk } menandakan tamat atur cara. Kedua-dua simbol ini setara dengan mula dan tamat dalam algoritma yang telah dibincangkan dalam bab 2.

printf (“Selamat Datang ke UKM!\n”);

Sistem C mengandungi suatu pustaka piawai yang digunakan dalam aturcara. Fungsi printf() ialah fungsi dalam pustaka C yang mencetak output pada paparan computer. Perhatikan bahawa kita telah memasukkan fail pengepala stdio.h yang memberikan maklumat tentang takrifan fungsi printf().

Fungsi printf() ini menerima pemalar rentetan “selamat datang ke UKM!\n”. Pemalar rentetan adalah satu siri aksara yang didahului dan diakhiri dengan tanda kutip berganda “….”. Rentetan ini menunjukkan output yang hendak dicetak pada paparan. Dua aksara selepas rentetan iaitu ‘\n’ dibaca sebagai condong belakang (backslash n). Aksara istimewa ini mewakili aksara yang dipanggil baris baru. Aksara ini tidak dicetak. Tujuannya ialah untuk meletakkan kursor di permulaan baris yang baru.

BAB 4 – PEMBOLEHUBAH DAN STRING

4.1 Pemboleh ubah

Pemboleh ubah ialah suatu objek yang mempunyai ciri-ciri tertentu. Pembolehubah diisytiharkan dipermulaan suatu blok aturcara yang perlu menggunakan pemboleh ubah tersebut. Untuk mengisytiharkan pembolehubah, kita perlu mengenalpasti ciri- ciri berikut:

- Setiap pembolehubah mempunyai nama

- Setiap pembolehubah mempunyai jenis

- Setiap pembolehubah mewakili suatu nilai

Jenis pembolehubah

Pembolehubah boleh mewakili berbagai jenis data. Perhatikan jadual jenis data asas dibawah. Jenis data ini seringkali digunakan dalam aturcara C.

Takrifan

Jenis

Char

Aksara

Int

Integer

Float

Nombor nyata

Double

Nombor nyata dengan kepersisan tinggi

Apabila suatu pembolehubah mempunyai jenis data tertentu bermakna pembolehubah tersebut dapat mewakili data daripada jenis tersebut. Bagi pembolehubah berjenis integer, C menganggapkan hanya nombor bulat sahaja boleh mewakili nilai tersebut. Terdapat juga jenis data tambahan yang menggunakan penerang (qualifier). Unsigned, signed, short, long, unsigned short, signed short, unsigned long dan signed long merupakan penerang yang wujud dalam C.

4.2 Pengisytiharan Pemboleh Ubah

Pembolehubah digunakan untuk menyimpan data input dan hasil pengiraan atau manipulasi logik. Nilai yang disimpan oleh pembolehubah boleh berubah sepanjang perlaksanaan atur cara. Pembolehubah yang berbeza digunakan untuk menyimpan jenis data yang berbeza. Oleh itu dalam pengisytiharan pembolehubah, perlu dinyatakan jenis data yang harus disimpan oleh pembolehubah tersebut.

4.3 Jenis Data

Jenis data asas boleh dikategorikan kepada dua kelas iaitu aksara dan numeric. Aksara diwakili oleh jenis data char. Numeric pula terdiri daripada jenis data int, float dan double. Kenapa perlu ada lebih daripada datu jenis numeric jika kita boleh mewakilkan integer dan nombor nyata dengan hanya menggunakan jenis data double? Ada dua sebab utama mengapa terdapat lebih daripada satu jenis data numerik. Yang pertama ialah kerana pada kebanyakan computer, perlaksanaan operasi yang melibatkan integer lebih cepat berbanding dengan nilai nyata iaitu float atau double. Sebab yang kedua ialah operasi integer lebih tepat berbanding dengan operasi nyata kerana ketepatan data titik apungan berkurangan apabila berlaku pembundaran.


BAB 5 – INPUT DAN OUTPUT

5.1 Fungsi printf()

Fungsi ini menghantar data kepada peranti output (biasanya paparan video) mengikut format yang diberikan. Sebagaimana terjemahan namanya, fungsi ini kadangkala disebut sebagai fungsi untuk mencetak. Kita perlu mengambil ingatan bahawa mencetak yang dimaksudkan disini adalah mencetak pada paparan video dan bukannya pada pencetak.

Format fungsi printf() adalah berbeza sedikit berbanding dengan kenyataan C yang lain. Bentuk umum fungsi printf() adalah seperti berikut:

printf(format_output [, senarai_nilai]);

perhatikan bahawa fungsi printf() memerlukan format_output. Ini merupakan suatu rentetan yang menentukan bentuk output bagi nilai-nilai yang disenaraikan. Senarai_nilai pula boleh terdiri daripada pembolehubah pemalar, ungkapan atau gabungan kesemuanya.

5.2 fungsi scanf()

Fungsi scanf() hanya akan memaparkan output pada paparan. Dalam bahagian ini, kita akan melihat bagaimana aturcara dapat menerima input dengan fungsi scanf(). Fungsi ini membenarkan kita berinteraksi dengan atur cara yang ditulis. Input adalah daripada papan kekunci. Nilai yang diinput dipadankan dengan pembolehubah berdasarkan format yang diberikan. Seterusnya nilai yang diwakili oleh pembolehubah tersebut dapat digunakan dalam aturcara yang biasanya menghasilkan output. Perhatikan bentuk umum fungsi scanf():

Scanf(format_input [, senarai_pemboleh_ubah]);

Fungsi scanf() memerlukan format_input yang memerlukan rentetan aksara yang mementukan bentuk rentetan input. Rentetan ini hampir sama dengan format_output dalam fungsi printf().


BAB 6 – OPERATOR DAN UNGKAPAN

6.1 Operator Aritmetik Asas

Konsep asas operator aritmetik bahasa C adalah sama dengan operator aritmetik yang dipelajari dalam matapelajaran matematik di sekolah. Jadual dibawah menunjukkan simbol operator aritmetik C.

Simbol

Makna

+

tambah

-

tolak

*

darab

/

bahagi

%

modulo

Kebanyakan simbol diatas berkelakuan sama seperti operasi aritmetik biasa. Operator tambah, tolak, darab, dan beberapa kes operasi bahagi memberi hasil yang sama seperti operator aritmetik biasa.

6.2 Ungkapan Aritmetik

Ungkapan aritmetik C merupakan gabungan satu atau lebih operasi aritmetik. Ungkapan ini dapat mewakili ungkapan algebra. Berikut merupakan contoh ungkapan aritmetik bahasa C.

-----------------------------------------------------------------------------------------------------------------

5 + 6

14 * 5 * 2

21 – 6 + 7 * 4 / 2

7.5 * (2.0 – 4.52)

-----------------------------------------------------------------------------------------------------------------

6.3 operator hubungan

Operator aritmetik digunakan untuk mewakilkan rumus aritmetik bagi menyelesaikan masalah yang berkaitan dengannya. Selain daripada operator aritmetik, C juga menyediakan operator yang digunakan untuk perbandingan data yang dikenali sebagai operator hubungan.

Tugas operator ini adalah untuk membandingkan nilai dua ungkapan, sama ada sama dengan, tidak sama dengan, kurang daripada, lebih daripada dan sebagainya. Jadual berikut menyenaraikan simbol operator hubungan tersebut dan maknanya.

Operator

Makna

<

Kurang daripada

<=

Kurang daripada atau bersamaan dengan

>

Lebih daripada

>=

Lebih daripada atau bersamaan dengan

==

Bersamaan dengan

!=

Tidak bersamaan dengan

Operator ini mempunyai 2 operan yang boleh terdiri daripada pemboleh ubah, pemalar atau gabungan keduanya. Ungkapan hubungan terbentuk daripada satu operasi hubungan. Ungkapan hubungan akan mengembalikan nilai 1 jika benar atau nilan 0 jika palsu. Contoh ungkapan hubungan dan nilainya ditunjukkan dalam jadual dibawah.

Ungkapan hubungan

Nilai

6 <>

1

7 == 5

0

6 != 5

1

9 >= 5

1



BAB 7 – STRUKTUR KAWALAN PILIHAN

Struktur kawalan pilihan mewakili struktur pemilihan dalam algoritma, manakala struktur ulangan pula mewakili struktur pengulangan dalam algoritma. Dalam bab ini kita akan melihat struktur kawalan pilihan menggunakan kenyataan if, switch dan break.

7.1 kenyataan if

Kenyataan if digunakan untuk mewakili struktur pilihan, struktur pilihan membolehkan kita memilih dan melaksanakan hanya satu daripada beberapa pilihan berdasarkan kepada syarat tertentu. Dalam bahasa C, kita menggunakan ungkapan hubungan atau ungkapan mantik untuk mewakili syarat pilihan.

Kita telah melihat dimana struktur pemilihan dalam algoritma dibahagikan kepada 3 bentuk utama iaitu pemilihan tunggal, dwipemilihan dan multipemilihan. Kenyataan if juga dapat dibahagikan kepada 3 bentuk yang setara.

Bentuk 1 (if)

Bentuk yang pertama adalah setara dengan pemilihan tunggal. Perhatikan sintaksnya :

if ( ungkapan)

kenyataan;

kenyataan akan dilaksanakan hanya jika nilai ungkapan bukan sifar (benar). Ungkapan boleh terdiri daripada ungkapan hubungan atau ungkapan mantik yang mempunyai nilai benar atau palsu.

Bentuk 2 (if-else)

Bentuk kedua kenyataan if adalah setara dengan struktur dwipemilihan. Kita menggunakan kenyataan if-else. Perhatikan sintaksnya:

if (ungkapan)

kenyataan -1;

else

kenyataan -2;

jika nilai ungkapan adalah bukan sifar (benar) maka kenyataan-1 akan dilaksanakan. Sebaliknya jika nilai ungkapan adalah sifar (palsu) maka kenyataan-2 pula akan dilaksanakan. Kenyataan-1 dan kenyataan-2 juga boleh terdiri daripada kenyataan majmuk (yang diapit oleh tanda { dan } ).

Bentuk 3 (if-else-if)

Bentuk ketiga kenyataan if adalah setara dengan struktur multipemilihan. Kita menggunakan kenyataan if-else-if. Perhatikan sintaksnya:

if (ungkapan-1)

kenyataan-1;

else if (ungkapan-2)

kenyataan-2;

else

kenyataan-3;


kenyataan-1 akan dilaksanakan jika nilai ungkapan-1 adalah bukan sifar(benar). Kenyataan-2 pula akan dilaksanakan jika nilai ungkapan-1 adalah sifar(palsu) dan nilai ungkapan-2 adalah bukan sifar(benar). Kenyataan-3 pula akan dilaksanakan jika ungkapan-1 dan ungkapan-2 bernilai sifar(palsu).

7.2 kenyataan switch dan break

Kenyataan switch dan break digunakan untuk memilih satu pilihan sahaja daripada beberapa pilihan yang wujud. Kenyataan ini sangat berguna apabila pilihan adalah berdasarkan nilai bagi satu pembolehubah atau ungkapan mudah. Nilai bagi ungkapan ini boleh terdiri daripada jenis int dan char, tetapi tidak daripada jenis float. Perhatikan sintaks bagi kenyataan switch dan break:

-----------------------------------------------------------------------------------------------------------------

switch (ungkapan) {

case ungkapan-1 :

kenyataan-1;

break;

case ungkapan-2:

kenyataan-2;

break;

:

case ungkapan-m:

kenyataan-m;

break;

default :

kenyataan-n;

break;

}

-----------------------------------------------------------------------------------------------------------------

Ungkapan pada kenyataan switch akan dinilai dan cuba dipadankan dengan satu daripada ungkapan-1 hingga ungkapan-m pada case. Jika dapat dipadankan, kenyataan untuk case berkenaan akan dilaksanakan dan diikuti dengan kenyataan break. Kenyataan break ini akan membawa kawalan keluar daripada kenyataan switch tanpa melaksanakan kenyataan case berikutnya. Jika ungkapan tidak dapat dipadankan, dan wujud kenyataan default maka kenyataan-n dilaksanakan. Jika tidak wujud kenyataan default maka kenyataan-n dilaksanakan. Jika tidak wujud kenyataan default kawalan akan keluar daripada kenyataan switch.



BAB 8 STRUKTUR KAWALAN ULANGAN


Struktur pengulangan membolehkan kita mewakili masalah yang berulang-ulang sehingga syarat tertentu dipenuhi. Struktur pengulangan ini dapat diterjemahkan kepada aliran logic atur cara sebagai struktur kawalan ulangan. Dalam bahasa C, struktur kawalan ulangan dapat ditulis sebagai kenyataan for,while, dan do-while.

8.1 kenyataan for

Kenyataan for membolehkan kita mengulangi bahagian atur cara tertentu sehingga bilangan ulangan yang ditentukan. Ini bermakna semasa kita menulis atur cara, kita telah dapat menentukan bilangan ulangan yang diperlukan. Setiap kali bergelung, kenyataan for membilang bilangan ulangan sehingga mencapai bilangan ulangan yang ditentukan. Setelah itu kenyataan berikut selepas kenyataan for dilaksanakan.

Bentuk umum kenyataan for adalah seperti berikut:

for (awalan; ujian; pengemaskinian)

kenyataan;

awalan merupakan ungkapan yang mengumpukkan nilai awal kepada pembilang gelung. Ujian pula adalah syarat akhir gelungan yang menentukan sama ada untuk terus bergelung atau sebaliknya. Biasanya ujian ditulis sebagai ungkapan hubungan bagi pembilang gelung. Pengemaskinian merupakan satu ungkapan untuk mengemaskinikan pembilang gelung.

Langkah perlaksanaannya adalah seperti berikut:

  1. Pembilang gelung diawalkan dengan ungkapan awalan.
  2. Berdasarkan nilai pembilang gelung, ungkapan ujian dinilai.
  3. Jika nilai tersebut benar, maka kenyataan akan dilaksanakan.
  4. Kemudian ungkapan pengemaskinian pembilang gelung dilakukan.
  5. Langkah 2 hingga 4 akan berulang sehingga ungkapan ujian menghasilkan nilai palsu.
  6. Gelung tamat.

8.2 kenyataan while

Strukutur kawalan pengulangan yang kedua adalah gelung berkawalkan syarat. Gelung ini dapat ditulis sebagai kenyataan while. Kenyataan while dapat menghasilkan gelung yang lebih umum berbanding kenyataan for. Gelung while akan bergelung sehingga syarat tertentu dicapai. Dalam kenyataan while kita tidak memerlukan maklumat bilangan gelung tetapi hanya perlu meletakkan syarat untuk terus bergelung. Apabila syarat ini tidak dipenuhi, maka gelung akan berhenti. Perhatikan sintaks kenyataan while berikut:

while (ungkapan)

kenyataan;


ungkapan biasanya merupakan ungkapan hubungan atau ungkapan logic atau hubungan majmuk. Ungkapan merupakan syarat terhadap pengawal gelung yang menghasilkan nilai benar (bukan sifar) atau palsu (sifar). Selagi ungkapan bernilai bukan sifar (benar) kenyataan akan dilaksanakan. Kenyataan boleh terdiri daripada satu kenyataan ataupun kenyataan majmuk yang merupakan badan gelung. Lazimnya badan gelung harus mengandungi ungkapan untuk mengemaskinikan pengawal gelung.

Langkah perlaksanaan bagi gelung while adalah seperti berikut:

  1. Ungkapan pengawal gelung dinilai.
  2. Jika ungkapan bernilai benar (bukan sifar), laksanakan kenyataan dan ulang langkah 1.
  3. Jika ungkapan bernilai palsu (sifar), tamat gelung.

8.3 kenyataan do-while

Gelung berkawalkan syarat dan gelung berkawalkan sentry juga dapat ditulis menggunakan kenyataan do-while. Kenyataan ini hampir sama dengan kenyataan while, tetapi syarat untuk tamat gelung diuji diakhir gelung. Ini bermakna gelung ini akan dilaksanakan sekurang-kurangnya sekali sebelum syarat ujian dinilai. Sintaks bagi kenyataan do-while adalah seperti berikut:

do

kenyataan

while (ungkapan);


secara umumnya, kenyataan akan dilaksanakan sehingga nilai ungkapan adalah palsu (sifar). Langkah perlaksanaan bagi gelung do-while adalah seperti berikut:

  1. Kenyataan dilaksanakan.
  2. Ungkapan pengawal gelung dinilai.
  3. Jika ungkapan bernilai benar (bukan sifar), maka ulang langkah 1 hingga 3.
  4. Jika ungkapan bernilai palsu (sifar), tamat gelung.


BAB 9 FUNGSI


Fungsi merupakan gabungan kenyataan yang dibentuk untuk melaksanakan suatu tugas. Bab ini akan menerangkan apa yang dimaksudkan dengan fungsi, dalam keadaan bagaimana ia diperlukan, dan bagaimana jujujan perlaksanaan atur cara dikawal dalam fungsi.


9.1 fungsi pustaka piawai c


Bahasa C menggalakkan penggunaan semula kod dengan menyediakan pelbagai fungsi yang sedia tertakrif. Contohnya, pustaka matematik piawai bagi C ,mentakrifkan fungsi sqrt() yang melaksanakan pengiraan punca kuasa dua. Fungsi ini boleh diguna semula oleh aturcara yang kita tulis.


9.2 mekanisma kerja fungsi


Satu cara untuk pengaturcara mengimplemen reka bentuk atas-bawah ialah dengan mentakrifkan fungsi milik mereka sendiri. Lazimnya pengaturcara akan menulis satu fungsi bagi setiap submasalah yang digambarkan dalam carta berstruktur. Dalam bahagian ini kita akan membincangkan bagaimana untuk mengguna dan mentakrifkan fungsi sendiri dengan memfokuskan kepada fungsi mudah yang tidak mempunyai parameter dan tidak mengembalikan sebarang nilai.


Sebuah aturcara biasanya terdiri daripada satu atau lebih fungsi, yang mana satu daripadanya ialah fungsi main(). Perlaksanaan aturcara sentiasa bermula dengan main(). Apabila kawalan aturcara menemui suatu nama fungsi dan diikuti oleh sepasang kurungan, fungsi tersebut akan dipanggil, atau diaktifkan. Ini bermakna kawalan aturcara dipindahkan kepada fungsi. Selepas fungsi tersebut melaksanakan tugasnya, kawalan aturcara akan dikembalikan semula kepada persekitaran yang memanggil fungsi tadi, yang mana perlaksanaan aturcara akan diteruskan.


9.3 panggilan fungsi


Sintaks am untuk panggilan fungsi adalah seperti berikut:

namafungsi(senarai_paramater_sebenar)


senarai_parameter_sebenar ialah parameter yang dihulurkan sebagai input kepada fungsi. Apabila kita ingin melaksanakan fungsi, kita mesti memanggil namafungsi. Kawalan aturcara akan berpindah kepada namafungsi(). Selepas tamat perlaksanaan fungsi tersebut, kenyataan selepas panggilan namafungsi tadi akan dilaksanakan.


BAB 10 TATASUSUNAN


10.1 kenapa tatasusunan


Bila dan kenapa kita perlu menggunakan tatasusunan dalam aturcara? Andaikan kita perlu menulis sebuah aturcara untuk membaca markah ujian bagi 10 orang pelajar yang setiap satunya berjenis integer. Tanpa menggunakan tatasusunan, kita memerlukan 10 pembolehubah yang setiap satunya berjenis int dan mempunyai nama yang unik. Pengisytiharannya adalah seperti berikut.

-----------------------------------------------------------------------------------------------------------------

int markah1;

intmarkah2;

intmarkah3;

…..

intmarkah10;

-----------------------------------------------------------------------------------------------------------------


10.2 tatasusunan satu dimensi


Tatasusunan merupakan suatu bentuk data rencam. Tatasusunan boleh diisytiharkan dalam pelbagai dimensi.


Mengisytiharkan tatasusunan

Berikut ialah cara pengisytiharan tatasusunan satu dimensi.

Jenis_data nama_tatasusunan[ungkapan];


Jenis_data menentukan jenis data yang hendak disimpan. Nama_tatasusunan merupakan nama pencam yang merujuk kepada tatasusunan. Ungkapan mengandungi nilai bagi saiz tatasusunan. Ia boleh terdiri daripada pemalar integer atau ungkapan yang telah ditakrifkan nilainya. Nilai ini akan menentukan bilangan data yang boleh disimpan oleh tatasusunan. Bilangan data ini menentukan saiz tatasusunan.


Perhatikan contoh pengisytiharan tatasusunan berikut.

int markah [100];


ini bermaksud yang suatu tatasusunan bernama markah dengan saiz 100 daripada jenis int telah diisytiharkan. Pengisytiharan ini akan mengarahkan pengkompil supaya memperuntukkan 100 sel ingatan yang berjujukan kepada pembolehubah bernama markah. Sel-sel ingatan ini juga dipanggil sebagai unsure tatasusunan. Sel ini hanya boleh menyimpan data berjenis int.

Menggunakan gelung untuk memproses tatasusunan

kebiasaanya kita memproses unsur tatasusunan secara berjujukan iaitu bermula dengan unsur pertama (indeks 0) dan seterusnya hingga unsure yang terakhir. Dalam C kita boleh melakukan pemprosesan ini dengan mudah menggunakan gelung berkawalkan pembilang seperti kenyataan for. Pembilang gelung bagi kenyataan for ini harus bermula dengan 0 hingga kurang satu daripada saiz tatasusunan. Dengan menggunakan pembilang gelung ini sebagai indeks tatasusunan, kita dapat merujuk kepada setiap unsure tatasusunan satu demi satu secara berjujukan setiap kali bergelung.


Tatasusunan dan fungsi


Sama seperti pemboleh ubah biasa, tatasusunan yang diisytiharkan sebagai pemboleh ubah sejagat tidak perlu dihulur sebagai parameter sekiranya ingin dicapai dalam fungsi tertentu. Sebaliknya jika suatu tatasusunan diisytiharkan sebagai pembolehubah setempat, ia perlu dihulur sebagai parameter.


10.3 Tatasusunan dua dimensi


Tatasusunan dua dimensi dapat diandaikan sebagai matriks dua dimensi yang mempunyai baris dan lajur. Berikut ialah cara pengisytiharan tatasusunan dua dimensi:

Jenis_data nama_tatasusunan[ungkapan1][ungkapan2];


Penjelasan bagi setiap komponen adalah sama seperti tatasusunan satu dimensi. Perbezaan yang wujud hanyalah dalam tatasusunan dua dimensi, kita perlu mengisytiharkan saiz bagi baris dan lajurnya. Ungkapan1 ialah saiz bagi baris dan ungkapan2 ialah saiz bagi lajur.

Andaikan anda ingin menyimpan satu set markah ujian 100 orang pelajar. Setiap pelajar mempunyai 10 markah ujian. Data markah ujian ini boleh disimpan dengan menggunakan tatasusunan dua dimensi. Berikut ialah cara untuk mengisytiharkan tatasusunan markah dengan saiz barisnya 100 dan saiz lajurnya 10.

Int markah [100][10];


BAB 11 AKSARA DAN RENTETAN


Bab ini akan memperkenalkan fungsi pustaka piawai yang berkaitan dengan aksara dan rentetan. Fungsi pustaka ini memudahkan kita menulis atur cara yang memproses aksara dan rentetan.


11.1 Asas aksara dan rentetan


Aksara merupakan satu daripada jenis data mudah yang disediakan oleh kebanyakan bahasa pengaturcaraan termasuklah C. kita telah melihat pemalar aksara merupakan suatu aksara yang dikurungi oleh ‘. Nilai bagi aksara ini adalah nilai integer yang mewakili set aksara bagi sistem komputer yang digunakan.


Rentetan merupakan gabungan satu atau lebih aksara. Rentetan tidak mempunyai takrifan jenisnya tersendiri. Jadi untuk mentakrifkan rentetan dalam C, kita gunakan tatasusunan berjenis aksara. Rentetan boleh mengandungi abjad, digit, aksara simbol seperti +,-,*,% malah semua aksara ASCII yang boleh dicetak.


11.1 Mengisytiharkan rentetan


Oleh kerana rentetan diimplemen sebagai tatasusunan aksara, maka pengisytiharan rentetan adalah sama dengan pengisytiharan tatasusunan berjenis aksara. Perhatikan contoh berikut:

Char rentetan[20];


Dalam pengisytiharan diatas, rentetan mempunyai 20 ruang yang boleh menyimpan sehingga 19 aksara (ingat kembali dimana satu ruang adalah untuk aksara ‘\0’ yang mewakili hujung rentetan).

Sebagaimana tatasusunan lain, kita juga boleh memberi nilai awal kepada rentetan. Perhatikan contoh dibawah yang memberikan nilai awal “kuning” kepada pemboleh ubah warna.

Char warna[] = “kuning”;

Pengisytiharan ini adalah sama dengan :

Char warna [] = { ‘k’ , ’u’ , ’n’ , ’i’ , ’n’ , ’g’, ’\0’ };


Apabila rentetan diisytiharkan tanpa menentukan saiz tatasusunan, ruang disediakan secara otomatik. Ruang yang disediakan adalah mengikut panjang rentetan tersebut dan ditambah satu ruang untuk aksara ‘\0’. Dalam contoh diatas, saiz tatasusunan adalah 7.


11.2 Fungsi manupulasi rentetan


C menyediakan fungsi bagi manipulasi rentetan dalam pustaka string.h. antara fungsi yang disediakan adalah fungsi untuk menyalin suatu rentetan, mencari panjang rentetan dan membandingkan dengan rentetan. Bahagian ini akan menghuraikan beberapa fungsi manipulasi rentetan yang banyak digunakan dalam menulis aturcara.

Strcpy(0

Prototaip fungsi ini adalah:

Char *strcpy(char s1[], char s2[]);


Fungsi strcpy() menyalin satu aksara rentetan aksara s2 kepada rentetan aksara s1 (dengan s1 dan s2 ditakrifkan sebagai tatasusunan jenis aksara). Saiz tatasusunan s1 mestilah ditakrifkan cukup besar untuk memuatkan rentetan s2 (termasuklah aksara ‘\0’). Fungsi ini mengembalikan suatu penuding yang menunjuk kepada rentetan s1 (ini bermaksud fungsi ini mengembalikan s1). Perhatikan contoh dibawah:

-----------------------------------------------------------------------------------------------------------------

char nama1[20], nama2[] = “Nurul Nadia”;

strcpy (nama1,nama2);

printf (“%s”, nama1);

-----------------------------------------------------------------------------------------------------------------

Strlen()

Prototaip fungsi ini adalah seperti berikut:

Size_t strlen (char s1 [ ]);


Fungsi strlen() akan mengembalikan bilangan aksara dalam rentetan s1, tidak termasuk aksara ‘\0’. Perhatikan contoh berikut:

-----------------------------------------------------------------------------------------------------------------

Int I;

char s1 [20]]= “Universiti”;

i = strlen(s1);

i = strlen (“UKM”)

i = strlen (“ “)

-----------------------------------------------------------------------------------------------------------------

Strcat()

Prototaip fungsi ini adalah:

Char *strcat(chat s1, char s2);


Fungsi strcat () akan menyalin rentetan s2 dihujung rentetan s1. Kita perlu pastikan yang saiz s1 cukup untuk menampung rentetan akhir setelah fungsi ini dilaksanakan. Aksara ‘\0’ dalam s1 asal dihapuskan. Hanya terdapat satu aksara ‘\0’ sahaja dihujungg rentetan baru s1. Fungsi ini akan mengembalian perunding yang menunjuk ke s1 (iaitu rentetan s1).


BAB 12 - MANIPULASI FAIL


12.1 fail input output


Media yang biasanya digunakan untuk menyimpan data adalah cakera (disk). Fail data input boleh disunting menggunakan penyunting teks sebagaimana kita mencipta fail atur cara. Apabila data ditaipkan, kita boleh menyemak dan menyunting baris data dan akhirnya menyimpan data dalam cakera secara kekal. Data yang disimpan ini boleh diubah, dihapus dan ditambah apabila perlu. Data ini kemudiannya disalurkan kepada aturcara untuk diproses. Satu lagi kelebihan menggunakan fail data ialah data tersebut boleh digunakan berulang kali oleh aturcara yang sama ataupun atur cara yang lain.

Selain daripada data yang diinput daripada fail, kita juga boleh menulis aturcara yang mencetak output kepada fail yang disimpan dalam cakera. Kebiasaannya apabila kita menulis output yang banyak pada paparan, output tersebut akan bergulung pada paparan dan kita hanya akan dapat melihat beberapa baris terakhir sahaja. Bagi output yang sebegini, jika kita menulis output pada fail pada cakera, kita akan mendapat salinan kekal. Kita boleh membaca kandungan fail ini menggunakan penyunting fail teks dan kita juga boleh mencetak fail ini. Akhir sekali kita juga boleh menggunakan fail output yang dihasilkan oleh satu atur cara sebagai input kepada aturcara yang lain.


Fail data


Bahasa C dapat memproses dua jenis fail data iaitu fail teks dan fail binary. Semua fail yang dicipta oleh penyunting teks adalah fail teks. Fail teks terdiri daripada gabungan aksara yang disimpan sebgai satu nama dalam ingatan sekunder seperi cakera. Saiz bagi fail teks adalah tidak tetap; ia bergantung kepada bilangan aksara yang dipunyainya. Untuk menandakan berakhirnya suatu fail teks, komputer meletakkan aksara khas akhir fail (end of file) selepas aksara terakhir dalam fail. Aksara akhir fail ini akan dirujuk sebagai .


Semasa kita mencipta fail, kita menggunakan kekunci untuk memisahkan data kepada baris yang berbeza. Apabila kekunci ditekan, aksara baris baru (diwakili sebagai ‘\n’ dalam bahasa C) diletakkan dalam fail.


12.2 jenis capaian fail


Data yang disimpan dalam cakera boleh dicapai dengan dua cara iaitu secara berjujukan atau membaca secara rawak. Cara capaian data menentukan bagaimana aturcara kita membaca, menulis, mengubah dan menghapuskan data.


Capaian secara berjujukan bermakna data dalam fail dicapai mengikut jujukan ianya ditulis. Analogi bagi capaian secara berjujukan adalah pita kaset. Kita memainkan muzik dalam jujukan yang sama sebagaimana ianya dirakam. Bagi fail berjujukan ini, adalah sukar untuk menambah data ditengah-tengah fail. Walaupun capaian fail berjujukan mempunyai banyak kekangan, kebanyakan aplikasi menggunakan fail jenis ini.


Tidak seperti fail capaian berjujukan, fail capaian rawak pula bermakna data boleh dicapai dalam sebarang jujukan. Bayangkan fail capaian rawak sebagai satu cakera padat (CD) muzik; kita boleh terus memainkan atau fast-forward bahagian sebelumnya. Fail capaian rawak memerlukan lebih pertimbangan pengaturcaraan.


12.3 membuka dan menutup fail


Sebelum suatu fail boleh dicipta, diedit dan dibaca, fail tersebut mestilah dibukan terlebih dahulu. Apabila kita ingin membuka suatu fail, kita mesti menyatakan nama fail yang ingin dibuka serta tugas yang ingin dilakukan terhadap fail tersebut (membaca, menulis atau menambah data).

Sintaks untuk membuka fail adalah :

pfail = fopen(nama_fail, mod_capaian);


pfail adalah penuding istimewa yang menunjuk keada fail tersebut. Penuding ini dikenali sebagai rujukan bagi fail. Penuding fail diisytiharkan sebagai penuding jenis FILE seperti berikut:

FILE *pfail;


nama_fail pula adalah rentetan yang merupakan nama fail yang sah. nama_fail boleh mengandungi nama pemacu dan direktori yang lengkap. mod_capaian menentukan operasi yang boleh dilakukan terhadap fail tersebut.


BAB 13 – STRUKTUR


Dalam bab ini kita akan melihat satu kemudahan memodelkan data dalam C yang dikenali sebagai struktur. Dengan menggunakan struktur, kita dapat mewakilkan sekumpulan data yang berkaitan antara satu sama lain walaupun berlainan jenis secara berstruktur. Perwakilan data sebegini penting dalam menulis aturcara yang berkaitan dengan memanipulasi data dan pangkalan data.


13.1 pengenalan kepada struktur


Struktur adalah gabungan butir-butir data daripada pelbagai jenis. Tidak seperti tatasusunan, struktur dapat menggabungkan data daripada jenis yang berbeza dan dapat dirujuk dengan nama yang sama.


13.2 menakrifkan struktur


Kita dapat menakrifkan struktur dengan binaan struct. Binaan struct menakrifkan satu jenis data baru yang boleh digunakan oleh aturcara. Bentuk umum binaan struct adalah :

struct nama_struktur {

takrifan_data_1;

takrifan_data_2;

:

takrifan_data_n;

};

Nama_struktur merupakan nama bagi binaan struct tersebut. Nama ini haruslah memenuhi syarat yang dikenakan ke atas nama pemboleh ubah atau pencam.


BAB 14 - KESATUAN DAN TERANGKAN


Kita akan lihat dua lagi jenis data yang boleh ditakrifkan oleh pengaturcara iaitu jenis data kesatuan dan jenis data terangkaan. Jenis data kesatuan menggunakan kata kunci union manakala jenis data terangkaan menggunakan kata kunci enum.


14.1 kesatuan (union)


Jenis data kesatuan membenarkan kita menggabungkan beberapa jenis data yang berbeza sebagai satu unit yang berkongsi ingatan yang sama. Hanya satu nilai sahaja boleh diumpukkan pada lokasi ingatan tersebut pada satu masa. Ini agak berbeza dengan jenis data struktur yang menggabungkan beberapa jenis data berbeza sebagai satu unit dan setiap unsur data tersebut boleh diumpukkan nilai secara serentak.


Cara untuk menakrifkan union adalah sama dengan menakrifkan struktur. Perhatikan contoh berikut, katakana kita memerlukan satu pemboleh ubah nombor yang pada satu keadaan diumpukkan dengan satu nilai integer. Dalam keadaan yang lain dalam aturcara yang sama nombor diumpukkan dengan nilai nyata ataupun mungkin nilai aksara. Jika kita sediakan tiga pembolehubah yang berbeza untuk mewakili nilai ini, maka kita perlu membina tiga set atur cara untuk melakukan operasi terhadap nilai ini. Maka dalam kes seperti ini kita bina jenis data union yang terdiri daripada tiga unsur iaitu aksara, integer dan nyata.


14.2 terangkaan (enum)


Jenis data enum merupakan jenis data yang membolehkan kita memberikan nama tertentu kepada nilai. Jenis data ini biasanya digunakan bagi pembolehubah yang mempunyai nilai yang terhingga. Dengan menggunakan jenis data ini akan meningkatkan kebolehbacaan aturcara.


Cuba kita perhatikan apabila kita ingin mewakilkan pembolehubah untuk nama hari. Biasanya adalah mudah untuk kita andaikan nilai 1 mewakili hari ahad, nilai 2 mewakili hari isnin dan seterusnya. Walaupun atur cara dapat berfungsi dengan baik, tetapi kita perlu menjelaskan perwakilan yang diguna dengan menggunakan komen. Kita lihat bagaimana takrifan jenis enum hari berikut dan seterusnya nanti dijelaskan bagaimana jenis data ini dapat membantu menjelaskan aturcara kita.


Enum hari {isnin, selasa, rabu, khamis, jumaat, sabtu, ahad };


Dengan takrifan diatas, isnin bernilai 0, selasa bernilai 1, dan seterusnya ahad bernilai 6. Kita boleh takrifkan pembolehubah berjenis enum hari seperti berikut:


Enum hari hariini, h;


Isnin, selasa, rabu, khamis, jumaat, sabtu dan ahad merupakan nilai yang boleh diumpukkan kepada pembolehubah hariini dan h. Lebih tepat lagi, nilai yang diumpukkan adalah nilai integer yang diwakilinya.


BAB 15 PENUDING


Penuding adalah jenis data istimewa yang disediakan oleh bahasa pengaturcaraan C. jenis data penuding menjadikan C bahasa yang sangat lentur. Bab ini akan mendalami asas jenis data penuding, hubungan penuding dengan tatasusunan, rentetan dan juga struktur.


15.1 asas penuding


Secara ringkasnya penuding adalah satu pembolehubah yang mana nilainya adalah alamat. Alamat ini biasanya merujuk kepada data dalam suatu lokasi ingatan; menjadikan penuding menunjuk kepada data tersebut. Terdapat jenis penuding yang berbeza yang menunjuk kepada jenis data yang berbeza. Kita ada jenis penuding integer yang menunjuk kepada data integer, jenis penuding aksara yang menunjuk kepada data aksara dan sebagainya.


Takrifan dan umpukan nilai penuding


Tardapat dua operator yang mempunyai kaitan dengan penuding iaitu operator & dan *. Operator & adalah operator yang menentukan alamat bagi suatu pembolehubah. Operator * adalah operator yang merujuk kepada kandungan lokasi yang ditunjuk oleh penuding.

Untuk lebih jelas, kita lihat takrifan berikut:


int i, *p;


kita telah sedia faham yang i ialah pembolehubah berjenis int. kita boleh tulis &i sebagai alamat atau lokasi ingatan bagi pemboleh ubah i.(ingat kembali yang kita gunakan &i sebagai parameter dalam fungsi scanf() – yang mana merujuk kepada alamat bagi pemboleh ubah i ).

Dalam takrifan diatas, p adalah satu pembolehubah penuding yang merujuk ke suatu nilai int. kandungan pemboleh ubah p ialah alamat; iaitu rujukan kepada lokasi ingatan yang mengandungi suatu nilai int. berikut adalah beberapa contoh umpukan nilai kepada pembolehubah p:

-----------------------------------------------------------------------------------------------------------------


p = &i; /*p menunjukkan kei */

P = NULL; /*p tidak menunjuk ke sebarang lokasi ingatan */

P = 0; /*sama seperti p = NULL */

-----------------------------------------------------------------------------------------------------------------

Kenyataan pertama diatas dapat dihuraikan sebagai “p menunjuk ke I” atau “p merujuk kepada i” ataupun “p mengandungi alamat i”. Andaikan yang alamat bagi pemboleh ubah i ialah 1240 (kita gariskan untuk membezakan antara alamat dengan nombor). Maka kenyataan tersebut akan mengumpukkan nilai 1240 kepada p. ini seolah-olah p menunjuk kepada i.