PENGATURCARAAN II (C++)

DDC 2133

BAB 7 : PENUDING
 PENGENALAN
• Penuding – satu jenis p/ubah yang mengandungi alamat
ingatan bg p/ubah yg lain ( cth : ia menuding kepada
p/ubah yg mengandungi nilai).
• Contoh : jika lokasi ingatan pada alamat 5000 memegang
alamat lokasi ingatan yg lain, katakan 5004, maka nilai yg
disimpan pd lokasi 5004 boleh diakses menggunakan
p/ubah penuding.
Lokasi ingatan Kandungan
5000 5004
5001
5002
5003
5004
5005
 PENGENALAN
• Penuding boleh dianggap alamat bg objek yg lain. Jika satu p/ubah
penuding mengandungi alamat satu p/ubah lain, ia sebenarnya penuding
kpd p/ubah tersebut.
• Dlm C++ 2 operator penuding yg diguna :
– Operator reference (&) – alamat kepada (memulangkan alamat p/ubah
selepasnya)
– Operator dereference (*) – nilai yg dituding oleh (memulangkan nilai p/ubah yg
dituding oleh penuding ini)
• Contoh 1 : a = &b
alamat p/ubah b ditetapkan kepada a
• Contoh 2 : c = *b
Nilai yg dituding oleh b ditetapkan kepada c
 PENGENALAN
• Contoh 1 : a = &b
alamat p/ubah b ditetapkan kepada a
• Contoh 2 : c = *b
Nilai yg dituding oleh b ditetapkan kepada c

a 1776

b
25
c

25
 PENGISYTIHARAN DAN RUJUKAN
• Sintaks pengisytiharan :
jenis_data *namapembolehubah;
• Contoh :
char *markah; //penuding kepada aksara
float *t; //penuding kepada float
double *suhu; //penuding kepada double
• Setelah p/ubah penuding diisytihar, satu ruang yg dpt
memegang /menyimpan satu alamat ingatan
ditempah.
 PENGISYTIHARAN DAN RUJUKAN
• Nilai boleh diberi iaitu memberi alamat supaya p/ubah
penuding ini menunjuk ke lokasi p/ubah tertentu.
int *p; i 10

int i = 10;
int p = &i; p
• Lokasi i boleh dirujuk sama ada menggunakan p/ubah i
atau penuding p.
cout <<“Nilai i ialah “<<i;
cout<<“Nilai *p ialah “<<*p; *kedua-dua akan cetak nilai
10
*p = 24;
cout<<“Nilai i yang baru ialah “<<i; *nilai 24 akan dicetak
 PENGISYTIHARAN DAN RUJUKAN
#include <iostream.h>
void main ( )
{
int *m, x = 567;
m = &x;
cout << "Nilai x ialah "<<*m
}
Output :
Nilai x ialah 567
 UNGKAPAN PENUDING
• Aritmetik Penuding
hanya dibenarkan 2 operasi aritmetik – tambah dan tolak.
contoh 1:
char *mychar;
andaikan p/ubah di atas menuding kpd lokasi ingatan 1000, diberi
mychar++;
maka p/ubah penuding di atas menuding kpd kandungan ingatan pd lokasi
1001.
contoh 2 : jika pointer1 menuding kpd tatasusunan integer
pointer1 = pointer1 + 7;
maka pernyataan di atas akan menyebabkn pointer1 menuding ke
elemen yg ke 7 (dpd yg semasa) dlm tatasusunan.
 UNGKAPAN PENUDING
• Perbandingan Penuding
C++ membenarkan perbandingan penuding yg sama jenis.
cth :
int iptr1, iptr2, i1 = 5, i2 = 55;
double dptr1, dptr2, d1 = 7.0, d2 = 77;
iptr1 = &i1;
iptr2 = &i2;
dptr1 = &d1;
dptr2 = &d2;
maka perbandingan (iptr1 == iptr2) adalah sah tetapi
perbandingan (iprt1 == dptr2) tidak sah.
 UNGKAPAN PENUDING
• Penetapan nilai Penuding
p/ubah penuding boleh ditetapkan nilai kepada p/ubah
penuding yang lain dari jenis yg sama.
contoh :
#include <iostream.h>
void main ( )
{
int num = 5, *pointer1, *pointer2;
pointer1 = &num;
pointer2 = pointer1;
cout<<“\n” << *pointer1 <<“\t”<<*pointer2;
Output : 5 5
 PENUDING KEPADA PENUDING
• Penuding boleh digunakan utk menuding kpd penuding lain.
• Penuding kpd p/ubah adalah single indirection ttpi
penuding yg menuding kpd penuding yg lain adalah double
@ multiple indirection.
single indirection multiple indirection
pointer variable second pointer first pointer variable

Address value Address Address value

• Second pointer bukan menuding kpd no int ttpi menuding
kpd penuding yg lain yg menuding kpd penuding ordinary
(second pointer menuding kpd first pointer yg seterusnya
menuding kpd p/ubah yg mengandungi nilai.
 PENUDING KEPADA PENUDING
• Utk akses kpd nilai target yg dituding oleh penuding kpd
penuding, operator asterisk * ditulis 2 kali. Cthnya :
int **twoptr; //beritahu pengkompil twoptr adalah
penuding utk menuding jenis data int
//program to illustrate multiple indirection
#include <iostream.h>
main ( )
{
int num = 7, *firstPtr, **secondPtr;
firstPtr = &num;
secondPtr = &firstPtr;
cout <<**secondPtr;
return 0;
}
 PANGGILAN-IKUT-RUJUKAN
MENGGUNAKAN PENUDING
• Panggilan ikut rujukan – alamat sesuatu p/ubah
dihantar ke fungsi supaya fungsi boleh merujuk terus
ke lokasi ingatan di mana p/ubah berada.
• Jika fungsi mengubah nilai p/ubah, perubahan akan
kekal sehingga p/ubah keluar drp fungsi.
• Cara : menggunakan penuding utk rujuk kpd p/ubah
dan panggilan menggunakan simbol &.
 PANGGILAN-IKUT-RUJUKAN
MENGGUNAKAN PENUDING
#include <iostream.h>
void Gandaan(int *k)
{
*k = *k * *k;
}
void main ( )
{
int angka = 10;
cout <<“Nilai asal angka ialah “<<angka<<endl;
Gandaan(&angka);
cout <<“Nilai angka selepas melalui fungsi Gandaan ialah
“<<angka<<endl;
}
#include <iostream.h>
void GandaLuas (int p , int l)
{
p = p * l;
cout <<“Dalam GandaLuas : “<<p<<endl; //output 20
}
void GandaFaktor (int *a, int faktor)
{
*a = *a * faktor;
cout <<“Dalam GandaFaktor : “<<*a<<endl; //output 20
}
void main ( )
{ int x = 4; int y = 5;
GandaLuas (x,y); // cetakan 20
cout<<“Nilai x selepas panggilan ialah : “<<x<<endl; // output 4
GandaFaktor(&x, y);
cout <<“Nilai x selepas panggilan ialah “<<x; //output 20
}
 TATASUSUNAN DAN PENUDING
• Tatasusunan boleh digunakan untuk menyimpan
penuding bg banyak nilai.
• Ungkapan berikut menyediakan tatasusunan bg 10
integer p/ubah penuding.
int *p[10];
• Ungkapan berikut menyediakan tatasusunan bg 10
char p/ubah penuding .
char *p[10];
 TATASUSUNAN DAN PENUDING
char r[30], *p;
p = r;
• p/ubah p diumpukkan alamat bg elemen pertama dalam tatasusunan
r (nama tatasusunan tersebut ialah penuding kpd tatasusunan
tersebut).
• Utk mencapai sesuatu elemen dlm tatasusunan, indeks dan kurungan
atau penuding boleh digunakan.
r[0] atau *(p + 0) - mencapai elemen pertama r
• Contoh gelung utk mencetak kandungan setiap elemen tatasusunan.
char t[10];
char *p = t;
for (i = 0; 1<10; i++,p++)
cout<<*p;
 TATASUSUNAN DAN PENUDING
#include <iostream.h>
void main ( )
{
int a[10] = { 3, 4, 23, 35, 45, 23, 3, 34, 100};
int *p[10];
int i;
for (i = 0; i<10; i++)
p[i] = &a[i];
for ( i = 0; i<10; i++)
cout<<“ “<<*p[i];
}
 PEMALAR DALAM PENUDING
• P/ubah penuding menuding kepada objek pemalar
const int *ptr_to_constant;

• Pemalar penuding kepada objek bukan pemalar

int *const constant_ptr;

• Pemalar penuding kepada objek pemalar

const int *const constant_ptr;
 PENUDING DAN FUNGSI
• Selain digunakan dlm ungkapan yg biasa, fungsi juga boleh memulangkan dan
menerima penuding sebagai argumen.
• Utk menggunakan penuding kepada fungsi, jenis nilai yg akan dipulangkan oleh
fungsi mesti diisytihar dan juga argumen serta jenisnya perlu ditentukan.
• Contoh :
double (*ptr) (double, double)
• Utk merujuk kpd fungsi menggunakan penuding, alamat fungsi kpd penuding
perlu ditetapkn.
ptr = &minimun; //tetapkn alamat minimun( )
kpd ptr
 PENUDING DAN FUNGSI
small = (*ptr)(x1, x2)
• Memanggil fungsi yg dituding oleh (*ptr).
#include <iostream.h>
void main( )
{
double minimum (double, double) ;//prototaip fungsi
// (*ptr) menuding kpd fungsi berjenis double
double (*ptr) (double, double);
double x1, x2, small;
ptr = &minimum;
cout << “\nEnter 2 numbers : “<<endl;
cin >> x1 >> x2;
//panggilan fungsi yg dituding ptr
small = (*ptr) (x1, x2);
cout<<\n”Smaller of the two is “ <<small;
}
double minimum (double y1, double y2)
{
if (y1 < y2)
return y1;
else
return y2;
}
 MEMULANGKAN PENUDING DARIPADA
FUNGSI
• Fungsi boleh memulangkan penuding dgn
menggunakan operator * pada sebelah kiri nama
fungsi.
• Contoh :
int * Nama_fungsi ( )
• Menetapkan penuding dgn badan fungsi
Contoh 1 :

#include <iostream.h>

double & GetWeeklyHours ( )

{
double h = 46.50;
double &hours = h;
return hours;
}
double * GetSalary( )
{
double salary = 26.48;
double *HourlySalary = &salary;
return HourlySalary;
}
int main( )
{ double hours = GetWeeklyHours( );
double salary = *GetSalary( );
cout << “Weekly Hours : “ <<hours <<endl;
cout << “Hourly Salaru : “<< salary <<endl;

double WeeklySalary = hours * salary;

cout << “Weekly Salary : “<<WeeklySalary <<endl;

return 0;
}