#include <iostream>
using namespace std;
class B
{
public :
int m ,a ;
int Perkalian1() {return a*m;}
}; //akhir dari kelas B
class D : public B //deklarasi atas kelas terderivasi D
{
public:
int n ;
int Perkalian2() {return n* Perkalian1();}
}; //akhir dari kelas D
int main()
{
D C1; // C1 adalah sebuah objek dari kelas D
C1.m = 5; //data secara langsung diakes oleh objek
C1.a = 4 ;
C1.n = 3 ;
cout<<"Perkalian1 = "<<C1.Perkalian1()<<endl;
cout<<"Perkalian2 = "<<C1.Perkalian2()<<endl;
return 0;
}
===========================================
#include <iostream>
using namespace std;
class B //deklarasi atas kelas B
{
protected :
int m ; //anggota terproteksi dari kelas B
public:
int k;
int Kuadrat() {return k*k ;}
int Perkalian() {return k*m;}
}; //akhir dari kelas B
class D : public B //kelas D mewarisi kelas B
{
public:
void setNilai1(int a) //fungsi publik untuk mengakses m dari kelas B
{m = a;}
}; //akhir dari kelas D.
int main()
{
D C; //C dideklarasikan sebagai objek dari D
C.k = 9; //Akses langsung terhadap k dari kelas B
C.setNilai1(6); //Akses terhadap m melalui anggota publik dari D
cout<<"Kuadrat = "<<C.Kuadrat()<<", Perkalian = "<< C.Perkalian()<<endl;
return 0;
}
====================================
#include <iostream>
using namespace std;
class B
{
private : //akses private
int m ;
}; //akhir dari kelas B
class D : public B //deklarasi atas kelas D
{
public:
int a;
void setNilai() //fungsi untuk mengakses m dari kelas B
{m = a;}
int n;
}; //akhir dari kelas D
int main()
{
D C; //C adalah sebuah objek dari kelas D
C.a = 5;
C.n = 4;
int kali = C.a* C.n;
cout<<"Perkalian atas angota-anggota = "<<kali<<endl;
cout<<"Penjumlahan dari anggota-anggota terkuadrat = "<<C.n*C.n + C.a*C.a<<endl;
return 0;
}
========================================
#include <iostream>
using namespace std;
class B { //kelas basis B
private:
int x; //anggota private dari kelas B
int Kuadrat(){ return x*x ;} //anggota private dari kelas B
public:
void setNilai(int p); //setNilai()-sebuah anggota publik untuk
//mengakses anggota private x dari kelas B
int Pkuadrat(){return Kuadrat();} //Sebuah anggota publik dari kelas B untuk
//mengakes anggota private Kuadrat()
int m;
}; //akhir dari kelas B
void B::setNilai(int p){x = p;}; //definisi dari setNilai()
class D : public B //deklarasi dari D dengan pewarisan publik
{
public:
int n ;
}; //akhir dari kelas D
int main()
{
D C; //C adalah sebuah objek dari kelas D
C.setNilai(5) ; //mengakses x dari kelas B melalui setNilai()
C.m = 4; //mengakses anggota publik dari kelas B secara langsung
C.n = 3; //mengakses anggota publik dari kelas B secara langsung
cout<<"Perkalian atas m dan n = "<<C.m*C.n<<endl;
cout<<"Kuadrat = "<<C.Pkuadrat()<<endl;
return 0;
}
============================================
#include <iostream>
using namespace std;
class B {
protected : //akses terproteksi
int m;
int Kuadrat() {return m*m;}
public: //akses publik
int k;
perkalian() {return k*m;}
}; //akhir dari kelas B
class D : protected B //pewarisan terproteksi
{
public:
void setNilai1(int a) //anggota publik untuk mengakses m
{m = a;}
void setNilai2(int p) {k = p;} //anggota publik untuk mengakses k
int dKuadrat(){return B::Kuadrat();} //untuk mengakses Kuadrat()
int dperkalian(){return B::perkalian();} //untuk mengakses perkalian()
}; //akhir dari kelas D
int main()
{
D C; //C adalah sebuah objek dari kelas D
C.setNilai2(10);
C.setNilai1(5);
cout<<"Perkalian atas m dan k = "<<C.dperkalian()<<endl;
cout<<"Kuadrat = "<< C.dKuadrat()<<endl;
return 0;
}
=====================================
#include <iostream>
using namespace std;
class B { //kelas basis
private:
int m; //anggota data private
int Kuadrat(){return m*m ;} //anggota fungsi private
public :
void set_nilaib(int a) {m = a;} //anggota publik untuk mengakses m
int bKuadrat(){return Kuadrat();} //untuk mengakses Kuadrat()
int k; //anggota publik dari kelas B
int perkalian(){return k*k;}
}; //akhir dari kelas B
class D : protected B //pewarisan terproteksi
{
public:
void set_nilaid (int n) {set_nilaib(n);}
void set_nilai2(int p) {k = p;} //untuk mengakses k,
int dbkuadrat(){return bKuadrat();} //untuk mengakses bKuadrat()
int dperkalian(){return perkalian();} //untuk mengakses perkalian()
}; //akhir dari kelas D.
int main()
{
D C; //C adalah sebuah objek dari kelas D
C.set_nilai2(10);
C.set_nilaid(5);
cout<<"Perkalian = "<<C.dperkalian()<<endl;
cout<<"Kuadrat = "<<C.dbkuadrat()<<endl;
return 0;
}
=======================================
#include <iostream>
using namespace std;
class B {
protected :
int m;
public:
int k;
}; //akhir dari kelas B
class D : private B //pewarisan private
{
public: //pemodifikasi akses pada kelas D
int a;
void set_nilai() {m = a;}
int n;
};//akhir dari kelas D
int main()
{
D C; //C adalah sebuah objek dari kelas D
C.k = 6;
C.a = 5;
C.n = 4;
int perkalian = C.a * C.n;
cout<<"Perkalian dari anggota-anggota dari B dan D = "<<perkalian<< endl;
cout<<"Penjumlahan atas kuadrat dari anggota-anggota dari B dan D = "<< C.n*C.n + C.a*C.a<<endl;
return 0;
}
==================================
#include <iostream>
using namespace std;
class B{
protected :
int m;
public :
int k;
int Kuadrat() {return k*k;}
int mskuadrat() {return m*m;}
}; //akhir dari kelas B
class D : private B //pewarisan private
{
public:
int a;
void set_nilai1() //anggota publik dari D untuk mengakses
{m = a;} //anggota terproteksi dari B
void set_nilai2(int b) {k = b;}
//anggota publik dari D yang diperlukan untuk mengakses anggta publik
//dari B.
//Karena pewarisan private, hal yang sama berlaku berikut.
int dmkuadrat(){return mskuadrat();}
int Dkuadrat(){return B::Kuadrat();}
}; //akhir dari kelas D
int main()
{
D C; // C adalah sebuah objek dari kelas D
C.set_nilai2(6);
C.a = 5;
C.set_nilai1();
cout<<"Kuadrat = "<< C.Dkuadrat()<<endl;
cout<<"Kuadrat dari m = "<<C.dmkuadrat()<<endl;
return 0;
}
=========================================
#include <iostream>
using namespace std;
class B1 {
private :
int m ;
public :
int a;
void set_nilai()
{m = a;}
}; //akhir dari kelas B1
class B2
{
public :
int k;
}; //akhir dari kelas B2
class D : public B1,public B2
//deklarasi pewarisan jamak
{
public:
int n ;
};
//akhir dari kelas D
int main()
{
D C; //C dideklarasikan sebagai objek dari kelas D
C.k = 5; //C mengakses langsung anggota publik dari B2
C.a = 4; //C mengakses langsung anggota publik dari B1
C.n = 3;
int perkalian = C.a* C.n*C.k;
cout<<"Perkalian dari anggota-anggota data dari B1, B2, dan D = "<<perkalian<< endl;
return 0;
}
======================================
#include <iostream>
using namespace std;
class B
{
public :
void Tampil() {cout<<"Ini adalah fungsi Tampil() dari kelas B"<<endl;}
};
class D1 : public B
{
public :
void Tampil() {cout<<"Ini adalah fungsi Tampil() dari kelas D1"<<endl;}
};
class D2 : public D1
{
public :
void Tampil() {cout<<"Ini adalah fungsi Tampil() dari kelas D2"<<endl;}
};
int main ()
{
D2 d2 ; //d2 adalah sebuah objek dari kelas D2
d2.B::Tampil();
d2.D1::Tampil();
d2.Tampil();
return 0;
}
========================================
#include <iostream>
using namespace std;
class B
{
protected:
int bx;
public:
void Bset(int m) { bx = m ;}
void Tampil(){cout<<"Tampil() dari kelas B "<<endl;}
}; //akhir dari kelas B
class D1 : public B
{
protected:
int D1x;
public:
void D1set(int n){ D1x = n;}
void Tampil(){cout<<"Tampil() dari kelas D1"<<endl;}
}; //akhir dari kelas D1
class D2 : public D1
{
protected:
int D2x;
public:
void D2set(int p) { D2x = p ;}
void Tampil(){cout<<"Tampil() dari kelas D2"<<endl;}
}; //akhir dari kelas D2
class D3 : public D2
{
private:
int D3x;
public :
void D3set(int q) { D3x = q;}
int Perkalian() { return D3x * D2::D2x * D1::D1x * B::bx;}
void Tampil(){ cout<<"Tampil() dari kelas D3 "<<endl;}
}; //akhir dari kelas D3
int main ()
{
D3 d3;
d3.D3set (10);
d3.D2::D2set(4);
d3.D1::D1set(3);
d3.B::Bset(2);
cout<<"Perkalian = "<<d3.Perkalian()<<endl;
d3.Tampil();
d3.D2::Tampil();
d3.D1::Tampil();
d3.B::Tampil();
return 0 ;
}
===================================
#include <iostream>
using namespace std;
class B1{
private:
int x;
public:
B1() { x =1;} //konstruktor default dari B1
B1(int a ) { x = a;} //konstruktor parametris dari B1
int getx(){return x;} //fungsi publik dari B1
~B1() { } //destruktor untuk B1
}; //akhir dari kelas B1
class B2 {
int y; //private secara default
public:
B2(){y=2;}
B2(int b) {y = b;} //konstruktor parametris dari B2
~B2(){} //destruktor untuk B2
int gety(){ return y;}
}; //akhir dari kelas B2
class D : public B1, public B2
{
private :
int z;
public :
D(int i, int j, int k) : B1(i), B2(j) {z = k;}
//Konstruktor untuk D
~D() {} //destruktor dari D
int Perkalian() {return getx()* gety()*z;} //Sebuah fungsi publik dari D
}; //akhir dari kelas D
int main()
{
D d (4, 5, 6); //d adalah sebuah objek dari kelas D
cout<<"Perkalian = "<<d.Perkalian()<<endl;
return 0;
}
==========================================
#include <iostream>
using namespace std;
class B1 { //awal dari kelas B1
private:
int x;
public:
B1() {x = 4;
cout<<"Konstruktor dari B1 dipanggil\n";}
~B1(){cout<<"Destruktor dari B1 dipanggil\n";}
}; //akhir dari kelas B1
class B2 //awal dari kelas B2
{
private:
int y;
public:
B2() {y = 5;
cout<<"Konstruktor dari B2 dipanggil\n";}
~B2(){cout<<"Destruktor dari B2 dipanggil\n";}
}; //akhir dari kelas B2
class D : public B1, B2 //kelas D diderivasi dari B1 dan B2
{
private:
int z;
public:
D (int c) { z =c; cout<<"Konstruktor dari D dipanggil\n";}
~D() {cout<<"Destruktor dari D dipanggil\n";}
}; //akhir dari kelas D
int main()
{
D d (10); //d dideklarasikan sebagai objek dari kelas D
return 0;
}
================================
#include <iostream>
using namespace std;
class B
{
protected:
int x;
public:
B () { x = 4;}
B(int a) {x = a;
cout<<"Konstruktor basis dipanggil"<<endl;}
B(const B &b) {x = b.x;
cout<<"Konstruktor penyalin dari kelas B dipanggil"<<endl;}
};
class D : public B
{
int y; //private secara default
public:
D() {y = 5;}
D(int k){y = k;
cout<<"Konstruktor kelas terderivasi dipanggil"<<endl;}
int Tampil() {return y;}
};
int main()
{
D d1 (10); //d1 didefinisikan sebagai objek dari kelas D
D d2 = d1; //d2 didefinisikan sebagai salinan dari d1.
cout<<"d2 = "<<d2.Tampil()<<endl;
return 0 ;
}
===================================
#include <iostream>
using namespace std;
class Kubikel {
private:
int x, y, z;
public:
Kubikel(){}
Kubikel(int a, int b, int c ) //konstruktor
{ x = a;
y = b;
z = c;
cout<<"konstruktor dari Kubikel dipanggil"<<endl;
}
int luas_permukaan() { return 2*(x*y +y*z +z*x);}
}; //akhir dari kelas Kubikel
class Kubik : public Kubikel
{
public:
int tarif;
Kubikel C;
//berikut adalah konstruktor dari kelas Kubik
Kubik(int L, int W, int H, int A) : Kubikel (L, W, H) {tarif = A;}
int biaya(int tarif, Kubikel C ){return tarif * C.luas_permukaan();}
}; //akhir dari kelas Kubik
int main()
{
int x =2;
Kubikel C1 (3, 3, 3);
Kubikel C2 (4, 5, 6);
Kubik Kubik1(3,3,3, x);
Kubik Kubik2(4,5,6,3);
cout<<"Luas permukaan dari Kubik1 = "<<Kubik1.luas_permukaan()<<"\n";
cout<<"Biaya untuk Kubik1 = "<<Kubik1.biaya(x, C1 )<<"\n";
cout<<"Luas permukaan dari Kubik2 = "<<Kubik2.luas_permukaan()<<"\n";
cout<<"Biaya untuk Kubik2 = "<<Kubik2.biaya(3,C2)<<"\n";
return 0;
}
===================================
#include <iostream>
using namespace std;
class C
{
private:
int x;
public:
C(int a) {x = a;
cout<<"Konstruktor dari C dipanggil.\n";}
~C(){ cout<<"Destruktor dari C dipanggil.\n";}
int getx() { return x;}
}; //akhir dari kelas C
class B {
private:
int y;
public:
B (int b) {y = b;
cout<<"Konstruktor dari B dipanggil.\n";}
~B(){cout<<"Destruktor dari B dipanggil.\n";}
int gety(){return y;}
}; //akhir dari kelas B
class D
{
private:
int z;
public:
C objC ; //objC dideklarasikan sebagai objek dari kelas C
B objB ; //objB dideklarasikan sebagai objek dari kelas B
D (int i, int j, int k ) : objB (i), objC(j) {z =k ; cout<<"Konstruktor dari D dipanggil.\n";}
~D() {cout<<"Destruktor dari D dipanggil.\n";}
int Perkalian(){return objC.getx()* objB.gety()* z;}
}; //akhir dari kelas D
int main()
{
D objD(5, 20, 4);
cout<<"Perkalian = "<<objD.Perkalian()<<endl;
return 0;
}
======================================
#include <iostream>
using namespace std;
class C
{
private:
int x;
public:
C(int a) {x = a;
cout<<"Konstruktor dari C dipanggil.\n";}
~C(){ cout<<"Destruktor dari C dipanggil.\n";}
int getx() { return x;}
}; //akhir dari kelas C
class B {
private:
int y;
public:
B (int b) {y = b;
cout<<"Konstruktor dari B dipanggil.\n";}
~B(){cout<<"Destruktor dari B dipanggil.\n";}
int gety(){return y;}
}; //akhir dari kelas B
class D : public B //kelas D diderivasi dari kelas B
{
private:
int z;
public:
C c ; //objek c dari kelas C di dalam kelas D
// Below is the constructor of class D.
D (int m, int n, int k ) : B(m), c(n)
{
z =k;
cout<<"Konstruktor dari D dipanggil.\n";
}
//konstruktor dari B dipanggil dengan nama kelas B.
//konstruktor dari C dipanggil dengan nama objeknya c.
~D() {cout<<"Destruktor dari D dipanggil.\n";}
int Perkalian() {return c.getx()* gety()* z;}
}; //akhir dari kelas D
int main()
{
D d(10, 20, 5); //objek dari kelas D
cout<<"Perkalian = "<<d.Perkalian()<<endl;
return 0;
}
========================================
#include <iostream>
using namespace std;
class B {
protected:
int bx;
public:
B(){}
B(int m) {bx = m;}
int getbx(){return bx;}
}; //akhir dari kelas B
class D1
{
protected:
int D1x;
public:
D1(){}
D1(int m) {D1x = m;}
int getD1x(){return D1x;}
}; //akhir dari kelas D1
class D2 : public D1
{
protected:
int D2x;
public:
int getD2x(){return D2x;}
D2(){}
D2(int e) {D2x = e;}
}; //akhir dari kelas D2
class D3 : public D2
{
private:
int D3x;
public:
B b; //b adalah sebuah objek dari kelas B
D1 d1; //d1 adalah sebuah objek dari kelas D1
//konstruktor dari D didefinisikan berikut.
D3 (int i, int j, int k, int s) : b(i), d1(j), D2(k) {D3x = s;}
int Perkalian() {return D3x * D2x * d1.getD1x() * b.getbx();}
void Tampil(){cout<<"Tampil() dari kelas D3."<<endl;}
}; //akhir dari kelas D3
int main ()
{
D3 d3 ( 10, 5, 4, 2);
cout<<"Perkalian = "<<d3.Perkalian()<<endl;
return 0 ;
}
===========================================
#include<iostream>
using namespace std;
class Vektor
{
protected:
int x, y, z ; //tiga komponen vektor
public:
Vektor (){ x=1,y=2,z=3;}
Vektor (int a, int b,int c)
{
x =a ; y = b; z =c;
cout<<"Konstruktor dari kelas Vektor dipanggil."<<endl;
}
Vektor operator += (const Vektor & P)
{
x = x + P.x ;
y = y + P.y ;
z = z + P.z ;
cout<<"Fungsi terbebani dari Vektor dipanggil."<<endl;
return *this;
}
void Tampil()
{
cout<<"Komponen x = "<<x<<endl;
cout<<"Komponen y = "<<y<<endl;
cout<<"Komponen z = "<<z<<endl;
}
}; //akhir dari kelas Vektor
class D : public Vektor
{
public:
// constructor function
D (int a, int b, int c) : Vektor (a,b,c)
{
cout<<"Konstruktor dari D dipanggil."<<endl;
}
}; //akhir dari kelas D
int main()
{
D V1(12, 4, 6), V2(3, 5, 7);
V1 += V2;
V1.Tampil();
return 0;
}
Tidak ada komentar:
Posting Komentar