Arsip

Archive for September, 2010

Tugas struktur data

21 September 2010 Tinggalkan komentar

:: PROGRAM C++

    #include
    #include
    using namespace std;
    class konversi
    {
    friend istream & operator >> ( istream &, konversi & );
    public:
    konversi( unsigned int b = 0 )
    {
    bilangan = b;
    }
    void membilang1();
    void membilang2();
    void membilang3();
    void membilang4();
    void konversikan();
    private:
    unsigned int bilangan;
    };
    istream & operator >> ( istream & in, konversi & x )
    {
    cout <> x.bilangan;
    return in;
    }
    void konversi::konversikan()
    {
    if ( bilangan 19 && bilangan = 100 ) membilang4();
    else
    membilang2();
    }
    void konversi::membilang4()
    {
    int puluhan;
    if ( bilangan >= 100 )
    {
    puluhan = bilangan % 100;
    bilangan = bilangan / 100;
    if ( bilangan > 1 )
    konversikan();
    else if ( bilangan = 1 )
    cout << “se”;
    cout < 19 && bilangan < 100 )
    {
    satuan = bilangan % 10;
    bilangan = bilangan / 10;
    konversikan();
    cout << ” puluh “;
    bilangan = satuan;
    konversikan();
    }
    }
    void konversi::membilang1()
    {
    switch ( bilangan )
    {
    case 0:
    cout << “nol\n”;
    break;
    case 1:
    cout << “satu\n”;
    break;
    case 2:
    cout << “dua\n”;
    break;
    case 3:
    cout << “tiga\n”;
    break;
    case 4:
    cout << “empat\n”;
    break;
    case 5:
    cout << “lima\n”;
    break;
    case 6:
    cout << “enam\n”;
    break;
    case 7:
    cout << “tujuh\n”;
    break;
    case 8:
    cout << “delapan\n”;
    break;
    case 9:
    cout << “sembilan\n”;
    break;
    case 10:
    cout << “sepuluh\n”;
    break;
    case 11:
    cout << “sebelas\n”;
    break;
    default:
    cout < 11 )
    {
    bilangan %= 10;
    membilang1();
    cout <> a;
    a.konversikan();
    system(“PAUSE”);
    return EXIT_SUCCESS;

    }
    136 #include <cstdlib>

    #include <iostream>

    using namespace std;

    class konversi

    {

    friend istream & operator >> ( istream &, konversi & );

    public:

    konversi( unsigned int b = 0 )

    {

    bilangan = b;

    }

    void membilang1();

    void membilang2();

    void membilang3();

    void membilang4();

    void konversikan();

    private:

    unsigned int bilangan;

    };

    istream & operator >> ( istream & in, konversi & x )

    {

    cout << “masukkan bilangan : “;

    in >> x.bilangan;

    return in;

    }

    void konversi::konversikan()

    {

    if ( bilangan <= 11 ) membilang1();

    else if ( bilangan > 19 && bilangan < 100 ) membilang3();

    else if ( bilangan >= 100 ) membilang4();

    else

    membilang2();

    }

    void konversi::membilang4()

    {

    int puluhan;

    if ( bilangan >= 100 )

    {

    puluhan = bilangan % 100;

    bilangan = bilangan / 100;

    if ( bilangan > 1 )

    konversikan();

    else if ( bilangan = 1 )

    cout << “se”;

    cout << “ratus “;

    bilangan = puluhan;

    konversikan();

    }

    }

    void konversi::membilang3()

    {

    int satuan;

    if ( bilangan > 19 && bilangan < 100 )

    {

    satuan = bilangan % 10;

    bilangan = bilangan / 10;

    konversikan();

    cout << ” puluh “;

    bilangan = satuan;

    konversikan();

    }

    }

    void konversi::membilang1()

    {

    switch ( bilangan )

    {

    case 0:

    cout << “nol\n”;

    break;

    case 1:

    cout << “satu\n”;

    break;

    case 2:

    cout << “dua\n”;

    break;

    case 3:

    cout << “tiga\n”;

    break;

    case 4:

    cout << “empat\n”;

    break;

    case 5:

    cout << “lima\n”;

    break;

    case 6:

    cout << “enam\n”;

    break;

    case 7:

    cout << “tujuh\n”;

    break;

    case 8:

    cout << “delapan\n”;

    break;

    case 9:

    cout << “sembilan\n”;

    break;

    case 10:

    cout << “sepuluh\n”;

    break;

    case 11:

    cout << “sebelas\n”;

    break;

    default:

    cout << “diluar range\n”;

    }

    }

    void konversi::membilang2()

    {

    int temp;

    if ( bilangan > 11 )

    {

    bilangan %= 10;

    membilang1();

    cout << “belas”;

    }

    }

    int main(int argc, char *argv[])

    {

    konversi a;

    cin >> a;

    a.konversikan();

    system(“PAUSE”);

    return EXIT_SUCCESS;

    }

    :: RESUME CLASS DENGAN C++

    class mirip dengan array, yaitu tipe turunan yang elemennya merupakan elemen dengan tipe lai. Tidak seperti array, elemen dari class dapat mempunyai tipe yang berbeda. Class juga bisa di sebut sebagai 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:

    class name{ 

    public:

    public data and function

    private:

    private data and function

    };

    object list;

    contoh deklarasi class

    class Pecahan{ 

    public:

    void Isikan(int,int);

    double Nilai();

    void SeperX();

    void Cetak();

    private:

    int lang, but ;

    };

    Deklarasi ini dimulai dengan kata kunci class diikuti dengan nama dari class tersebut,dan diakhiri dengan titik koma. nama class ini adalah contoh.

    fungsi Isikan(), Nilai(), SeperX() 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 Pecahan{

    public:

    void Isikan (int,int);

    double Nilai( );

    void SeperX( );

    void Cetak( );

    private:

    int lang, but;

    };

    Void Pecahan :: Isikan (int pembilang, int penyebut ){

    lang = pembilang ;

    but = penyebut;

    }

    double Pecahan :: Nilai ( ){

    return double (lang)/ but;

    }

    void Pecahan :: SeperX( ){

    int temp = lang ;

    lang = but ;

    but = temp;

    }

    void Pecahan :: Cetak( ){

    cout<< lang  <<” / “<< but ;

    }

    int main(int argc, char *argv[])

    {

    Pecahan X;

    X.Isikan (22,7);

    cout << “ x = “;

    X. Cetak( );

    cout << “ =” << X.Nilai ( )<< endl;

    X.SeperX ( );

    cout<< “1/x = “ X.Cetak ( );

    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:

    class cobacoba{ 

    public:

    cobacoba();

    ~cobacoba();

    contoh program :

    #include <cstdlib>

    #include <iostream>

    using namespace std;

    class myhome{

    public:

    int x;

    myhome();

    ~myhome();

    };

    Myhome::myhome(){

    x=50;

    }

    Myhome::~myhome(){

    cout<<“Destructing…”<<endl;

    }

    int main(int argc, char *argv[])

    {

    myhome the1;

    cout<<the1.x<<“”;

    cout<<endl;

    the1.~myhome();

    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;

    }
    Overload fungsi pada bahasa C++ 

    1. Function Overloading

    Function overloading adalah suatu proses menggunakan nama yang sama untuk dua atau lebih fungsi. Setiap definisi ulang dari fungsi yang di overloading harus menggunakan tipe parameter, urutan parameter, atau jumlah parameter yang berbeda. Jumlah, tipe atau urutan parameter dari suatu fungsi disebut function signature. Jika kita memiliki sejumlah fungsi dengan nama yang sama, compiler akan mengidentifikasi fungsi-fungsi tersebut berdasarkan parameternya. Keuntungan memiliki beberapa fungsi dengan nama yang sama dapat dilihat pada program berikut :

    #include <iostream>
    using namespace std;
    class Overload {
    public:
    int max(int, int);
    float max(float, float);
    };
    int Overload::max(int num1, int num2)
    {
    if (num1 > num2)
    return num1;
    else
    return num2;
    }
    float Overload::max(float num1, float num2)
    {
    if (num1 > num2)
    return num1;
    else
    return num2;
    }
    int main()
    {
    Overload o;
    cout << o.max(5.4F,8.6F) << endl;
    cout << o.max(19,12) << endl;
    return 0;
    }

    2. Function Signature

    Signature dari suatu fungsi didefinisikan dengan
    a. Jumlah parameter yang dimiliki fungsi
    Contoh :
    void add(int);
    void add(int, float);

    Pada contoh ini dua fungsi bernama add() ini berbeda karena jumlah parameternya berbeda
    b. Tipe data parameter fungsi
    Contoh :
    void display(int)
    void display(char)

    Pada contoh ini dua fungsi bernama display() ini berbeda karena tipe parameternya berbeda
    c. Urutan tipe data dari parameter fungsi
    Contoh :
    void display(int, char)
    void display(char, int)

    Pada contoh ini dua fungsi bernama display() ini berbeda karena urutan tipe parameternya
    berbeda
    d. Nilai return suatu fungsi TIDAK membedakan 2 fungsi dengan nama yang sama. Karena itu
    deklarasi fungsi di bawah ini tidak bisa diletakkan dalam satu class yang sama
    void display()
    char display()

    Constructor Overloading

    #include <iostream>
    using namespace std;
    class Calculator
    {
    private:
    int number1, number2, tot;
    public:
    Calculator();
    Calculator(int, int);
    void input(int, int);
    void add();
    void disp();
    }; Calculator::Calculator()
    {
    number1 = number2 = tot = 0;
    }
    Calculator::Calculator(int num1, int num2)
    {
    number1 = num1;
    number2 = num2;
    }
    void Calculator::input(int num1, int num2)
    {
    number1 = num1;
    number2 = num2;
    }
    void Calculator::add()
    {
    tot = number1 + number2;
    }
    void Calculator::disp()
    {
    cout << “The sum of two numbers is ” << tot << endl;
    } int main()
    {
    Calculator cal1;
    Calculator cal2(4,3);
    Calculator *calptr;
    calptr = new Calculator(5,10);
    cal2.add();
    cal2.disp();
    calptr->add();
    calptr->disp();
    delete calptr;
    return 0;
    }

    3. Memahami perlunya melakukan overloading operator

    Konsep overloding fungsi dapat juga diterapkan pada operator. Yang dimaksud dengan operator overloading adalah menambah fungsi dari operator C++ normal jika digunakan pada tipe data yang didefinisikan oleh user (user-defined data types). Hanya operator C++ yang bersifat predefined yang dapat di overload. Dengan menggunakan operator overloading maka user dapat memahami notasi dengan lebih mudah daripada dengan menggunakan fungsi karena lebih mendekati implementasi sebenarnya.

    4. Meng-overload operator unary

    Operator unary dapat didefinisikan sebagai member function yang tidak mengambil parameter atau non-member function yang mengambil 1 parameter.

    Berikut ini adalah contoh program sederhana untuk meng-overloading operator  :

    #include <iostream>
    using namespace std;
    class MyOp
    {
    private:
    int a;
    int b;
    public:
    void operator -();
    void accept(int, int);
    void print();
    };
    void MyOp::operator -() {
    a = -a;
    b = -b;
    }
    void MyOp::accept(int x, int y)
    {
    a = x;
    b = y;
    }
    void MyOp::print()
    {
    cout << “a = ” << a << endl;
    cout << “b = ” << b << endl;
    }
    int main()
    {
    MyOp m;
    m.accept(26, -9);
    m.print();
    -m; m.print();
    return 0; }

    :: PENURUNAN CLASS PADA BAHASA C++

    Pewarisan (inheritance) adalah penurunan sifat yang ada pada suatu kelas

    kepada kelas baru yang menjadi turunannya. Sifat-sifat suatu kelas ditentukan oleh

    data anggota dan metode, sehingga yang dimaksud penurunan sifat adalah penurunan

    data anggota atau metode. Kelas yang menurunkan sifat disebut kelas dasar (base

    class), sedangkan yang kelas baru yang mewarisi sifat kelas dasar disebut kelas

    turunan (derived class).

    Dengan pewarisan dapat diciptakan suatu kelas baru yang mana kelas tersebut

    mewarisi seluruh sifat kelas dasar yang mempunyai akses public atau protected

    ditambah sifat khusus dari kelas yang bersangkutan. Ketentuan ini tidak berlaku

    sebaliknya, artinya sifat yang ada pada kelas turunan tidak diwariskan pada kelas

    Kelas turunan

    Sifat A

    Ketentuan utama dengan adanya pewarisan yaitu memungkinkan suatu kode yang telah ditulis mudah sekali untuk digunakan kembali. Anda telah membuat suatu kelas yang telah diuji. Jika suatu nanti, anda ingin menerapkan kode tersebut pada sesuatu yang mempunyai sifat-sifat kelas tersebut, anda tinggal mewariskan kelas yang

    telah ada di kelas baru (kelas turunan). Anda tidak perlu mengotak-atik kelas yang

    teruji, sehingga efek samping yang tidak diharapkan tidak terjadi. Dengan cara ini

    pengembangan program menjadi lebih efisien dan menghemat waktu. Selain itu, anda

    dapat menambahkan sifat-sifat baru yang tidak ada pada kelas dasar atau bahkan

    dapat mengganti sifat-sifat pada kelas turunan, yang berbeda dengan sifat kelas dasar.

    Dari mekanisme pewarisan yang sudah diuraikan diatas, dapat disimpulkan

    bahwa pewarisan ini dikelompokkan menjadi tiga, yaitu :

    1. Pewarisan Tunggal (single inheritance)

    2. Pewarisan Jamak (multiple inheritance), dan

    3. Pewarisan Jamak Maya (virtual multiple inheritance)

    12.1. PEWARISAN TUNGGAL (SINGLE INHERITANCE)

    Adalah pewarisan yang mana jumlah kelas dasarnya tunggal. Pada pewarisan

    ini, kelas turunan dapat berjumlah lebih dari satu. Pewarisan tunggal dapat

    digambarkan dengan sintak program sebagai berikut :

    class A

    {

    . . .

    };

    class B : public A

    {

    . . .

    }

    Sintak di atas adalah mekanisme pewarisan secara public. Dengan implementasi

    di atas, kelas B merupakan kelas turunan dari kelas A. Selain pewarisan public,

    pewarisan juga dilakukan secara protected maupun private.

    Contoh program pewarisan tunggal :

    #include<iostream.h> 

    class makhluk

    {

    public:

    void berkembang();

    };

    class hewan : public makhluk

    {

    public:

    void bergerak();

    };

    class kuda : public hewan

    {

    public:

    void berlari();

    };

    main()

    makhluk mk;

    cout<<endl<<” Sifat-sifat dari Makhluk adalah : “<<endl;

    mk.berkembang();

    cout<<endl<<” Sifat-sifat dari Hewan adalah : “<<endl;

    hw.berkembang();

    cout<<endl<<” Sifat-sifat dari Kuda adalah : “<<endl;

    mk.berkembang();

    hewan hw;

    kuda kd;

    hw.bergerak();

    hw.bergerak();

    kd.berlari();

    void makhluk::berkembang()

    cout<<” Berkembang biak”<<endl;

    void hewan::bergerak()

    cout<<” Bergerak berpindah tempat”<<endl;

    void kuda::berlari()

    cout<<” Berlari sangat kencang seperti angin”<<endl;

    }

    :: PEWARISAN JAMAK (MULTIPLE INHERITANCE)

    adalah pewarisan dimana satu kelas diturunkan lebih dari satu kelas yang

    berbeda. Dalam pewarisan ini jumlah kelas dasarnya lebih dari satu, dan perlu dicatat

    bahwa kelas dasarnya bukan merupakan turunan dari satu kelas. Kelas turunan

    mewarisi seluruh sifat dari kelas dasarnya, sehingga sifat dari beberapa kelas dasar

    dan sifat khas dirinya. Perhatikan sintak dari pewarisan tunggal berikut ini :

    class A

    {

    . . .

    };

    class B

    {

    . . .

    }

    class C: public A, public B

    {

    . . .

    }

    Pada bentuk tersebut terdapat dua kelas dasar yaitu kelas A dan kelas B yang

    menurunkan kelas C. Kelas C akan mewarisi sifat dari kelas A maupun sifat dari kelas

    B, tetapi tidak berlaku sebaliknya.

    Perhatikan contoh program berikut ini :

    #include<iostream.h> 

    class kuda

    {

    public :

    void berlari()

    {

    cout<<” > Berlarinya sangat cepat”<<endl;

    }

    };

    class burung

    {

    public:

    void terbang()

    {

    cout<<” > Terbang menembus awan”<<endl;

    }

    };

    class pegasus: public kuda, public burung

    {

    public:

    void lariterbang()

    {

    cout<<” > Bersayap, lari dan dapat terbang ke

    angkasa”<<endl;

    }

    };

    main()

    {

    pegasus pg;

    cout<<“Sifat dari PEGASUS yaitu : “<<endl;

    pg.berlari();

    pg.terbang();

    pg.lariterbang();

    }

    }

:: Semoga ini bisa bermanfaat ::

Kategori:Uncategorized

Hello world!

21 September 2010 1 komentar

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!

Kategori:Uncategorized