21 September 2010

Strukut data praktikum 1

TUGAS STRUKTUR DATA
No. 1
PROGRAM SORTING
#include <conio.h>
#include <iostream.h>

class sorting{
friend istream& operator>>(istream&, sorting&);
friend ostream& operator<<(ostream&, const sorting&);
public:
sorting();
void selection_sort();
int pencarianbiner(int);
void cetakbaris(int,int,int);
void selection_sort(int&, int&);
void cari_data();
private:
void minimum(int, int, int&);
void tukar(int&, int&);
int data[100], n;
};

sorting::sorting(){
n=10;
}

void sorting::selection_sort(){
int t;
for(int i=0; i<n; i++){
minimum(i,n,t);
tukar(data[i], data[t]);
}
}

void sorting::minimum(int dari, int n,int& tempat){
int min=data[dari];
tempat=dari;
for(int i=dari+1; i<n; i++){
if(data[i]<min)          {
min=data[i];
tempat=i;
}
}
}

void sorting::tukar(int&a, int&b){
int temp;
temp=a;
a=b;
b=temp;
}

void sorting::cari_data()
{
int posisi=0, qq;
cout <<"cari data : "; cin >> qq;
for(int i=0; i<n; i++){
if(data[i]==qq) {
posisi = i+1;
}
}
if(pencarianbiner(qq)==-1) cout <<"tdk ada"<<endl;
else cout << "ada, posisi di : "<< posisi << endl;

}

int sorting::pencarianbiner(int qq){
int midle, low=0, high=n;
while(low<=high){
midle=(low+high)/2;
cetakbaris(low,midle,high);
if(qq==data[midle])
return midle;
else if(qq< data[midle])
high = midle-1;
else low=midle+1;
}
return -1;
}

void sorting::cetakbaris(int low,int midle,int high){
cout<<"low"<<low<<"\nmidle"<<midle<<"\nhigh"<<high<<endl;
}


istream& operator>>(istream& in, sorting& A){
cout << "Masukkan jumlah data : ";cin >> A.n;
for(int i=0; i<A.n;i++){
cout <<"Data["<<i<<"] : ";
in >> A.data[i];
}
return in;
}
ostream& operator<<(ostream& out, const sorting& A){
for(int i=0; i<A.n;i++){
out<<A.data[i]<<" ";
}
return out;
}

int main(){
sorting X;
cin >> X;
cout <<"Data sebelum sorting :\n";
cout <<X<<endl;
X.selection_sort();
cout <<"Data sesudah sorting :\n";
cout <<X<<endl<<endl;
X.cari_data();
getch();
return 0;
}


Hasil Kompilenya :












No. 2
A.     
CLASS BESERTA ANGGOTANYA ( public, private, protected )
class adalah template yang mendefinisikan bentuk suatu objek. class menentukan baik kode dan data. C++ menggunakan spesifikasi class untuk membangun objek. objek adalah contoh dari sebuah class. jadi sebuah class pada dasarnya adalah seperangkat rencan yang menentukan bagaimana untuk membangun sebuah objek.
sintak class:
1
class name{
2
public:
3
          public data and function
4
private:
5
          private data and function
6
};
7
object list;

contoh deklarasi class :
1
class contoh{
2
public:
3
void masukan();
4
void hitung();
5
void keluaran();
6
private:
7
int a,b;
8
};


deklarasi ini dimulai dengan keyword class diikuti dengan nama dari class tersebut,dan diakhiri dengan titik koma. nama class ini adalah contoh.
fungsi masukan(), hitung(), keluaran() adalah untuk memanggil function member (anggota fungsi) yang merupakan anggota dari class.function member disebut juga methods dan services.
dalam class ini seluruh function member ditandai sebagai public,dan seluruh data member ditandai sebagai private. perbedaannya adalah public member dapat diakses dari luar class, sementara private members hanya dapat diakses dari dalam class. pencegahan akses dari luar ini disebut "information hiding".
contoh program:
#include <cstdlib>
#include <iostream>
#include <math.h>

using namespace std;

class pangkat{
      public:
             pangkat();
             float pangkatkan(int,int);
             void masukan();
             void hitung();
             void keluaran();
      private:
              float hasil;
              int a,b;
      };
     
      pangkat::pangkat(){
           cout<<"Menghitung hasil perpangkatan\n\n";             
           }
          
      void pangkat::masukan(){
           cout<<"Tulis sebuah bilangan: ";
           cin>>a;
           cout<<"Mau dipangkat berapa: ";
           cin>>b;
           }
          
      void pangkat::hitung(){
           hasil=pangkatkan(a,b);
           }
          
      void pangkat::keluaran(){
           cout<<a<<" pangkat "<<b<<" = "<<hasil;
           }
          
      float pangkat::pangkatkan(int x,int y){
            return(exp(y*log(x)));
            }
          
int main(int argc, char *argv[])
{
    pangkat x;
    x.masukan();
    x.hitung();
    x.keluaran();
    cout<<endl;
   
    system("PAUSE");
    return EXIT_SUCCESS;
}


Constructor
Constructor adalah function member yang dipanggil secara otomatis pada saat objek dideklarasikan/diciptakan/dihidupkan. Fungsi constructor harus memiliki nama yang sama dengan nama class itu sendiri, dan dideklarasikan tanpa tipe kembalian.
Destructor
Destructor memiliki nama yang sama seperti constructor, tidak memiliki jenis kembali, didahului dengan ~


contoh:
1
class cobacoba{
2
public:
3
cobacoba();
4
~cobacoba();

contoh program :
#include <cstdlib>
#include <iostream>

using namespace std;
class myclass{
      public:
             int x;
             myclass();
             ~myclass();
             };
      myclass::myclass(){
      x=100;
      }
      myclass::~myclass(){
      cout<<"Destructing..."<<endl;
      }
                         
int main(int argc, char *argv[])
{
    myclass obj1;
    cout<<obj1.x<<"";
    cout<<endl;
    obj1.~myclass();
   
    system("PAUSE");
    return EXIT_SUCCESS;
}


Menggunakan protected members.
protected biasanya digunakan dalam inheritance atau class turunan. class turunan mewarisi semua anggota yang didefinisikan oleh class dasar dan menambahkan sendiri,elemen yang berbeda. c++ mengimplementasikan warisan dengan membiarkan satu class untuk menggabingkan class lain kedalam deklarasi. ini dilakukan dengan menentukan class dasar saat class turunan dinyatakan.
seperti yang kita ketahui,private member dalam class dasar tidak dapat diakses oleh class turunan. untuk itu,jika menginginkan class turunan memiliki akses beberapa anggota di class dasar akan perlu public. tentu saja membuat public member juga membuat tersedia untuk semua kode lain yang mungkin tidak diinginkan. untungnya,implikasi ini adalah salah karena c++ memungkinkan untuk membuat protected member. protected member diciptakan dengan menggunakan protected access modifier.
contoh sederhana :
#include <cstdlib>
#include <iostream>

using namespace std;
class b{
      protected:
                int i,j;
      public:
             void set(int a, int b){i=a;j=b;}
             void show(){cout<<i<<""<<j<<endl;}
             };
class d:public b{
      int k;
      public:
             void setk(){k=i*j;}
             void showk(){cout<<k<<endl;};
             };
int main(int argc, char *argv[])
{
    d objek;
    objek.set(2,3);
    objek.show();
    objek.setk();
    objek.showk();
   
    system("PAUSE");
    return EXIT_SUCCESS;
}


disini,karena b diwariskan oleh d sebagai public dan karena i dan j dinyatakan sebagai protected,fungsi d setk() dapat mengaksesnya. jika i dan j dinyatakan sebagai pribadi oleh b, lalu d tidak akan memiliki akses kepada mereka, dam program akan tidak dapat dikompilasi. ketika class dasar adalah sebagai warisan public, protected member class dasar menjadi anggota protected class turunan. ketika class dasar yang diwariskan sebagai private, protected member class dasar menjadi anggota private class turunan.
contoh program :
#include <cstdlib>
#include <iostream>

using namespace std;
class Lingkaran{
protected:
int r;
public:
Lingkaran();
void setR(int);
int getR();
float getLuas();
};

Lingkaran::Lingkaran(){
r = 0;
}

void Lingkaran::setR(int a){
r = a;
}

int Lingkaran::getR(){
return r;
}

float Lingkaran::getLuas(){
float luas;
float phi = 3.14;
luas = phi * r * r;
return luas;
}

class Tabung : public Lingkaran{
private:
int t;
public:
Tabung();
void setT(int);
float getVolume();
};

Tabung::Tabung(){
t = 0;
}

void Tabung::setT(int a){
t = a;
}

float Tabung::getVolume(){
float volume = getLuas() * t;
return volume;
}
int main(int argc, char *argv[])
 {   Tabung a;
     a.setR(5);
     a.setT(6);
     cout<<a.getVolume()<<endl;
   
    system("PAUSE");
    return EXIT_SUCCESS;
}


B.
TATA CARA MENGOVERLOAD OPERATOR ( Khususnya input dan output )
Salah satu kelebihan dari C++ adalah dapat memberikan kerja lebih ke operator, Saat mereka digunakan dengan user-defined classes . Ini adalah yang disebut operator overloading. Hanya operator C++ yang bersifat predefined yang dapat di overload. Dengan menggunakan operator overloading maka user dapat memahami notasi dengan lebih mudah.
Disini ada beberapa macam tanda untuk penggunaan overloading operator :
*      =                             (assignment operator)
*      + - *                       (binary arithmetic operators)
*      += -= *=               (compound assignment operators)
*      == !=                     (comparison operators)
Assignment operator
Mempunyai ciri sebagai berikut :
class MyClass {
public:
    ...
    MyClass & operator=(const MyClass &rhs);
    ...
  }

  MyClass a, b;
  ...
  b = a;   // Same as b.operator=(a);


 Compound assignment operator
MyClass a, b;
  ...
  a += b;    // Same as a.operator+=(b)

Dalam kasus ini , value dalam a dimodifikasi oleh operator +=

Binary Arithmetic Operators
Binary arithmetic operators adalah menarik karena mereka tidak merubah kedua operand
Jika harus mengimplementasikan operator += , dan sekarang anda ingin mengimplementasikan operator +. Maka tanda dari fungsi nya harus seperti ini:

const MyClass MyClass::operator+(const MyClass &other) const {
MyClass result = *this;  //membuat copyan Sama seperti MyClass result(*this);
    result += other;            // Gunakan += untuk menamabah copyan lain.
    return result;             
  }



bool MyClass::operator==(const MyClass &other) const {
    ...  // Compare value nya , dan return hasil bool.
  }

Point penting disini ketika operator != dapat juga didefinisikan oleh operator ==,Contoh penggunaanya :

bool MyClass::operator!=(const MyClass &other) const {
    return !(*this == other);
  }

Comparison Operators
Comparison operators sangat sederhana. Pertama harus mendifinisikan ==, Memakai fungsi seperti ini :

boExClass::operator==(const ExClass &other) const {
    ...  // Compare value nya , dan return hasil bool.
  }

Point penting disini adalah ketika operator != dapat juga didefinisikan oleh operator ==,Contoh penggunaanya:

bool ExClass::operator!=(const ExClass &other) const {
    return !(*this == other);
  }


C.
CARA MENURUNKAN CLASS
Dalam bahasa C++, sebuah class yang mewarisi disebut class dasar. Class yang melakukan pewarisan disebut Class turunan. Oleh karena itu, class turunan adalah versi khusus dari class dasar. Sebuah class turunan mewarisi semua anggota yang didefinisikan oleh class dasar dan menambahkan sendiri elemen yang berbeda.
Sintak Inheritance :
class a{
...
};
class b:public a{
...
}

Namun, meskipun class turunan mencakup semua anggota class dasarnya, itu tetap tidak dapat mengakses private members pada class dasarnya tersebut.
Seperti yang kita ketahui,private member dalam class dasar tidak dapat diakses oleh class turunan. Untuk itu, jika menginginkan class turunan memiliki akses beberapa anggota di class dasar akan perlu public. Tentu saja membuat public member juga membuat tersedia untuk semua kode lain yang mungkin tidak diinginkan. Untungnya,implikasi ini adalah salah karena c++ memungkinkan untuk membuat protected member. Protected member diciptakan dengan menggunakan protected access modifier.
contoh program :




#include <cstdlib>
#include <iostream>

using namespace std;

class lingkaran {
public:
lingkaran ();
protected:
float r;
};

lingkaran::lingkaran(){
cout<<"\n";
}

class luas : public lingkaran {
public:
void Luas_lingkaran(float);
private:
float L;
};

void luas::Luas_lingkaran(float g){
r = g;
L = 3.14*g*g;
cout<<"Luas Lingkaran = "<<L<<endl;
}

class keliling : public lingkaran{
public:
void Kel_lingkaran(float);
private:
float K;
};

void keliling::Kel_lingkaran(float g){
r = g;
K = 3.14*(2*g);
cout<<"Keliling Lingkaran = "<<K<<endl;
}

int main(int argc, char *argv[])
{
lingkaran z;
float i;
cout<<"Masukkan jari-jari = ";
cin>>i;
luas Y;
keliling X;
Y.Luas_lingkaran(i);
X.Kel_lingkaran(i);


system("PAUSE");
return EXIT_SUCCESS;
}
Karena class dasar, class turunan atau keduanya dapat mengandung konstruktor dan destruktor, penting untuk memahami urutan mereka dijalankan.
Contoh program sederhana :
#include <cstdlib>
#include <iostream>

using namespace std;

class b{
      public:
             b(){cout<<"Constructing base portion";}
             ~b(){cout<<"Destructing base portion";}
             };
class d:public b{
      public:
             d(){cout<<"Constructing derivied portion";}
             ~d(){cout<<"Destructing derivied portion";}
             };
int main(int argc, char *argv[])
{
    d ob;
        system("PAUSE");
    return EXIT_SUCCESS;
}


Seperti pernyataan di fungsi main(), menunjukkan program ini hanya membangun dan kemudian menghancurkan sebuah objek bernama ob, yang merupakan class d. Ketika dijalankan, program ini menampilkan:
Constructing base portion Constructing derived portion Destructing derived portion Destructing base portion.
Untuk menunjukkan output, pertama constructor b dijalankan, diikuti oleh destructor d. Berikutnya (sejak ob segera hancur dalam program ini), maka destructor d dipanggil, diikuti oleh b.
Diposting oleh di
Label:

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)