Bab. 13 Beberapa Topik Penting
Lainnya
|
Tujuan
Instruksional
|
|
|
·
Operator const_cast.
·
Anggota kelas Mutable.
·
namespace.
·
Katakunci operator.
|
·
Pointer ke anggota
kelas (.* dan ->*)
·
Pewarisan jamak.
·
Kelas basis virtual.
|
13.1 Introduksi
Pada kesempatan ini akan dibahas
beberapa fitur tambahan C++. Akan didiskusikan tentang operator const_cast, yang mengijinkan Anda untuk
menambah atau menghapus kualifikasi const
atas suatu variabel. Selanjutnya, akan didiskusikan mengenai namespace, yang berguna untuk memastikan
setiap pengenal di dalam program memiliki nama yang unik dan bermanfaat untuk
menyelesaikan konflik penamaan yang diakibatkan oleh penggunaan pustaka yang
memiliki nama variabel, nama fungsi, dan nama kelas sama.
Kemudian akan disajikan beberapa
katakunci operator, berguna bagi programmer yang memiliki papanketik yang tidak
mendukung beberapa karakter tertentu seperti !, &, ^, ~, dan |. Diskusi
dilanjutkan dengan topik penspesifikasi kelas mutable, yang memampukan Anda untuk mengindikasikan bahwa suatu
anggota data harus selalu bisa dimodifikasi, meskipun ia berada di dalam suatu
objek yang saat ini diperlakukan sebagai objek const oleh program.
Berikutnya akan diintroduksi dua
operator spesial yang dapat digunakan dengan pointer yang menunjuk kepada
anggota kelas untuk mengakses anggota data atau fungsi anggota tanpa perlu
mengetahui namanya terlebih dahulu. Di bagian akhir, akan dikenalkan pewarisan
jamak, yang memampukan kelas terderivasi untuk mewarisi anggota-anggota dari
beberapa kelas basis. Akan didiskusikan pula tentang beberapa masalah potensial
dari pewarisan jamak dan tentang pewarisan virtual
yang dapat memecahkan masalah tersebut.
13.2 Operator const_cast
C++
menyediakan operator const_cast untuk
membuang kualifikasi const atau volatile. Anda mendeklarasikan variabel dengan kualifikasi volatile ketika Anda mengharapkan
variabel tersebut dimodifikasi oleh perangkat keras atau oleh program lain yang
dikenal kompiler. Pendeklarasikan variabel sebagai volatile mengindikasikan bahwa kompiler tidak mengoptimasikan
penggunaan variabel tersebut karena, jika dilakukan, akan mempengaruhi program
lain (yang tak dikenal kompiler) dalam mengakses dan memodifikasi variabel volatile.
Secara
umum, adalah berbahaya bila menggunakan operator const_cast, karena hal ini mengijinkan program untuk memodifikasi
variabel yang dideklarasikan const. Terdapat
beberapa kasus dimana hal ini perlu dilakukan. Misalnya, pada pustaka lama C
dan C+, terdapat beberapa fungsi yang memiliki parameter non-const dan tidak memodifikasi parameter
tersebut. Jadi, ketika Anda berniat untuk melewatkan data const kepada fungsi semacam itu, maka Anda perlu membuang
kualifikasi const pada data tersebut,
karena, jika tidak, kompiler akan mengeluarkan pesan kesalahan.
Sama
halnya, Anda bisa melewatkan data non-const
kepada fungsi yang memperlakukan data sebagai konstanta, kemudian menghasilkan
nilai balik berupa data tersebut (sebagai konstanta). Pada kasus seperti itu,
Anda bisa membuang kualifikasi const
pada nilai balik menggunakan operator const_cast,
seperti yang didemonstrasikan pada Gambar 13.1.
Gambar 13.1 Mendemonstrasikan const_cast
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
// Gambar 13.1: gambar13_01.cpp
// Mendemonstrasikan const_cast.
#include <iostream>
#include <cstring> // memuat
protototipe untuk fungsi strcmp dan strlen
#include <cctype> // memuat
prototipe untuk fungsi toupper
using namespace std;
// menghasilkan string terbesar C-style
const char *maksimum( const char *pertama, const
char *kedua )
{
return ( strcmp( pertama, kedua )
>= 0 ? pertama : kedua );
} // akhir dari fungsi maksimum
int main()
{
char s1[] = "selamat";
// array karakter yang bisa dimodifikasi
char s2[] = "jalan";
// array karakter yang bisa dimodifikasi
// const_cast
dibutuhkan untuk mengijinkan const char * yang dijadikan nilai balik
// oleh maksimum
ditugaskan kepada variabel char * variable maksPtr
char *maksPtr = const_cast<
char * >( maksimum( s1, s2 ) );
cout << "String yang lebih
besar adalah: " << maksPtr << endl;
for ( size_t i = 0; i <
strlen( maksPtr ); ++i )
maksPtr[ i ] = toupper( maksPtr[ i ] );
cout << "String yang
dikapitalisasi: " << maksPtr << endl;
} // akhir dari main
|
String
yang lebih besar adalah: selamat
String
yang dikapitalisasi: SELAMAT
Pada
program ini, fungsi maksimum (baris
9-12) menerima dua string C-style sebagai parameter char* dan menghasilkan nilai balik const char* yang menunjuk kepada string terbesar dari dua string
yang ada. Fungsi main mendeklarasikan
dua string C-style sebagai array non-const
char (baris 16-17); jadi, kedua array itu dapat dimodifikasi. Dalam main, Anda diharapkan menampilkan string
terbesar dari kedua string C-style, kemudian memodifikasi string C-style
tersebut dengan mengkapitalisasi semua hurufnya.
Dua
parameter fungsi maksimum bertipe const
char*, jadi nilai baliknya harus bertipe const char* pula. Jika nilai balik fungsi itu dispesifikasi sebagai
char*, maka kompiler akan menampilkan
pesan kesalahan yang mengindikasikan bahwa nilai yang dijadikan nilai balik
tidak bisa dikonversi dari const char*
menjadi char*.
Meskipun
fungsi maksimum percaya bahwa datanya
bersifat konstanta, namun diberikan dua array di dalam main yang tidak memuat data konstanta. Oleh karena itu, main harus dapat memodifikasi isi kedua
array tersebut jika diperlukan. Karena diketahui bahwa kedua array tersebut
bisa dimodifikasi, maka Anda perlu menggunakan const_cast (baris 21) untuk membuang kekonstantaan pointer yang
dijadikan nilai balik oleh maksimum,
sehingga Anda dapat memodifikasi data di dalam array yang memuat string
terbesar dari dua string C-style yang diberikan. Anda kemudian dapat
menggunakan pointer (nama array karakter) di dalam statemen for (baris 25-26) untuk mengkonversi isi
string terbesar menjadi huruf besar semua. Tanpa operator const_cast pada baris 21, program ini tidak akan bisa dikompilasi,
karena Anda tidak diijinkan untuk menugaskan pointer bertipe const char* kepada pointer bertipe char*.
13.3 Anggota Kelas mutable
Pada
Anda telah dikenalkan operator const_cast,
yang membolehkan pembuangan kekonstantaan suatu tipe. Operasi const_cast dapat pula diterapkan
terhadap anggota data suatu objek const
dari tubuh suatu anggota fungsi const.
Hal ini memampukan fungsi anggota const
untuk memodifikasi anggota data, meskipun objek dipandang sebagai const di dalam tubuh fungsi tersebut.
Operasi semacam itu dilakukan ketika semua anggota data suatu objek
dideklarasikan const, tetapi pada
anggota data tertentu perlu dilakukan pemodifikasian.
Sebagai
contoh, pikirkan tentang list berantai yang menetapkan isinya dengan tatanan
berurutan. Pencarian dalam list berantai tidak memerlukan pemodifikasian
terhadap data, sehingga fungsi pencarian dapat berupa suatu fungsi anggota const pada kelas list berantai. Namun, adalah
masuk akal bila di dalam suatu objek list berantai, agar pencarian selanjutnya
lebih efisien, dilakukan penjejakan lokasi kecocokan terakhir. Untuk
melakukannya, fungsi anggota const yang melaksanakan pencarian harus dapat
memodifikasi anggota data yang menjejak lokasi kecocokan terakhir.
Jika
anggota data seperti yang telah dijelaskan selalu bisa dimodifikasi, C++
menyediakan penspesifikasi mutable
sebagai alternatif dari const_cast.
Anggota data mutable selalu bisa
dimodifikasi, meskipun di dalam suatu fungsi anggota const atau objek const. Pemodifikasi
mutable dan const_cast digunakan dalam konteks yang berbeda. Pada objek const tanpa memiliki anggota data mutable, operator const_cast dapat digunakan setiap kali anggota perlu dimodifikasi.
Hal ini akan mereduksi peluang suatu anggota dimodifikasi secara tak sengaja
karena anggota secara permanen tidak dapat dimodifikasi (tanpa penggunaan const_cast). Operasi yang melibatkan const_cast tersembunyi di dalam
implementasi fungsi anggota.
Mendemonstrasikan
Anggota Data mutable
Gambar
13.2 mendemonstrasikan penggunaan anggota data mutable. Program mendefinisikan kelas Uji_Mutable (baris 7-21), yang memuat sebuah konstruktor, fungsi getNilai dan sebuah anggota data private, nilai, yang dideklarasikan mutable.
Baris 15-18 mendefinisikan fungsi getNilai
sebagai fungsi anggota const yang
menghasilkan nilai balik berupa hasil salinan atas nilai. Perhatikan bahwa fungsi menginkremen anggota data mutable, nilai, di dalam statemen return.
Normalnya, fungsi anggota const tidak
dapat memodifikasi anggota data kecuali jika menggunakan const_cast terhadap tipe non-const.
Karena nilai adalah mutable, maka fungsi ini dapat
memodifikasi data.
Gambar 13.2 Mendemonstrasikan penspesifikasi
mutable
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
// Gambar 13.2: gambar13_02.cpp
// Mendemonstrasikan penspesifikasi mutable.
#include <iostream>
using namespace std;
// definisi kelas UjiMutable
class UjiMutable
{
public:
UjiMutable( int v = 0 )
{
nilai = v;
} // akhir dari konstruktor UjiMutable
int getNilai() const
{
return ++nilai; // menginkremen
nilai
} // akhir dari fungsi getNilai
private:
mutable int nilai; // anggota mutable
}; // akhir dari kelas UjiMutable
int main()
{
const UjiMutable uji( 99 );
cout << "Nilai awal:
" << uji.getNilai();
cout << "\nNilai
termodifikasi: " << uji.getNilai() << endl;
} // akhir dari main
|
Nilai
awal: 99
Nilai
termodifikasi: 100
Baris
25 mendeklarasikan objek const UjiMutable,
uji, dan menginisialisasinya dengan
99. Baris 27 memanggil fungsi anggota const,
getNilai, yang menambahkan satu
kepada nilai dan menjadikan isi
sebelumnya sebagai nilai balik. Perhatikan bahwa kompiler mengijinkan
pemanggilan terhadap fungsi anggota getNilai
pada objek uji karena objek tersebut
merupakan suatu objek const dan getNilai adalah suatu fungsi anggota const. Namun, getNilai memodifikasi variabel nilai.
Jadi, ketika baris 28 memanggil getNilai
kembali, nilai baru dari nilai (100)
ditampilkan untuk membuktikan bahwa anggota data mutable telah dimodifikasi.
13.4 namespace
Suatu
program dapat menyertakan banyak pengenal yang didefinisikan dalam berbagai
skop. Kadangkala variabel dalam suatu skop tumpang-tindih (bertubrukan) dengan
suatu variabel bernama sama dalam skop yang berbeda, yang kemungkinan akan
menyebabkan konflik penamaan. Kondisi tumpang-tindih semacam itu terjadi pada
banyak level. Ketumpang-tindihan pengenal seringkali terjadi dalam pustaka
pihak-ketiga, yang secara tak-sengaja menggunakan pengenal global yang sama
(seperti nama fungsi). Hal ini akan menyebabkan error kompilasi.
C++
standard memecahkan masalah ini dengan penggunaan namespace. Setiap namespace
mendefinisikan skop dimana pengenal dan variabel ditempatkan. Untuk menggunakan
anggota suatu namespace, Anda harus
mencantumkan nama anggota, nama namespace, dan operator resolusi skop (::),
seperti ini:
NamaSpaceKu::anggota
atau
menggunakan direktif using. Secara
umum, statemen using semacam itu ditempatkan di awal file dimana
anggota-anggota namespace digunakan. Sebagai contoh, perhatikan penempatan
direktif using pada awal suatu file
kode-sumber
using
namespace NamaSpaceKu;
menyatakan
bahwa anggota-anggota namespace, NamaSpaceKu, dapat digunakan di dalam
file tanpa perlu mengawali setiap anggota dengan NamaSpaceKu dan operator resolusi skop (::).
Penggunaan
direktif using dalam format
using std::cout;
membawa
satu nama ke dalam skop dimana direktif berada. Penggunaan direktif using dalam format
using namespace std;
membawa
semua nama dari namespace tertentu (std)
ke dalam skop dimana direktif berada.
Tidak
semua namespace dijamin unik. Dua pertiga vendor bisa jadi menggunakan nama
pengenal sama secara tak-sengaja untuk nama-nama namespace. Gambar 13.3 mendemonstrasikan kegunaan namespace.
Gambar 13.3 Mendemonstrasikan beberapa namespace
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
// Gambar 13.3: gambar13_03.cpp
// Mendemonstrasikan beberapa namespace.
#include <iostream>
using namespace std;
int integer1 = 98; // variabel global
// Menciptakan namespace Contoh
namespace Contoh
{
//
mendeklarasikan dua konstanta dan satu variabel
const
double PI = 3.14159;
const
double E = 2.71828;
int
integer1 = 8;
void
tampilNilai(); // prototipe
//
namespace bersarang
namespace
Dalam
{
//
mendefinisikan enumerasi
enum
Tahun { FISKAL1 = 1990, FISKAL2, FISKAL3 };
} //
akhir dari namespace Dalam
} // akhir dari namespace Contoh
// menciptakan namespace tak-bernama
namespace
{
double
doubleTakBernama = 88.22; // mendeklarasikan variabel
} // akhir dari namespace tak-bernama
int main()
{
// menampilkan nilai
doubleTakBernama dari namespace tak-bernama
cout << "doubleTakBernama =
" << doubleTakBernama;
// menampilkan variabel global
cout << "\n(global) integer1 =
" << integer1;
// menampilkan nilai-nilai dari namespace
Contoh
cout << "\nPI = "
<< Contoh::PI
<< "\nE = " << Contoh::E
<< "\ninteger1 = "
<< Contoh::integer1
<< "\nFISKAL3 = "
<< Contoh::Dalam::FISKAL3 << endl;
Contoh::tampilNilai(); // memanggil fungsi tampilNilai
} // end main
// menampilkan variabel dan nilai konstanta
void Contoh::tampilNilai()
{
cout << "\nDalam tampilNilai:\ninteger1
= " << integer1 << "\nPI = "
<< PI << "\nE =
" << E << "\ndoubleTakBernama = "
<< doubleTakBernama <<
"\n(global) integer1 = " << ::integer1
<< "\nFISKAL3 = "
<< Dalam::FISKAL3 << endl;
} // akhir dari tampilNilai
|
doubleTakBernama = 88.22
(global) integer1 = 98
PI = 3.14159
E = 2.71828
Integer1 = 8
FISKAL3 = 1992
Mendefinisikan
namespace
Baris
9-24 menggunakan katakunci namespace
untuk mendefinisikan namespace Contoh.
Tubuh suatu namespace diapit oleh kurung-kurawal ({}). Anggota-anggota
namespace Contoh memuat dua konstanta
(PI dan E pada baris 12-13), sebuat int
(integer1 pada baris 14), sebuah
fungsi (tampilNilai pada baris 16)
dan sebuah namespace bersarang (Dalam
pada baris 19-23). Perhatikan bahwa anggota integer1
memiliki nama sama dengan variabel global integer1
(baris 6). Variabel-variabel bernama sama harus memiliki skop yang berbeda,
jika tidak, maka error kompilasi akan terjadi. Sebuah namespace dapat memuat
konstanta, data, kelas, namespace
bersarang, fungsi, dan lainnya. Definisi namespace harus menempati skop global
atau bersarang di dalam namespace lain.
Baris
27-30 menciptakan sebuah namespace tak-bernama yang memuat anggota doubleTakBernama. Variabel, kelas, dan
fungsi di dalam sebuah namespace tak-bernama hanya dapat diakes di dalam unit
translasi sekarang (file .cpp atau file yang memuatnya). Tetapi, tidak seperti
variabel, kelas, atau fungsi dengan hubungan static, anggota suatu namespace tak-bernama dapat digunakan sebagai
argumen template. Namespace tak-bernama memiliki direktif using secara implisit, sehingga anggota-anggotanya menempati
namespace global, yang dapat diakses secara langsung dan tidak perlu mencantumkan
nama namespace. Variabel global juga merupakan bagian dari namespace global dan
dapat diakses dari semua skop.
Direktif using
Tidak Boleh Ditempatkan dalam Header
Namespace secara khusus berguna dalam
aplikasi berskala besar yang menggunakan banyak pustaka kelas. Pada kasus
tersebut, terdapat kemungkinan yang lebih tinggi terjadinya konflik penamaan.
Saat bekerja pada proyek semacam itu, tidak boleh terdapat direktif using dalam header. Jika Anda
menempatkan direktif using dalam
header, maka hal itu akan membawa semua nama ke dalam sembarang file yang
mencantumkan header tersebut. Hal ini akan mengakibatkan tubrukan nama yang
sangat susah untuk ditemukan bila terjadi. Direkomendasikan hanya menggunakan,
seperti std::cout atau std::string.
13.5 Katakunci Operator
Standard
C++ menyediakan beberapa katakunci operator (Gambar 13.4) yang dapat digunakan
untuk menggantikan beberapa operator C++. Anda bisa menggunakan katakunci
operator jika Anda memiliki papanketik yang tidak mendukung beberapa karakter
tertentu seperti !, &, ^, ~, |, dan lain-lain.
Gambar
13.4 Katakunci Operator
|
Operator
|
Katakunci operator
|
Penjelasan
|
|
&&
||
!
!=
&
|
^
~
&=
|=
^=
|
and
or
not
not_eq
bitand
bitor
xor
compl
end_eq
or_eq
xor_eq
|
AND logikal
OR logikal
NOT logikal
ketak-sama-dengan-an
AND bitwise
OR bitwise
XOR bitwise
komplemen bitwise
penugasan AND bitwise
penugasan OR bitwise
penugasan XOR bitwise
|
Gambar
13.5 mendemonstrasikan beberapa katakunci operator. Microsoft visual 2010
memerlukan header <ciso646>
(baris 4) untuk menggunakan katakunci operator. Pada GNU C++, header ini kosong
karena katakunci operator telah terdefinisi.
Gambar 13.5 Mendemonstrasikan Katakunci Operator
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
// Gambar 13.5: gambar13_05.cpp
// Mendemonstrasikan katakunci operator.
#include <iostream>
#include <ciso646> // untuk Microsoft Visual C++
using namespace std;
int main()
{
bool a = true;
bool b = false;
int c = 2;
int d = 3;
// menyebabkan nilai-nilai bool ditampilkan
sebagai true atau false
cout << boolalpha;
cout << "a = "
<< a << "; b = " << b
<< "; c = "
<< c << "; d = " << d;
cout << "\n\nKatakunci
operator logikal:";
cout << "\n a and a:
" << ( a and
a );
cout << "\n a and b:
" << ( a and
b );
cout << "\n a or a: "
<< ( a or a );
cout << "\n a or b: "
<< ( a or b );
cout << "\n not a: "
<< ( not a );
cout << "\n not b: "
<< ( not b );
cout << "\na not_eq b:
" << ( a
not_eq b );
cout << "\n\nKatakunci
operator bitwise:";
cout << "\nc bitand d: "
<< ( c bitand d );
cout << "\nc bit_or d: "
<< ( c bitor d );
cout << "\n c xor d:
" << ( c xor
d );
cout << "\n compl c:
" << ( compl
c );
cout << "\nc and_eq d: "
<< ( c and_eq d );
cout << "\n c or_eq d:
" << ( c
or_eq d );
cout << "\nc xor_eq d: "
<< ( c xor_eq d )
<< endl;
} // akhir dari main
|
a
= true; b = false; c = 2; d = 3
Katakunci
operator logikal:
a and a: true
a and b: false
a or a: true
a or b: true
not a: false
not b: true
a
not_eq b: true
Katakunci
operator bitwise:
c
bitand d: 2
c
bit_or d: 3
c xor d: 1
compl c: -3
c
and_eq d: 2
c or_eq d: 3
c xor_eq d: 0
Program
mendeklarasikan dan menginisialisasi dua variabel bool dan dua variabel integer
(baris 9-12). Operasi-operasi logikal (baris 21-27) dilakukan terhadap variabel
bool a dan b menggunakan
berbagai katakunci operator logikal. Operasi-operasi bitwise (baris 30-36)
dilakukan terhadap variabel int c dan d menggunakan berbagai katakunci operator bitwise. Setiap hasil
operasi kemudian ditampilkan.
13.6 Pointer ke Anggota Kelas (.* dan
->*)
C++
menyediakan operator .* dan ->* untuk mengakses anggota kelas melalui
pointer. Ini merupakan kapabilitas yang jarang dipakai dan hanya digunakan oleh
programer C++ handal. Di sini hanya akan disajikan contoh penggunaan pointer
yang menunjuk ke beberapa anggota kelas. Gambar 13.6 mendemonstrasikan beberapa
pointer-ke-anggota-kelas.
Gambar 13.6 Mendemonstrasikan Operator .* dan
->*
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
// Gambar 13.6: gambar13_06.cpp
// Mendemonstrasikan operator .* dan ->*.
#include <iostream>
using namespace std;
// definisi kelas Uji
class Uji
{
public:
void fungsi()
{
cout << "Dalam fungsi\n";
} // akhir dari fungsi fungsi
int nilai; // angota data publik
}; // akhir dari kelas Uji
void arrowStar( Uji * ); // prototipe
void dotStar( Uji * ); // prototipe
int main()
{
Uji uji;
uji.nilai = 8; // menugaskan nilai 8
arrowStar( &uji ); // melewatkan alamat
kepada arrowStar
dotStar( &uji ); // melewatkan alamat
kepada dotStar
} // akhir dari main
// mengakses fungsi anggota objek Uji
menggunakan ->*
void arrowStar( Uji *ujiPtr )
{
void ( Uji::*anggotaPtr )() =
&Uji::fungsi; // mendeklarasikan pointer fungsi
( ujiPtr->*anggotaPtr )();
// memanggil fungsi secara tak-langsung
} // akhir dari arrowStar
// mengakses anggota objek Uji menggunakan
.*
void
dotStar( Uji *ujiPtr2 )
{
int Uji::*vPtr = &Uji::nilai;
// mendeklarasikan pointer
cout << ( *ujiPtr2
).*vPtr << endl; // mengakses nilai
} // akhir dari dotStar
|
Dalam
fungsi
8
Program
mendeklarasikan kelas Uji (baris
7-16), yang menyediakan fungsi anggota public,
fungsi, dan anggota data public, nilai. Baris 18-19 menyediakan prototipe untuk fungsi arrowStar (didefinisikan pada baris
30-34) dan dotStar (didefinisikan
pada baris 37-41), yang mendemonstrasikan operator ->* dan .*. Baris 23
menciptakan objek uji, dan baris 24
menugaskan 8 kepada anggota data nilai.
Baris 25-26 memanggil fungsi arrowStar
dan dotstar dengan alamat objek uji.
Baris
32 di dalam fungsi arrowStar
mendeklarasikan dan menginisialisasi variabel anggotaPtr sebagai sebuah pointer ke fungsi anggota. Dalam
deklarasi ini, Uji::* mengindikasikan
bahwa nama variabel anggotaPtr
merupakan sebuah pointer ke anggota kelas Uji.
Untuk mendeklarasikan pointer ke fungsi, nama pointer yang diawali dengan *
diapit oleh sepasang kurung, seperti (Uji::*anggotaPtr).
Pointer ke suatu fungsi harus mencantumkan, sebagai bagian dari tipenya, kedua
tipe nilai balik fungsi yang ditunjuk dan daftar parameter fungsi tersebut.
Tipe nilai balik fungsi ditempatkan di sebelah kiri kurung dan daftar parameter
ditempatkan dan diapit oleh sepasang kurung yang lain di sebelah kanan
deklarasi pointer. Pada kasus ini, fungsi memiliki nilai balik bertipe void dan tidak mempunyai parameter.
Pointer
anggotaPtr diinisialisasi dengan alamat
fungsi anggota fungsi pada kelas Uji. Header fungsi harus sesuai dengan
deklarasi pointer fungsi, yaitu fungsi fungsi
harus memiliki tipe nilai balik void
dan tanpa parameter. Perhatikan bahwa sisi kanan penugasan menggunakan operator
alamat (&) untuk mendapatkan alamat fungsi anggota fungsi. Perhatikan pula bahwa baik sisi kiri atau sisi kanan
penugasan pada baris 32 tidak menunjuk ke objek spesifik dari kelas Uji. Hanya nama kelas yang digunakan dan
operator resolusi skop (::). Baris 33 memanggil fungsi anggota yang disimpan di
dalam anggotaPtr (yaitu, fungsi) menggunakan operator ->*.
Karena anggotaPtr merupakan sebuah
pointer ke suatu anggota kelas, maka operator ->* yang digunakan (bukan operator ->).
Baris
39 mendeklarasikan dan menginisialisasi vPtr
sebagai sebuah pointer ke anggota data int
dari kelas Uji. Sisi kanan penugasan
mengindikasikan alamat anggota data nilai.
Baris 40 melakukan dereferensi pointer ujiPtr2,
kemudian menggunakan operator .* untuk mengakses anggota data yang ditunjuk
oleh vPtr. Kode klien dapat
menciptakan banyak pointer ke anggota kelas yang dapat diakses oleh klien. Pada
contoh ini, baik fungsi anggota fungsi
maupun anggota data nilai
dideklarasikan public.
13.7 Pewarisan Jamak
Dalam
C++, sebuah kelas dapat diderivasi dari lebih dari satu kelas basis, suatu
teknik yang dikenal sebagai pewarisan jamak, dimana di dalamnya kelas
terderivasi mewarisi anggota-anggotanya dari dua atau lebih kelas basis.
Kapabilitas ini dapat mendorong pendaur-ulangan kode yang efisien, tetapi dapat
pula menyebabkan berbagai masalah serius. Pewarisan jamak merupakan konsep
rumit yang seharusnya hanya digunakan oleh para programmer berpengalaman. Pada
kenyataannya, berbagai masalah yang disebabkan oleh pewarisan jamak sangat
susah dideteksi, sehingga bahasa pemrograman yang lebih muda, seperti Java dan
C#, tidak mengijinkan sebuah kelas diderivasi dari lebih dari satu kelas basis.
Masalah
yang umum terjadi pada pewarisan jamak adalah bahwa setiap kelas basis bisa
jadi memuat anggota data atau fungsi anggota yang memiliki nama sama. Hal ini
bisa menyebabkan masalah ambiguitas ketika dikompilasi. Perhatikan contoh
pewarisan jamak (Gambar 13.7, 13.8, 13.9, 13.10, dan 13.11). Kelas Basis1
(Gambar 13.7) memuat satu anggota data protected
int, nilai (baris 20), sebuah
konstruktor (baris 10-13) yang menetapkan nilai
dan fungsi anggota public, getData, pada baris 15-18 yang
menghasilkan nilai balik nilai.
Gambar 13.7 Definisi kelas Basis1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
// Gambar 13.7: Basis1.h
// Definisi kelas Basis1
#ifndef BASIS1_H
#define BASIS1_H
// definisi kelas Basis1
class Basis1
{
public:
Basis1( int nilaiParameter )
{
nilai = nilaiParameter;
} // konstruktor Basis1
int getData() const
{
return nilai;
} // akhir dari fungsi getData
protected: // hanya bisa diakses dari kelas terderivasi
int nilai; // diwarisi oleh kelas
terderivasi
}; // akhir dari kelas Basis1
#endif // BASIS1_H
|
Kelas
Basis2 (Gambar 13.8) mirip dengan
kelas Basis1, dimana data
terproteksinya (huruf) bertipe char (bari 20). Seperti kelas Basis1, Basis2 memiliki sebuah fungsi anggota public, getData, tetapi
fungsi ini menghasilkan nilai balik berupa anggota data char, huruf.
Gambar 13.8 Definisi kelas Basis2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// Gambar 13.8: Basis2.h
// Definition of class Basis2
#ifndef BASIS2_H
#define BASIS2_H
// definisi kelas Basis2
class Basis2
{
public:
Basis2( char dataKarakter )
{
huruf = dataKarakter;
} // akhir dari konstruktor Basis2
char getData() const
{
return huruf;
} // akhir dari fungsi getData
protected: // hanya bisa diakses dari kelas terderivasi
char huruf; // diwarisi oleh kelas
terderivasi
}; // akhir dari kelas Basis2
#endif // BASIS2_H
|
Kelas
Terderivasi (Gambar 13.9 - 13.10)
mewarisi kedua kelas Basis1 dan Basis2 melalui pewarisan jamak. Kelas Terderivasi mempunyai sebuah anggota
data private bertipe double bernama riil (baris 20), sebuah konstruktor untuk menginisialisasi semua
data pada kelas Terderivasi dan
sebuah fungsi anggota getRiil yang
menghasilkan nilai balik berupa nilai dari variabel riil.
Gambar 13.9 Definisi kelas Basis2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// Gambar 13.9: Terderivasi.h
// Definisi kelas Terderivasi yang mewarisi
// dua kelas basis (Basis1 dan Basis2).
#ifndef TERDERIVASI_H
#define TERDERIVASI_H
#include <iostream>
#include "Basis1.h"
#include "Basis2.h"
using namespace std;
// definisi kelas terderivasi
class Terderivasi : public Basis1, public
Basis2
{
friend ostream &operator<<(
ostream &, const Terderivasi & );
public:
Terderivasi( int, char, double
);
double getRiil() const;
private:
double riil; // data private kelas
terderivasi
}; //
akhir kelas Terderivasi
#endif // TERDERIVASI_H
|
Gambar 13.10 Definisi kelas Basis2
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// Gambar 13.10: Terderivasi.cpp
// Definisi fungsi anggota untuk kelas
Terderivasi
#include "Terderivasi.h"
// konstruktor Terderivasi memanggil
konstruktor
// kelas Basis1 dan Basis2.
// menggunakan
penginisialisasi anggota untuk memanggil konstruktor kelas-basis
Terderivasi::Terderivasi( int integer, char
karakter, double double1 )
:
Basis1( integer ), Basis2( karakter ), riil( double1 ) { }
// mengembalikan riil
double Terderivasi::getRiil() const
{
return riil;
} // akhir dari fungsi getRiil
// menampilkan semua anggta dari Terderivasi
ostream &operator<<( ostream
&keluaran, const Terderivasi &terderivasi )
{
keluaran << " Integer:
" << terderivasi.nilai << "\n Karakter: "
<< terderivasi.huruf <<
"\nBilangan riil: " << terderivasi.riil;
return keluaran; // membuat
pemanggilan bertingkat
} // akhir dari operator<<
|
Untuk
mengindikasikan pewarisan jamak dicantumkan titik dua (:) setelah kelas Terderivasi dengan kelas-kelas basis
yang dipisahkan dengan koma (baris 13, Gambar 13.9). Pada Gambar 13.10,
perhatikan bahwa konstruktor Terderivasi
secara eksplisit memanggil konstruktor dari setiap kelas basis, Basis1 dan Basis2, menggunakan sintaks penginisialisasi-anggota (baris 9).
Konstruktor kelas basis dipanggil secara berurutan sesuai dengan hirarki
pewarisan. Jika konstruktor kelas basis tidak dipanggil secara eksplisit dalam
daftar penginisialisasi-anggota, maka konstruktor default yang akan dipanggil
secara implisit.
Operator
penyisipan stream teroverload (Gambar 13.10, baris 18-23) menggunakan argumen
keduanya, sebuah referensi ke suatu objek Terderivasi,
untuk menampilkan data pada objek Terderivasi.
Fungsi operator ini adalah fungsi friend
dari Terderivasi, sehingga operator<< dapat secara langsung
mengakses semua anggota protected dan
private pada kelas Terderivasi, termasuk anggota data
terproteksi nilai (diwarisi dari
kelas Basis1), anggota data
terproteksi huruf (diwarisi dari
kelas Basis2) dan anggota data privat
riil (dideklarasikan di dalam kelas Terderivasi).
Sekarang
akan diuji fungsi main (Gambar 13.11)
yang menguji kelas-kelas pada Gambar 13.7 - 13.10. Baris 11 menciptakan objek Basis1, basis1, dan menginisialisasinya dengan nilai int 10, kemudian menciptakan pointer basis1Ptr dan menginisialisasinya dengan pointer null. Baris 12 menciptakan objek Basis2, basis2, dan menginisialisasinya dengan nilai char ‘Z’, kemudian menciptakan pointer basis2Ptr. Baris 13 menciptakan objek Terderivasi, terderivasi,
dan menginisialisasinya untuk memuat nilai int
7, nilai char ‘A’, dan nilai double 3.5.
Gambar 13.11 Menguji pewarisan jamak
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
// Gambar 13.11: gambar13_11.cpp
// Menguji pewarisan jamak.
#include <iostream>
#include "Basis1.h"
#include "Basis2.h"
#include "Terderivasi.h"
using namespace std;
int main()
{
Basis1 basis1( 10 ), *basis1Ptr = 0; //
menciptakan objek Basis1
Basis2 basis2( 'Z' ), *basis2Ptr = 0; //
menciptakan objek Basis2
Terderivasi terderivasi( 7, 'A', 3.5 ); // menciptakan objek
Terderivasi
// menampilkan anggota-anggora data dari
objek kelas basis
cout << "Objek basis1 memuat
integer " << basis1.getData()
<< "\nObjek basis2 memuat
karakter " << basis2.getData()
<< "\nObjek terderivasi
memuat:\n" << terderivasi << "\n\n";
// menampilkan anggota-anggota data dari
objek kelas terderivasi
// operator resolusi skop memecahkan masalah
ambiguitas getData
cout << "Anggota-anggota
data dari kelas Terderivasi dapat diakses secara individual:"
<< "\n Integer: "
<< terderivasi.Basis1::getData()
<< "\n Karakter: "
<< terderivasi.Basis2::getData()
<< "\nBilangan riil: "
<< terderivasi.getRiil()
<< "\n\n";
cout << "Terderivasi
dapat dipandang sebagai objek dari kelas basis:\n";
// memperlakukan Terderivasi sebagai objek
Basis1
basis1Ptr = &terderivasi;
cout << "basis1Ptr->getData()
menghasilkan " << basis1Ptr->getData() << '\n';
// memperlakukan Terderivasi sebagai objek
Basis2
basis2Ptr = &terderivasi;
cout << "basis2Ptr->getData()
menghasilkan " << basis2Ptr->getData() << endl;
} // akhir dari main
|
Objek
basis1 memuat integer 10
Objek
basis2 memuat karakter Z
Objek terderivasi
memuat:
Integer: 7
Karakter: A
Bilangan riil: 3.5
Anggota-anggota
data dari kelas Terderivasi dapat diakses secara individual:
Integer: 7
Karakter: A
Bilangan riil: 3.5
Terderivasi dapat dipandang sebagai objek dari kelas
basis:
basis1Ptr->getData() menghasilkan 7
basis2Ptr->getData() menghasilkan A
Baris
16-18 menampilkan nilai-nilai data setiap objek. Untuk objek basis1 dan basis2, dipanggil fungsi anggota getData dari setiap objek. Meskipun terdapat dua fungsi getData pada contoh ini, pemanggilan
terhadap fungsi itu tidak menjadi ambigu. Pada baris 16, kompiler mengetahui
bahwa basis1 merupakan objek dari
kelas Basis1, sehingga getData dari kelas Basis1 yang dipanggil. Pada baris 17, kompiler mengetahui bahwa basis2 merupakan objek dari kelas Basis2, sehingga getData dari kelas Basis2
yang dipanggil. Baris 18 menampilkan isi objek terderivasi menggunakan operator penyisipan stream teroverload.
13.8 Pewarisan Jamak dan Kelas Basis
virtual
Pewarisan
jamak digunakan, misalnya, di dalam pustaka C++ standard untuk membentuk kelas basic_iostream (Gambar 13.12).
Gambar
13.12 Pewarisan jamak untuk membentuk kelas basic_iostream
Kelas
basic_ios merupakan kelas basis bagi
kedua kelas basic_istream dan basic_ostream, masing-masing dibentuk
dari pewarisan tunggal. Hal ini memampukan objek-objek kelas basic_iostram untuk menyediakan
fungsionalitas dari basic_istream dan
basic_ostream. Dalam hirarki
pewarisan jamak, situasi yang dideskripsikan pada Gambar 13.12 dikenal pula
dengan pewarisan diamond.
Karena
kelas basic_istream dan basic_ostream masing-masing mewarisi basic_ios, masalah berpotensi terjadi
pada basic_iostream. Kelas basic_iostream dapat memuat dua salinan
dari anggota kelas basic_ios, satu
diwarisi melalui kelas basic_istream
dan satu lagi diwarisi melalui kelas basic_ostream.
Situasi semacam itu akan menjadi ambigu dan dapat menyebabkan error kompilasi,
karena kompiler tidak akan mengetahui versi mana dari angota kelas basic_ios yang digunakan. Pada bagian
ini, Anda akan melihat bagaimana menggunakan kelas basis virtual untuk menyelasikan masalah pewarisan dari kelas basis
tak-langsung.
Error Kompilasi
Dihasilkan Ketika Ambiguitas Terjadi dalam Hirarki Diamond
Gambar
13.13 mendemonstrasikan ambiguitas yang dapat terjadi di dalam hirarki diamond.
Kelas Basis (baris 8-12) memuat fungsi
virtual, tampil, pada baris 11. Kelas TerderivasiSatu
(baris 15-23) dan TerderivasiDua
(baris 26-34) masing-masing secara publik mewarisi dari Basis dan mengoverride
fungsi tampil.
Gambar 13.13 Pewarisan Jamak
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
// Gambar 13.13: gambar13_13.cpp
// Mencoba secara polimorfik memanggil
sebuah fungsi
// yang secara jamak diwarisi dari dua kelas
basis.
#include <iostream>
using namespace std;
// definisi kelas Basis
class Basis
{
public:
virtual void tampil() const = 0; // fungsi virtual
}; // akhir dari kelas Basis
// definisi kelas TerderivasiSatu
class TerderivasiSatu : public Basis
{
public:
//
mengoverride fungsi tampil
void
tampil() const
{
cout
<< "TerderivasiSatu\n";
} //
akhir dari fungsi tampil
}; // akhir dari kelas TerderivasiSatu
// definisi kelas TerderivasiSatu
class TerderivasiDua : public Basis
{
public:
//
mengoverride fungsi tampil
void
tampil() const
{
cout
<< "TerderivasiDua\n";
} //
akhir dari fungsi tampil
}; // akhir dari kelas TerderivasiDua
// definisi kelas Jamak
class Jamak : public TerderivasiSatu, public
TerderivasiDua
{
public:
//
menentukan versi mana dari fungsi tampil
void
tampil() const
{
TerderivasiDua::tampil();
} //
akhir dari fungsi tampil
}; // akhir dari kelas Jamak
int main()
{
Jamak keduanya; // menginstansiasi objek
Jamak
TerderivasiSatu satu; // menginstansiasi
objek TerderivasiSatu
TerderivasiDua dua; // menginstansiasi
TerderivasiDua
Basis *array[ 3 ]; // menciptakan array yang
memuat pointer kelas basis
array[ 0 ] = &keduanya; // ERROR--ambigu
array[ 1 ] = &satu;
array[ 2 ] = &dua;
// secara polimorfik memanggil fungsi tampil
for ( int i = 0; i < 3; ++i
)
array[ i ] -> tampil();
} // akhir main
|
gambar22_13.cpp:
In function ‘int main()’:
gambar22_13.cpp:54:
error: ‘Basis’ is an ambiguous base of ‘Jamak’
Kelas
Jamak (baris 37-45) mewarisi kedua
kelas TerderivasiSatu dan TerderivasiDua. Dalam kelas Jamak, fungsi tampil dioverride (didefinisikan-ulang) untuk
memanggil fungsi tampil pada kelas TerderivasiDua (baris 43). Perhatikan
bahwa Anda harus mencantumkan pemanggilan tampil
dengan nama kelas TerderivasiDua
untuk menentukan versi tampil yang
mana yang akan dipanggil.
Fungsi
main (baris 47-61) mendeklarasikan
objek-objek kelas Jamak (baris 49), TerderivasiSatu (baris 50) dan TerderivasiDua (baris 51). Baris 52
mendeklarasikan sebuah array yang memuat pointer-pointer Basis *. Setiap elemen array diinisialisasi dengan alamat suatu objek
(baris 54-56). Error akan terjadi bila alamat dari keduanya, sebuah objek kelas Jamak,
ditugaskan kepada array[0]. Objek keduanya sebenarnya memuat dua subobjek
bertipe Basis, sehingga kompiler
tidak mengetahui subobjek yang mana yang ditunjuk oleh array[0] dan membangkitkan error kompilasi yang mengindikasikan
suatu konversi ambigu.
Masalah
ini diatasi dengan pewarisan virtual.
Ketika sebuah kelas basis diwarisi sebagai virtual,
maka hanya akan ada satu subobjek yang akan muncul di dalam kelas terderivasi.
Proses ini dikenal dengan pewarisan kelas-basis virtual. Gambar 13.14 merevisi program pada Gambar 13.13 dengan
menggunakan sebuah kelas basis virtual.
Gambar 13.14 Pewarisan Jamak dengan Pewarisan
virtual
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
// Gambar 13.14: gambar13_14.cpp
// Menggunakan kelas basis virtual
#include <iostream>
using namespace std;
// definisi kelas Basis
class Basis
{
public:
virtual void tampil() const = 0; // fungsi virtual
}; // akhir dari kelas Basis
// definisi kelas TerderivasiSatu
class TerderivasiSatu : public Basis
{
public:
//
mengoverride fungsi tampil
void
tampil() const
{
cout
<< "TerderivasiSatu\n";
} //
akhir dari fungsi tampil
}; // akhir dari kelas TerderivasiSatu
// definisi kelas TerderivasiSatu
class TerderivasiDua : public Basis
{
public:
//
mengoverride fungsi tampil
void
tampil() const
{
cout
<< "TerderivasiDua\n";
} //
akhir dari fungsi tampil
}; // akhir dari kelas TerderivasiDua
// definisi kelas Jamak
class Jamak : public TerderivasiSatu, public
TerderivasiDua
{
public:
//
menentukan versi mana dari fungsi tampil
void
tampil() const
{
TerderivasiDua::tampil();
} //
akhir dari fungsi tampil
}; // akhir dari kelas Jamak
int main()
{
Jamak keduanya; // menginstansiasi objek
Jamak
TerderivasiSatu satu; // menginstansiasi
objek TerderivasiSatu
TerderivasiDua dua; // menginstansiasi
TerderivasiDua
// mendeklarasikan array, memuat pointer-pointer
kelas basis dan
// menginisialisasi setiap elemen dengan objek
bertipe kelas-terderivasi
Basis
*array[ 3 ];
array[ 0 ] = &keduanya;
array[ 1 ] = &satu;
array[ 2 ] = &dua;
// secara polimorfik memanggil fungsi tampil
for ( int i = 0; i < 3; ++i
)
array[ i ] -> tampil();
} // akhir main
|
TerderivasiDua
TerderivasiSatu
TerderivasiDua
Kunci
perubahan di sini adalah bahwa kelas TerderivasiSatu
(baris 14) dan TerderivasiDua (baris
25) masing-masing mewarisi dari Basis
dengan menspesifikasi virtual public
Basis. Karena kedua kelas tersebut mewarisi dari Basis, maka masing-masing memuat subobjek Basis. Keuntungan pewarisan virtual
tidak menjadi jelas sampai kelas Jamak
mewarisi TerderivasiSatu dan TerderivasiDua (baris 36). Karena tiap
kelas basis itu menggunakan pewarisan virtual untuk mewarisi anggota-anggota
kelas Basis, kompiler memastikan
bahwa hanya terdapat satu subobjek Basis
yang diwariskan kepada kelas Jamak.
Hal ini mengeliminasi error ambiguitas yang dibangkitkan kompiler pada Gambar 13.13.
Kompiler sekarang mengijinkan konversi implisit atas pointer kelas-terderivasi (&keduanya) menjadi pointer kelas-basis array[0] pada baris 55 di dalam main.
Statemen for pada baris 60-61 secara
polimorfik memanggil tampil untuk
tiap objek.
Kesimpulan
C++ menyediakan operator const_cast untuk membuang kualifikasi const atau volatile.
Program mendeklarasikan sebuah
variabel dengan kualifikasi volatile
ketika program tersebut mengharapkan variabel itu dapat dimodifikasi oleh
program lain. Pendeklarasian sebuah variabel sebagai volatile mengindikasikan bahwa kompiler tidak mengoptimasikan
penggunaan variabel tersebut, karena, jika begitu, akan mempengaruhi kemampuan
program lain untuk mengakses dan memodifikasi variabel volatile tersebut.
Secara umum, adalah berbahaya
menggunakan operator const_cast,
karena hal itu mengijinkan program untuk memodifikasi variabel yang telah
dideklarasikan const, yang seharusnya
tidak boleh dimodifikasi.
Pemodifikasi mutable dan const_cast
digunakan dalam konteks yang berbeda. Pada objek const tanpa memiliki anggota data mutable, operator const_cast
dapat digunakan setiap kali anggota perlu dimodifikasi. Hal ini akan mereduksi
peluang suatu anggota dimodifikasi secara tak sengaja karena anggota secara
permanen tidak dapat dimodifikasi (tanpa penggunaan const_cast).
Suatu program dapat menyertakan banyak
pengenal yang didefinisikan dalam berbagai skop. Kadangkala variabel dalam
suatu skop tumpang-tindih (bertubrukan) dengan suatu variabel bernama sama
dalam skop yang berbeda, yang kemungkinan akan menyebabkan konflik penamaan.
Kondisi tumpang-tindih semacam itu terjadi pada banyak level.
Ketumpang-tindihan pengenal seringkali terjadi dalam pustaka pihak-ketiga, yang
secara tak-sengaja menggunakan pengenal global yang sama (seperti nama fungsi).
Hal ini akan menyebabkan error kompilasi. C++
standard memecahkan masalah ini dengan penggunaan namespace.
Standard C++ menyediakan beberapa
katakunci operator (Gambar 22.4) yang dapat digunakan untuk menggantikan
beberapa operator C++. Anda bisa menggunakan katakunci operator jika Anda
memiliki papanketik yang tidak mendukung beberapa karakter tertentu seperti !,
&, ^, ~, |, dan lain-lain.
C++ menyediakan operator .* dan
->* untuk mengakses anggota kelas melalui pointer. Ini merupakan kapabilitas
yang jarang dipakai dan hanya digunakan oleh programer C++ handal.
Dalam C++, sebuah kelas dapat
diderivasi dari lebih dari satu kelas basis, suatu teknik yang dikenal sebagai
pewarisan jamak, dimana di dalamnya kelas terderivasi mewarisi
anggota-anggotanya dari dua atau lebih kelas basis. Kapabilitas ini dapat mendorong
pendaur-ulangan kode yang efisien, tetapi dapat pula menyebabkan berbagai
masalah serius. Pewarisan jamak merupakan konsep rumit yang seharusnya hanya
digunakan oleh para programmer berpengalaman. Pada kenyataannya, berbagai
masalah yang disebabkan oleh pewarisan jamak sangat susah dideteksi, sehingga
bahasa pemrograman yang lebih muda, seperti Java dan C#, tidak mengijinkan
sebuah kelas diderivasi dari lebih dari satu kelas basis.
Latihan
1.
Perhatikan
potongan kode di bawah ini dan tentukan apakah setiap statemen true atau false. Jelaskan mengapa demikian.
a)
Variabel kilometer terlihat di dalam namespace Data.
b)
Objek string1 terlihat di dalam namespace Data.
c)
Konstanta AMERIKA tidak terlihat di dalam namespace Data.
d)
Konstanta INDONESIA terlihat di dalam namespace Data.
e)
Fungsi fungsi terlihat di dalam namespace Data.
f)
Namespace Data terlihat di dalam namespace InformasiNegara.
g)
Objek peta terlihat di dalam di dalam namespace InformasiNegara.
h)
Objek string1 terlihat di dalam namespace InformasiRegional.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
namespace InformasiNegara
{
using namespace std;
enum Negara { POLANDIA, SWISS, JERMAN,
INDONESIA, AMERIKA };
int kilometer;
string string1;
namespace InformasiRegional
{
short getPopulasi();
// diasumsikan definisinya ada
PetaData peta; // diasumsikan definisinya
ada
} // akhir dari InformasiRegional
} // akhir dari InformasiNegara
namespace Data
{
using
namespace InformasiNegara:: InformasiRegional;
void *fungsi( void *, int );
} // akhir dari Data
|
2.
Bandingkan
mutable dan const_cast. Berikan sedikitnya satu contoh penggunaan mutable dan cons_cast.
3.
Tulislah
sebuah program yang menggunakan const_cast
untuk memodifikasi sebuah variabel const.
Gunakan pointer untuk menunjuk pengenal const
tersebut.
4.
Apa
kegunaan kelas basis virtual?
5.
Tulislah
sebuah program yang menggunakan kelas basis virtual. Kelas pada hirarki
pewarisan teratas harus menyediakan sebuah konstruktor yang memerlukan
sedikitnya satu argumen (jangan sediakan konstruktor default).
6.
Temukan
dan perbaiki kesalahan pada tiap potongan kode berikut ini:
a) namespace Nama {
int
x;
int
y;
mutable
inte z;
};
b) int integer = const_cast< int >( double );
No comments:
Post a Comment