Template adalah fitur dalam C++ yang memungkinkan pembuatan kode generik. Dengan template, Anda dapat menulis fungsi atau kelas yang bekerja dengan tipe data yang berbeda tanpa harus menduplikasi kode untuk setiap tipe. Template sering digunakan untuk meningkatkan fleksibilitas dan reusability kode.
1. Template Fungsi
Template fungsi memungkinkan Anda membuat fungsi yang dapat bekerja dengan berbagai tipe data. Anda menggunakan kata kunci template diikuti oleh parameter template.
Sintaks Template Fungsi
template <typename T>
T namaFungsi(T argumen) {
// Implementasi fungsi
}Tadalah parameter template yang dapat berupa tipe data apa saja.- Anda dapat menggunakan lebih dari satu parameter template:
template <typename T, typename U>.
Contoh Template Fungsi
#include <iostream>
using namespace std;
// Template fungsi
template <typename T>
T maksimum(T a, T b) {
return (a > b) ? a : b;
}
int main() {
cout << "Maksimum dari 10 dan 20 adalah: " << maksimum(10, 20) << endl;
cout << "Maksimum dari 3.5 dan 2.1 adalah: " << maksimum(3.5, 2.1) << endl;
cout << "Maksimum dari 'A' dan 'B' adalah: " << maksimum('A', 'B') << endl;
return 0;
}Output:
Maksimum dari 10 dan 20 adalah: 20
Maksimum dari 3.5 dan 2.1 adalah: 3.5
Maksimum dari 'A' dan 'B' adalah: B2. Template Kelas
Template kelas memungkinkan pembuatan kelas generik yang dapat digunakan dengan berbagai tipe data. Hal ini sering digunakan untuk implementasi struktur data seperti stack, queue, atau vector.
Sintaks Template Kelas
template <typename T>
class NamaKelas {
private:
T data;
public:
NamaKelas(T nilai) : data(nilai) {}
T getData() {
return data;
}
};Contoh Template Kelas
#include <iostream>
using namespace std;
// Template kelas
template <typename T>
class Kotak {
private:
T panjang, lebar, tinggi;
public:
Kotak(T p, T l, T t) : panjang(p), lebar(l), tinggi(t) {}
T volume() {
return panjang * lebar * tinggi;
}
};
int main() {
Kotak<int> kotak1(3, 4, 5);
Kotak<double> kotak2(3.5, 4.2, 5.1);
cout << "Volume kotak1: " << kotak1.volume() << endl;
cout << "Volume kotak2: " << kotak2.volume() << endl;
return 0;
}Output:
Volume kotak1: 60
Volume kotak2: 75.393. Template dengan Beberapa Parameter
Template juga dapat memiliki lebih dari satu parameter tipe.
Contoh Template Fungsi dengan Banyak Parameter
#include <iostream>
using namespace std;
// Template fungsi dengan dua parameter
template <typename T1, typename T2>
void tampilkan(T1 a, T2 b) {
cout << "Nilai a: " << a << ", Nilai b: " << b << endl;
}
int main() {
tampilkan(10, 20.5);
tampilkan("Hello", 100);
return 0;
}Output:
Nilai a: 10, Nilai b: 20.5
Nilai a: Hello, Nilai b: 100Contoh Template Kelas dengan Banyak Parameter
#include <iostream>
using namespace std;
// Template kelas dengan dua parameter
template <typename T1, typename T2>
class Pasangan {
private:
T1 pertama;
T2 kedua;
public:
Pasangan(T1 p, T2 k) : pertama(p), kedua(k) {}
void tampilkan() {
cout << "Pertama: " << pertama << ", Kedua: " << kedua << endl;
}
};
int main() {
Pasangan<int, double> pasangan1(10, 20.5);
Pasangan<string, int> pasangan2("Hello", 100);
pasangan1.tampilkan();
pasangan2.tampilkan();
return 0;
}Output:
Pertama: 10, Kedua: 20.5
Pertama: Hello, Kedua: 1004. Template dengan Parameter Default
Anda juga dapat memberikan nilai default untuk parameter template.
Contoh Template Kelas dengan Parameter Default
#include <iostream>
using namespace std;
template <typename T = int>
class Angka {
private:
T nilai;
public:
Angka(T n) : nilai(n) {}
T getNilai() {
return nilai;
}
};
int main() {
Angka<> angka1(10); // Default tipe int
Angka<double> angka2(20.5); // Tipe double
cout << "Nilai angka1: " << angka1.getNilai() << endl;
cout << "Nilai angka2: " << angka2.getNilai() << endl;
return 0;
}Output:
Nilai angka1: 10
Nilai angka2: 20.55. Template Spesialisasi
Template dapat dispesialisasikan untuk tipe data tertentu, memberikan implementasi khusus untuk tipe tersebut.
Contoh Template Spesialisasi
#include <iostream>
using namespace std;
// Template umum
template <typename T>
class Cetak {
public:
void tampilkan(T nilai) {
cout << "Nilai: " << nilai << endl;
}
};
// Spesialisasi untuk tipe string
template <>
class Cetak<string> {
public:
void tampilkan(string nilai) {
cout << "String: " << nilai << endl;
}
};
int main() {
Cetak<int> cetak1;
Cetak<string> cetak2;
cetak1.tampilkan(100); // Menggunakan template umum
cetak2.tampilkan("Hello"); // Menggunakan spesialisasi
return 0;
}Output:
Nilai: 100
String: HelloKeuntungan Template
- Reusability: Satu template dapat digunakan untuk berbagai tipe data.
- Efisiensi Kode: Mengurangi duplikasi kode untuk fungsi atau kelas yang serupa.
- Generik: Mempermudah penanganan tipe data yang berbeda dengan cara yang konsisten.
Jika Anda membutuhkan contoh tambahan atau implementasi template untuk kasus tertentu, beri tahu saya! 😊
Leave a Reply