Logika Pemrograman: Bab 14. Soal & Penyelesaian C++

Monday, December 26, 2016

Bab 14. Soal & Penyelesaian C++

TEMPLATE

Soal & Penyelesaian

1. Tulislah sebuah template fungsi sederhana untuk membandingkan dua nilai.

Penyelesaian:

// maks.cpp

template <typename T>

inline T const& maks (T const& a, T const& b)

{

// jika a < b maka gunakan b sebaliknya gunakan a

return a<b?b:a;

}

#include <iostream>

#include <string>

#include <conio.h>

#include "maks.cpp"

int main()

{

int i = 42;

std::cout << "maks(7,i): " << ::maks(7,i) << std::endl;

double f1 = 3.4;

double f2 = -6.7;

std::cout << "maks(f1,f2): " << ::maks(f1,f2) << std::endl;

std::string s1 = "matematika";

std::string s2 = "martina";

std::cout << "maks(s1,s2): " << ::maks(s1,s2) << std::endl;

getch();

}

maks(7,i): 42

maks(f1,f2): 3.4

maks(s1,s2): matematika

2. Tulislah sebuah program C++ untuk mengilustrasikan penggunaan overload dari fungsi template.

Penyelesaian:

#include <conio.h>

#include <iostream>

#include <string>

// templateOverload.cpp

// maksimum dari dua nilai int

inline int const& maks (int const& a, int const& b)

{

return a<b?b:a;

}

//maksimum dari dua nilai sembarang tipe

template <typename T>

inline T const& maks (T const& a, T const& b)

{

return a<b?b:a;

}

// maksimum dari tiga nilai sembarang tipe

template <typename T>

inline T const& maks (T const& a, T const& b, T const& c)

{

return maks (maks(a,b), c);

}

int main()

{

// memanggil template untuk tiga argumen

std::cout << "maks(7, 42, 68): " << ::maks(7, 42, 68)<< std::endl;

// memanggil maks<double>

std::cout << "maks(7.0, 42.0): " << ::maks(7.0, 42.0)<< std::endl;

// memanggil maks<char>

std::cout << "maks('a', 'b'): " << ::maks('a', 'b')<< std::endl;

// memanggil fungsi tak-template

std::cout << "maks(7, 42): " << ::maks(7, 42)<< std::endl;

// memanggil maks<int>

std::cout << "maks<>(7, 42): " << ::maks<>(7, 42)<< std::endl;

// memanggil maks<double>

std::cout << "maks<double>(7, 42): " << ::maks<double>(7, 42)<< std::endl;

// memanggil fungsi tak-template untuk dua int

std::cout << "maks('a', 42.7): " << ::maks('a', 42.7)<< std::endl;

getch();

}

maks(7, 42, 68): 68

maks(7.0, 42.0): 42

maks('a', 'b'): b

maks(7, 42): 42

maks<>(7, 42): 42

maks<double>(7, 42): 42

maks('a', 42.7): 97

3. Tulislah sebuah program C++ untuk mengoverload fungsi template maksimum untuk pointer dan string-C.

Penyelesaian:

// templatePointer.cpp

#include <iostream>

#include <cstring>

#include <string>

#include <conio.h>

// maksimum dari dua nilai sembarang tipe

template <typename T>

inline T const& maks (T const& a, T const& b)

{

return a < b ? b : a;

}

// maksimum dari dua pointer

template <typename T>

inline T* const& maks (T* const& a, T* const& b)

{

return *a < *b ? b : a;

}

//maksimum dari dua string-C

inline char const* const& maks (char const* const& a, char const* const& b)

{

return std::strcmp(a,b) < 0 ? b : a;

}

int main ()

{

int a=7;

int b=42;

// maks() untuk dua nilai bertipe int

std::cout << "maks(a,b): " << ::maks(a,b)<< std::endl;

std::string s="hai";

std::string t="sayang";

// maks() untuk dua nilai bertipe std::string

std::cout << "maks(s,t): " << ::maks(s,t)<< std::endl;

int* p1 = &b;

int* p2 = &a;

// maks() untuk dua pointer

std::cout << "maks(p1,p2): " << ::maks(p1,p2)<< std::endl;

char const* s1 = "David";

char const* s2 = "Niko";

// maks() untuk dua string-C

std::cout << "maks(s1,s2): " << ::maks(s1,s2)<< std::endl;

getch();

}

maks(a,b): 42

maks(s,t): sayang

maks(p1,p2): 0034F728

maks(s1,s2): Niko

4. Tulislah sebuah program C++ untuk mendemonstrasikan suatu template fungsi.

Penyelesaian:

//templateFungsi.cpp

#include <iostream>

#include <conio.h>

using namespace std;

//Menukar nilai variabel1 dan variabel2.

template<class T>

void tukar_nilai(T& variabel1, T& variabel2)

{

T temp;

temp = variabel1;

variabel1 = variabel2;

variabel2 = temp;

}

int main( )

{

int integer1 = 1, integer2 = 2;

cout << "Nilai-nilai integer yang asli adalah "

<< integer1 << " " << integer2 << endl;

tukar_nilai(integer1, integer2);

cout << "Nilai-nilai integer hasil penukaran adalah "

<< integer1 << " " << integer2 << endl;

char simbol1 = 'A', simbol2 = 'B';

cout << "Nilai-nilai karakter yang asli adalah "

<< simbol1 << " " << simbol2 << endl;

tukar_nilai(simbol1, simbol2);

cout << "Nilai-nilai karakter hasil penukaran adalah "

<< simbol1 << " " << simbol2 << endl;

getch();

return 0;

}

Nilai-nilai integer yang asli adalah 1 2

Nilai-nilai integer hasil penukaran adalah 2 1

Nilai-nilai karakter yang asli adalah A B

Nilai-nilai karakter hasil penukaran adalah B A

5. Tulislah sebuah program C++ untuk mendemonstrasikan suatu fungsi pengurutan generik.

Penyelesaian:

//templateFungsiPengurutan.cpp

//Mendemonstrasikan sebuah fungsi pengurutan generik.

#include <iostream>

#include <conio.h>

using namespace std;

template<class T>

void tukar_nilai(T& variabel1, T& variabel2)

{

T temp;

temp = variabel1;

variabel1 = variabel2;

variabel2 = temp;

}

template<class BaseType>

int indeks_terkecil(const BaseType a[], int indeks_awal, int jumlah_digunakan)

{

BaseType min = a[indeks_awal];

int indeks_min = indeks_awal;

for (int indeks = indeks_awal + 1; indeks < jumlah_digunakan; indeks++)

if (a[indeks] < min)

{

min = a[indeks];

indeks_min = indeks;

//min adalah yang terkecil dari a[indeks_awal] sampai a[indeks]

}

return indeks_min;

}

template<class BaseType>

void urut(BaseType a[], int jumlah_digunakan)

{

int indeks_dekat_terkecil;

for(int indeks = 0; indeks < jumlah_digunakan - 1; indeks++)

{//Menempatkan nilai yang tepat pada a[indeks]:

indeks_dekat_terkecil =

indeks_terkecil(a, indeks, jumlah_digunakan);

tukar_nilai(a[indeks], a[indeks_dekat_terkecil]);

}

int main( )

{

int i;

int a[10] = {9, 8, 7, 6, 5, 1, 2, 3, 0, 4};

cout << "Integer-integer tak-terurut:\n";

for (i = 0; i < 10; i++)

cout << a[i] << " ";

cout << endl;

urut(a, 10);

cout << "Dalam tatanan terurut, integer-integer tersebut menjadi:\n";

for (i = 0; i < 10; i++)

cout << a[i] << " ";

cout << endl;

double b[5] = {5.5, 4.4, 1.1, 3.3, 2.2};

cout << "Double-double tak-terurut:\n";

for (i = 0; i < 5; i++)

cout << b[i] << " ";

cout << endl;

urut(b, 5);

cout << "Dalam tatanan terurut, double-double tersebut menjadi:\n";

for (i = 0; i < 5; i++)

cout << b[i] << " ";

cout << endl;

char c[7] = {'G', 'E', 'N', 'E', 'R', 'I', 'K'};

cout << "Karakter-karakter tak-terurut:\n";

for (i = 0; i < 7; i++)

cout << c[i] << " ";

cout << endl;

urut(c, 7);

cout << "Dalam tatanan terurut, karakter-karakter tersebut menjadi:\n";

for (i = 0; i < 7; i++)

cout << c[i] << " ";

cout << endl;

getch();

return 0;

}

Integer-integer tak-terurut:

9 8 7 6 5 1 2 3 0 4

Dalam tatanan terurut, integer-integer tersebut menjadi:

0 1 2 3 4 5 6 7 8 9

Double-double tak-terurut:

5.5 4.4 1.1 3.3 2.2

Dalam tatanan terurut, double-double tersebut menjadi:

1.1 2.2 3.3 4.4 5.5

Karakter-karakter tak-terurut:

G E N E R I K

Dalam tatanan terurut, karakter-karakter tersebut menjadi:

E E G I K N R

6. Tulislah sebuah program C++ untuk mendemonstrasikan template array.

Penyelesaian:

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

// templateArray.cpp

#include <iostream>

#include <conio.h>

const int UkuranDefault = 10;

// mendeklarasikan kelas Binatang sederhana sehingga Anda

// menciptakan sebuah array yang memuat bianatang-binatang

class Binatang

{

public:

Binatang(int);

Binatang();

~Binatang() {}

int GetBerat() const { return beratNya; }

void Tampil() const { std::cout << beratNya; }

private:

int beratNya;

};

Binatang::Binatang(int berat):beratNya(berat)

{}

Binatang::Binatang():beratNya(0)

{}

template <class T> // mendeklarasikan array dan parameter

class Array // kelas yang sedang diparameterisasi

{

public:

// konstruktor

Array(int ukuranNya = UkuranDefault);

Array(const Array &rhs);

~Array() { delete [] pType; }

// operator

Array& operator=(const Array&);

T& operator[](int offSet) { return pType[offSet]; }

const T& operator[](int offSet) const

{ return pType[offSet]; }

// aksesor

int GetUkuran() const { return ukuranNya; }

private:

T *pType;

int ukuranNya;

};

// mengimplementasikan konstruktor

template <class T>

Array<T>::Array(int ukuran):ukuranNya(ukuran)

{

pType = new T[ukuran];

// konstruktor dari tipe yang Anda ciptakan

// harus menetapkan nilai default

}

// konstruktor penyalin

template <class T>

Array<T>::Array(const Array &rhs)

{

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

}

// operator=

template <class T>

Array<T>& Array<T>::operator=(const Array &rhs)

{

if (this == &rhs)

return *this;

delete [] pType;

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

return *this;

}

// program penguji

int main()

{

Array<int> arrayKu; // sebuah array yang memuat integer-integer

Array<Binatang> kebunBinatang; // sebuah array yang memuat Binatang-Binatang

Binatang *pBinatang;

// mengisi array

for (int i = 0; i < arrayKu.GetUkuran(); i++)

{

arrayKu[i] = i*2;

pBinatang = new Binatang(i*3);

kebunBinatang[i] = *pBinatang;

delete pBinatang;

}

// menampilkan isi array

for (int j = 0; j < arrayKu.GetUkuran(); j++)

{

std::cout << "arrayKu[" << j << "]:\t";

std::cout << arrayKu[j] << "\t\t";

std::cout << "kebunBinatang[" << j << "]:\t";

kebunBinatang[j].Tampil();

std::cout << std::endl;

}

getch();

return 0;

}

arrayKu[0]: 0 kebunBinatang[0]: 0

arrayKu[1]: 2 kebunBinatang[1]: 3

arrayKu[2]: 4 kebunBinatang[2]: 6

arrayKu[3]: 6 kebunBinatang[3]: 9

arrayKu[4]: 8 kebunBinatang[4]: 12

arrayKu[5]: 10 kebunBinatang[5]: 15

arrayKu[6]: 12 kebunBinatang[6]: 18

arrayKu[7]: 14 kebunBinatang[7]: 21

arrayKu[8]: 16 kebunBinatang[8]: 24

arrayKu[9]: 18 kebunBinatang[9]: 27

7. Adalah memungkinkan untuk mendeklarasikan sembarang kelas atau fungsi yang menjadi friend dari kelas template Anda. Setiap instans (objek) dari kelas tersebut akan memperlakukan friend dengan sepantasnya, sama seperti pertemanan pada kehidupan nyata. Tambahkanlah sebuah fungsi friend, CampurTangan(), pada definisi template pada kelas Array pada soal nomor 6 tersebut.

Penyelesaian:

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

// templateKelasFriend.cpp

#include <iostream>

#include <conio.h>

using namespace std;

const int UkuranDefault = 10;

// mendeklarasikan kelas Binatang sederhana sehingga Anda

// menciptakan sebuah array yang memuat bianatang-binatang

class Binatang

{

public:

Binatang(int);

Binatang();

~Binatang() {}

int GetBerat() const { return beratNya; }

void Tampil() const { std::cout << beratNya; }

private:

int beratNya;

};

Binatang::Binatang(int berat):beratNya(berat)

{}

Binatang::Binatang():beratNya(0)

{}

template <class T> // mendeklarasikan array dan parameter

class Array // kelas yang sedang diparameterisasi

{

public:

// konstruktor

Array(int ukuranNya = UkuranDefault);

Array(const Array &rhs);

~Array() { delete [] pType; }

// operator

Array& operator=(const Array&);

T& operator[](int offSet) { return pType[offSet]; }

const T& operator[](int offSet) const

{ return pType[offSet]; }

// aksesor

int GetUkuran() const { return ukuranNya; }

// fungsi friend

friend void CampurTangan(Array<int>);

private:

T *pType;

int ukuranNya;

};

// fungsi friend. Tidak berupa fungsi template. Jadi, ia hanya dapat dipakai

// dengan array int!.

void CampurTangan(Array<int> arrayMu)

{

cout << endl << "*** CampurTangan ***" << endl;

for (int i = 0; i < arrayMu.ukuranNya; i++)

cout << "i: " << arrayMu.pType[i] << endl;

cout << endl;

}

// mengimplementasikan konstruktor

template <class T>

Array<T>::Array(int ukuran):ukuranNya(ukuran)

{

pType = new T[ukuran];

// konstruktor dari tipe yang Anda ciptakan

// harus menetapkan nilai default

}

// konstruktor penyalin

template <class T>

Array<T>::Array(const Array &rhs)

{

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

}

// operator=

template <class T>

Array<T>& Array<T>::operator=(const Array &rhs)

{

if (this == &rhs)

return *this;

delete [] pType;

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

return *this;

}

// program penguji

int main()

{

Array<int> arrayKu; // sebuah array yang memuat integer-integer

Array<Binatang> kebunBinatang; // sebuah array yang memuat Binatang-Binatang

Binatang *pBinatang;

// mengisi array

for (int i = 0; i < arrayKu.GetUkuran(); i++)

{

arrayKu[i] = i*2;

pBinatang = new Binatang(i*3);

kebunBinatang[i] = *pBinatang;

}

int j;

for (j = 0; j < arrayKu.GetUkuran(); j++)

{

cout << "kebunBinatang[" << j << "]:\t";

kebunBinatang[j].Tampil();

cout << endl;

}

cout << "Sekarang menggunakan fungsi friend untuk";

cout << "mencari anggota-anggota dari Array<int>";

CampurTangan(arrayKu);

cout << endl <<"Selesai." << endl;

getch();

return 0;

}

kebunBinatang[0]: 0

kebunBinatang[1]: 3

kebunBinatang[2]: 6

kebunBinatang[3]: 9

kebunBinatang[4]: 12

kebunBinatang[5]: 15

kebunBinatang[6]: 18

kebunBinatang[7]: 21

kebunBinatang[8]: 24

kebunBinatang[9]: 27

Sekarang menggunakan fungsi friend untukmencari anggota-anggota dari Array<int>

*** CampurTangan ***

i: 0

i: 2

i: 4

i: 6

i: 8

i: 10

i: 12

i: 14

i: 16

i: 18

Selesai.

8. Tambahkanlah fungsi friend operator<< pada soal nomor 6 dan ujilah program tersebut.

Penyelesaian:

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

// templateFriendOperator.cpp

#include <iostream>

#include <conio.h>

using namespace std;

const int UkuranDefault = 10;

// mendeklarasikan kelas Binatang sederhana sehingga Anda

// menciptakan sebuah array yang memuat bianatang-binatang

class Binatang

{

public:

Binatang(int);

Binatang();

~Binatang() {}

int GetBerat() const { return beratNya; }

void Tampil() const { cout << beratNya; }

private:

int beratNya;

};

Binatang::Binatang(int berat):beratNya(berat)

{}

Binatang::Binatang():beratNya(0)

{}

template <class T> // mendeklarasikan array dan parameter

class Array // kelas yang sedang diparameterisasi

{

public:

// konstruktor

Array(int ukuranNya = UkuranDefault);

Array(const Array &rhs);

~Array() { delete [] pType; }

// operator

Array& operator=(const Array&);

T& operator[](int offSet) { return pType[offSet]; }

const T& operator[](int offSet) const

{ return pType[offSet]; }

// aksesor

int GetUkuran() const { return ukuranNya; }

template <class T>

friend ostream& operator<< (ostream&, Array<T>&);

private:

T *pType;

int ukuranNya;

};

template <class T>

ostream& operator<< (ostream& keluaran, Array<T>& arrayMu)

{

for (int i = 0; i < arrayMu.ukuranNya; i++)

keluaran << "[" << i << "] " << arrayMu[i] << endl;

return keluaran;

}

// mengimplementasikan konstruktor

template <class T>

Array<T>::Array(int ukuran):ukuranNya(ukuran)

{

pType = new T[ukuran];

for (int i = 0; i < ukuran; i++)

pType[i] = 0;

}

// konstruktor penyalin

template <class T>

Array<T>::Array(const Array &rhs)

{

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

}

// operator=

template <class T>

Array<T>& Array<T>::operator=(const Array &rhs)

{

if (this == &rhs)

return *this;

delete [] pType;

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

return *this;

}

// program penguji

int main()

{

bool Berhenti = false; // bendera untuk loop

int offset, nilai;

Array<int> arrayKu;

while (Berhenti == false)

{

cout << "Masukkan sebuah offset (0-9) ";

cout << "dan sebuah nilai. (-1 untuk berhenti): ";

cin >> offset >> nilai;

if (offset < 0)

break;

if (offset > 9)

{

cout << "***Gunakan nilai antara 0 dan 9.***\n";

continue;

}

arrayKu[offset] = nilai;

}

cout << "\nBerikut adalah isi array:\n";

cout << arrayKu << endl;

getch();

return 0;

}

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 1 10

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 2 20

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 3 30

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 4 40

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 5 50

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 6 60

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 7 70

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 8 80

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 9 90

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): 10 10

***Gunakan nilai antara 0 dan 9.***

Masukkan sebuah offset (0-9) dan sebuah nilai. (-1 untuk berhenti): -1 -1

Berikut adalah isi array:

[0] 0

[1] 10

[2] 20

[3] 30

[4] 40

[5] 50

[6] 60

[7] 70

[8] 80

[9] 90

9. Anda dapat memperlakukan item-item template seperti tipe lainnya. Anda dapat melewatkannya sebagai parameter, baik dengan referensi atau dengan nilai, dan Anda dapat menjadikannya sebagai nilai balik dari fungsi baik dengan nilai atau dengan referensi. Demonstrasikanlah hal ini.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

// templatePelewatanItem.cpp

#include <iostream>

#include <conio.h>

using namespace std;

const int UkuranDefault = 10;

// mendeklarasikan kelas Binatang sederhana sehingga Anda

// menciptakan sebuah array yang memuat bianatang-binatang

class Binatang

{

public:

// konstruktor

Binatang(int);

Binatang();

~Binatang();

// aksesor

int GetBerat() const { return beratNya; }

void SetBerat(int berat) { beratNya = berat; }

// operator frien

friend ostream& operator<< (ostream&, const Binatang&);

private:

int beratNya;

};

// operator ekstraksi untuk menampilkan binatang

ostream& operator<<

(ostream& aliran, const Binatang& binatangKu)

{

aliran << binatangKu.GetBerat();

return aliran;

}

Binatang::Binatang(int berat): beratNya(berat)

{

// cout << "Binatang(int)" << endl;

}

Binatang::Binatang(): beratNya(0)

{

// cout << "Binatang()" << endl;

}

Binatang::~Binatang()

{

// cout << "Menghancurkan sebuah binatang..." << endl;

}

template <class T> // mendeklarasikan array dan parameter

class Array // kelas yang sedang diparameterisasi

{

public:

// konstruktor

Array(int ukuranNya = UkuranDefault);

Array(const Array &rhs);

~Array() { delete [] pType; }

// operator

Array& operator=(const Array&);

T& operator[](int offSet) { return pType[offSet]; }

const T& operator[](int offSet) const

{ return pType[offSet]; }

// aksesor

int GetUkuran() const { return ukuranNya; }

template <class T>

friend ostream& operator<< (ostream&, Array<T>&);

private:

T *pType;

int ukuranNya;

};

template <class T>

ostream& operator<< (ostream& keluaran, Array<T>& arrayMu)

{

for (int i = 0; i < arrayMu.ukuranNya; i++)

keluaran << "[" << i << "] " << arrayMu[i] << endl;

return keluaran;

}

// mengimplementasikan konstruktor

template <class T>

Array<T>::Array(int ukuran):ukuranNya(ukuran)

{

pType = new T[ukuran];

for (int i = 0; i < ukuran; i++)

pType[i] = 0;

}

// konstruktor penyalin

template <class T>

Array<T>::Array(const Array &rhs)

{

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

}

// operator=

template <class T>

Array<T>& Array<T>::operator=(const Array &rhs)

{

if (this == &rhs)

return *this;

delete [] pType;

ukuranNya = rhs.GetUkuran();

pType = new T[ukuranNya];

for (int i = 0; i<ukuranNya; i++)

pType[i] = rhs[i];

return *this;

}

void FungsiIsiInt(Array<int>& arrayKu);

void FungsiIsiBinatang(Array<Binatang>& arrayKu);

// program penguji

int main()

{

Array<int> arrayInt;

Array<Binatang> arrayBinatang;

FungsiIsiInt(arrayInt);

FungsiIsiBinatang(arrayBinatang);

cout << "arrayInt...\n" << arrayInt;

cout << "\narrayBinatang...\n" << arrayBinatang << endl;

getch();

return 0;

}

void FungsiIsiInt(Array<int>& arrayKu)

{

bool Berhenti = false; // bendera untuk loop

int offset, nilai;

while (Berhenti == false)

{

cout << "Masukkan sebuah offset (0-9) ";

cout << "dan sebuah nilai. (-1 untuk berhenti): ";

cin >> offset >> nilai;

if (offset < 0)

break;

if (offset > 9)

{

cout << "***Gunakan nilai antara 0 dan 9.***\n";

continue;

}

arrayKu[offset] = nilai;

}

void FungsiIsiBinatang(Array<Binatang>& arrayKu)

{

Binatang * pBinatang;

for (int i = 0; i < arrayKu.GetUkuran(); i++)

{

pBinatang = new Binatang;

pBinatang->SetBerat(i*100);

arrayKu[i] = *pBinatang;

delete pBinatang; // sebuah salinan ditaruh ke dalam array