#include <iostream>
using namespace std;
template <typename T> T Luas(T x, T y ) //template fungsi
{return x*y ;} // definisi
int main()
{
int n = 4 , m = 3;
double j = 6.5 , k = 4.1 ;
cout<<"Luas 1 = "<<Luas<int>(n, m)<<"\t Luas 2 = "<< Luas<double>(j, k)<<endl;
return 0;
}
=================================================
#include <iostream>
using namespace std;
template <class T> T maks(T x, T y) //definisi fungsi
{return x>y ? x : y;} //tubuh fungsi
int main()
{
int n = 64, m = 67 ; //variabel-variabel int
char ch1 = 'S' , ch2 = 'R'; //variabel-variabel char
double D1 = 6.87, D2= 8.34; //variabel-variabel double
cout<<"maks(n,m)= "<<maks<int>(n,m)<<endl;
cout<<"maks(ch1,ch2) = "<<maks<char>(ch1,ch2)<<endl;
cout<<"maks(D1,D2) = "<<maks<double>(D1, D2)<< endl;
return 0;
}
===============================================
#include<iostream>
#include<string>
using namespace std;
template <class T> //definsii template dari Tukar()
void Tukar(T &x , T &y) //nilai-nilai dilewatkan dengan referensi
{
T temp;
temp = x;
x = y;
y = temp;
}
void main()
{
int n =60, m=30;
char ch1= 'A', ch2 = 'D';
double a = 2.45, b = 4.76;
string S1 = "Selamat"; //S1 dan S2 adalah objek string
string S2 = "Malam"; //tipenya adalah string
Tukar <double>(a,b);
Tukar<char>(ch1,ch2);
Tukar<int>(n,m);
Tukar<string>(S1,S2);
cout<<"a = "<<a<<"\tb = "<<b<<"\n";
cout<<"ch1 = "<<ch1<<"\tch2 = "<<ch2<<endl;
cout<<"n = "<<n<<" \tm = "<<m<<"\n";
cout<<"S1 = "<<S1<<" , S2 = "<<S2<<endl;
}
==========================================
#include <iostream>
using namespace std;
template <class T>
void Tampil(const T*A, unsigned int ukuran) //deklarasi dan definisi fungsi
{
for( int i =0 ; i<ukuran; i++ )
cout<< A[i] <<" ";
cout<<endl;
}
int main ()
{
const int K = 6, M =15, J = 4;
int Budi[J] = {20, 30, 40, 50}; //sebuah array integer
//Berikut adalah sebuah array double
double Kartini[K] = {4.5, 5.6, 7.8, 8.9, 1.2, 3.4};
char Nama[M] = "John Kristof"; //sebuah string karakter
Tampil(Budi, J);
Tampil(Kartini , K);
Tampil(Nama , M);
return 0;
}
===================================
#include <iostream>
using namespace std;
template <class T>
void Tampil(const T A[], unsigned int ukuran) //deklarasi dan definisi fungsi
{
for( int i =0 ; i<ukuran; i++ )
cout<<A[i]<<" ";
cout<<endl;
}
int main ()
{
const int K = 6, M =15, J = 7, N = 4;
int Budi[J] = {20,30, 40,50,60,70,80};
char ch[N] = {'D', 'E', 'S', 'A'};
double Kartini[K] = {4.5, 5.6, 7.8, 8.9, 1.2, 3.4};
char* S[M] ={"Kristof", "John", "Martina", "Sandora", "Jelita"};
Tampil(Budi, J); //memanggil fungsi template
Tampil(Kartini, K);
Tampil(ch, N);
Tampil(S, M);
return 0;
}
====================================
#include <iostream>
using namespace std;
template <class T> //template fungsi pengurutan
void UrutArray(T A[], const int n)
{
for (int i = 0 ;i<n;i++)
{
for(int j=0;j<n-1;j++)
if(A[j]>A[j+1])
swap(A[j],A[j+1]);
}
}
template <class T>
void Tampil(T A[], unsigned int ukuran)
{
for (int i =0; i<ukuran; i++)
cout<<A[i]<<" ";
cout<<endl;
}
int main ()
{
const int K = 6, J = 7;
int ArrInteger[J] = {20, 30, 70, 80, 40, 50, 60};
char ch [6] = {'B', 'A', 'N', 'G', 'S', 'A'};
double ArrDouble[K] = {4.5, 5.6, 1.2, 7.8, 8.9, 3.2};
UrutArray(ArrInteger, J);
Tampil(ArrInteger, J);
UrutArray(ArrDouble, K);
Tampil<double>(ArrDouble, K);
UrutArray(ch, 6);
Tampil<char>(ch, 6);
return 0;
}
============================================
#include <iostream>
using namespace std;
template <class generik> //deklarasi dan definisi dari Tukar
void Tukar (generik x[ ], generik y[ ], int m)
{
generik temp ; // type identifier is generik in place of T
for (int i = 0; i<m;i++)
{
temp = x[i];
x[i] = y[i];
y[i] = temp ;
}
} //akhir dari template fungsi
void main()
{
double Budi[] = {11.1, 12.2, 13.3, 14.4 ,15.5};
double Wati[] = {30.5, 31.1, 32.2, 33.3, 34.4};
char Ch[] = {'B', 'A', 'N', 'G', 'S', 'A'};
char Kh[] = {'S', 'O', 'N', 'T', 'A', 'K'};
int K[5] = {1, 2, 3, 4, 5};
int M[5] = {50, 60, 70, 80, 90};
cout<<"Sebelum penukaran array:\n";
cout<<"Budi\tWati\tCh\tKh\tK\t M"<<endl;
for (int k = 0; k <5; k++)
cout <<Budi[k] <<"\t"<<Wati[k]<<"\t"<<Ch[k]<<"\t"<<Kh[k] <<"\t"
<<K[k]<<"\t"<<M[k] <<endl;
Tukar(Budi, Wati, 1);
Tukar(K, M, 3);
Tukar(Ch, Kh, 5) ;
cout<<"Setelah penukaran array:\n";
cout<<"Budi\tWati\tCh\tKh\tK\tM "<<endl;
for (int j = 0; j <5; j++)
cout <<Budi[j] <<"\t"<<Wati[j]<<"\t"<<Ch[j]<<"\t"<<Kh[j]<< "\t"
<<K[j]<<"\t"<<M[j]<<endl;
}
=====================================
#include <iostream>
using namespace std;
template <class T , class E> E maks(T x, E y)
{
return x>y ? x : y;
}
int main()
{
int n = 88 ;
double m = 80.4 ;
int ch1 = 67 ;
char ch2 = 'A';
double D1 = 76.87, D2= 90.3;
cout<<"maks(n, m)= "<<maks(n,m)<<endl;
cout<<"maks(ch1,ch2) = "<<maks(ch1,ch2)<<endl;
cout<<"maks(D1,D2) = "<<maks(D1, D2)<< endl;
cout<<"maks(n,D2) = "<<maks(n,D2)<<endl;
return 0;
}
========================================
#include <iostream>
using namespace std;
template <class T, class U>
U Perkalian (T x, U y)
{return x*y;}
template <class T, class S, class U>
S Perkalian (T x, S y, U z)
{return x*y*z;}
int main ()
{
int a(1);
double B(1.5);
char Ch('D');
cout<<"Perkalian(a, B, Ch) = "<<Perkalian(a, B, Ch)<<endl;
cout<<"Perkalian(a, B) = "<<Perkalian(a, B)<<endl;
cout<<"Perkalian('A', 4.5, 6) = "<<Perkalian('A', 4.5, 6)<<endl;
return 0;
}
=============================================
#include <iostream>
using namespace std;
template <class T>
class Kubik {
T x , y , z ; //variabel x , y, z bertipe data sama
public:
Kubik(T L, T W, T H)
{
x = L; y = W; z = H;
}
T luas_permukaan()
{
return 2*(x*y +y*z +z*x);
}
T volume() {
return x*y*z;
}
};
// akhir dari kelas
int main()
{
Kubik<int> C1(3, 8, 5); //dimensi-dimensi bertipe int
Kubik< double> C2(3.5, 5.5, 4.5) ; //dimensi-dimensi bertipe double
cout<<"Volume dari C1 = "<<C1.volume()<<"\n";
cout<<"Volume dari C2 = "<<C2.volume()<<"\n";
cout<<"Luas permukaan dari C1 = "<<C1.luas_permukaan()<<"\n";
cout<<"Luas permukaan dari C2 = "<<C2.luas_permukaan()<<"\n";
return 0 ;
}
===============================
#include <iostream>
using namespace std;
template <class T> //deklarasi dari template kelas
class Kubik {
public:
T x , y , z ;
Kubik (T L, T W, T H){x = L; y = W; z = H ;} //konstruktor
T luas_permukaan(); //prototipe fungsi di dalam tubuh kelas
T volume(); //prototipe fungsi di dalam tubuh kelas
}; //akhir kelas
template <class T> //definisi fungsi
T Kubik <T>::luas_permukaan()
{
return 2*(x*y +y*z +z*x);
}
template <class T > //definisi fungsi
T Kubik <T>::volume()
{
return x*y*z;
}
int main()
{
Kubik<int> C1(5,6,4); //Objek dengan dimensi-dimensi int
Kubik<double> C2(2.2,3.5,4.5) ; //Objek dengan dimensi-dimensi
//dalam nilai-nilai titik-mengambang
cout<<"Volume dari C1 = "<<C1.volume()<<"\n";
cout<<"Volume dari C2 = "<<C2.volume()<<"\n";
cout<<"Luas permukaan dari C1 = "<<C1.luas_permukaan()<<"\n";
cout<<"Luas permukaan dari C2 = "<<C2.luas_permukaan()<<"\n";
return 0 ;
}
============================================
#include <iostream>
using namespace std;
template <class T> //deklarasi dari template kelas
class Kubik {
public:
Kubik(T, T, T); //prototipe konstruktor
T luas_permukaan(); //prototipe fungsi di dalam tubuh kelas
T volume(); //prototipe fungsi di dalam tubuh kelas
private:
T x, y, z;
}; //akhir kelas
template < class T> //definisi fungsi konstruktor
Kubik <T>::Kubik <T> (T L, T W, T H)
{
x = L; y= W; z=H;
}
template <class T> //definisi fungsi
T Kubik <T>::luas_permukaan()
{
return 2*(x*y +y*z +z*x);
}
template <class T > //definisi fungsi
T Kubik <T>::volume()
{
return x*y*z;
}
int main()
{
Kubik<int> C1(5,6,4); //Objek dengan dimensi-dimensi int
Kubik<double> C2(2.2,3.5,4.5) ; //Objek dengan dimensi-dimensi
//dalam nilai-nilai titik-mengambang
cout<<"Volume dari C1 = "<<C1.volume()<<"\n";
cout<<"Volume dari C2 = "<<C2.volume()<<"\n";
cout<<"Luas permukaan dari C1 = "<<C1.luas_permukaan()<<"\n";
cout<<"Luas permukaan dari C2 = "<<C2.luas_permukaan()<<"\n";
return 0 ;
}
===================================
#include <iostream>
using namespace std;
template <class T>
class Rekt {
friend T Luas(const Rekt &R); //deklarasi dari template fungsi friend
private:
T x; // x dan y adalah sisi-sisi dari persegi-panjang
T y;
public:
Rekt(T A, T B) {x = A , y = B; } //konstruktor
}; //akhir dari template kelas
template <class T> //definisi dari fungsi friend
T Luas(const Rekt <T> &R)
{
return R.x* R.y ;
} // R adalah sebuah objek
int main ()
{
Rekt<int> kuRekt(6, 2); // kuRekt adalah sebuah objek dari Rekt
cout<<"Luas = "<<Luas(kuRekt)<<endl;
return 0;
}
============================================
#include <iostream>
using namespace std;
template <class T, class U> //template kelas dengan multi tipe data
class Rekt
{
private:
T x;
U y;
public:
Rekt (T A, U B) {x = A, y = B;}
friend U Luas (const Rekt &R); //template fungsi friend
};
template <class T, class U>
U Perkalian(T x, U y)
{
return x*y;
}
template <class T, class S, class U>
S Perkalian (T x, S y, U z)
{
return x*y*z;
}
int main ()
{
int a (1);
double B(1.5);
char Ch('D');
cout<<"Perkalian(a, B, Ch) = "<<Perkalian(a, B, Ch)<<endl;;
cout<<"Perkalian(a, B) = "<<Perkalian(a, B)<<endl;
cout <<"Perkalian('A', 4.5, 6) = "<<Perkalian('A', 4.5, 6)<<endl;
return 0;
}
==================================
#include <iostream>
using namespace std;
template <class T> //deklarasi tipe
class Kubik { //awal dari template kelas
private:
T x, y, z;
public:
Kubik (T, T, T); //prototipe konstruktor
T luas_permukaan();
T volume();
//template fungsi friend
friend T biayaLukis(T, const Kubik <T> &C);
}; //akhir dari kelas Kubik
template < class T> //definisi dari konstruktor di luar kelas
Kubik <T> :: Kubik<T>(T L, T W, T H) {
x = L; y = W; z = H;
}
template <class T> //definisi dari fungsi luas permukaan
T Kubik <T>::luas_permukaan()
{
return 2*(x*y +y*z +z*x);
}
template <class T> //definisi dari fungsi volume
T Kubik <T>::volume()
{
return x*y*z;
}
//berikut adalah definisi dari template fungsi friend
template <class T >
T biayaLukis(T Rho, Kubik<T> &C)
{
return Rho * C.luas_permukaan();
}
int main()
{
Kubik<int> C1(4, 5, 6) ;
Kubik<double> C2(2.5, 3.0, 4.0);
int D1 = 3;
double D2 = 2.0;
cout<<"Volume dari C1 = "<<C1.volume()<<"\n";
cout<<"Volume dari C2 = "<<C2.volume()<<"\n";
cout<<"Luas permukaan dari C1 = "<<C1.luas_permukaan()<<"\n";
cout<<"Luas permukaan dari C2 = "<<C2.luas_permukaan()<<"\n";
cout<<"Biaya melukis P1 = "<<biayaLukis(D1, C1)<<"\n";
cout<<"Biaya melukis P2 = "<<biayaLukis(D2, C2)<<"\n";
return 0 ;
}
===================================
template <class U> class lukis;
#include <iostream>
using namespace std;
template <class T>
class Kubik {
friend class lukis; //deklarasi dari kelas lukis sebagai friend
public:
Kubik ( T, T, T); //prototipe konstruktor dari kelas Kubik
T luas_permukaan(); //prototipe dari luas_permukaan() dan volume()
T volume();
private:
T x, y, z; // x , y and z are of same type
}; //akhir dari kelas Kubik
template < class T> //definisi konstruktor untuk kelas Kubik
Kubik <T> :: Kubik<T>(T L, T W, T H) {
x = L; y = W; z = H;
}
template <class T> //definisi dari fungsi luas_permukaan()
T Kubik <T>::luas_permukaan()
{
return 2*(x*y +y*z +z*x);
}
template <class T> //definisi dari fungsi volume()
T Kubik <T>::volume()
{
return x*y*z;
}
template <class U> //kelas lukis
class lukis { //definisi dari kelas lukis
private:
U Rho;
public:
lukis (U); //prototipe dari konstruktor
lukis(){Rho =2;}; //konstruktor default
U biaya(U Rho,U luas_permukaan ) //definisi dari fungsi biaya()
{
U CP; // CP = biaya lukis
CP = Rho* luas_permukaan ;
return CP;
}
}; //akhir dari kelas lukis
template <class U> //konstruktor untuk kelas lukis
lukis<U>::lukis<U>(U D) {
Rho = D;
}
int main()
{
Kubik<int> C1(4, 5, 6);
Kubik<int> C2(2, 3, 4);
lukis<int> P1;
lukis<int> P2;
int R1 =2;
int R2 = 3;
cout<<"Volume dari C1 = " <<C1.volume()<<"\n";
cout<< "Volume dari C2 = " <<C2.volume()<<"\n";
cout<<"Luas permukaan dari C1 = "<<C1.luas_permukaan()<<"\n";
cout<<"Luas permukaan dari C2 = "<<C2.luas_permukaan()<<"\n";
cout<<"Biaya melukis P1 = "<<P1.biaya(7, C1.luas_permukaan())<< "\n";
cout<<"Biaya melukis P2 = "<< P2.biaya (7, C2.luas_permukaan())<<"\n";
return 0 ;
}
====================================
#include<iostream>
#include<complex>
using namespace std;
int main ()
{
complex<double> a(4.5, 5.5) ;
complex<int> b(2,3) ;
complex<int> g(3,4) ;
complex<double> e(1.4, 3.4);
complex<double> C = a + e ;
complex<int>D = g - b;
complex<int> Perkalian = b*b ;
cout<<"a = "<<a<<"\t"<<"b = "<<b<<"\n";
cout<<"C= "<<C<<"\t"<<"D = "<<D<<"\n";
cout<<"Perkalian b*b = "<<Perkalian<<endl;
return 0;
}
=========================================
#include <iostream>
using namespace std;
template <class T>
T Perkalian(T x, T y)
{return x*y;}
template <class T>
T Perkalian( T x, T y, T z)
{return x*y*z;}
int main ()
{
int a (2), b(3), c(4);
double A(2.0), B(5.5), C(1.5);
cout<<"Perkalian(A, B, C) = "<<Perkalian(A, B, C)<<endl;;
cout<<"Perkalian(A, B) = "<<Perkalian(A, B)<<endl;
cout<<"Perkalian(a, b, c) = "<<Perkalian(a, b, c)<<endl;
return 0;
}
===============================
Tidak ada komentar:
Posting Komentar