oop - overloaded, polymorphism & composition

CHAPTER 7 : OVERLOADED, POLYMORPHISM, COMPOSITION

FUNCTION OVERLOADING

Function overloading merupakan satu kebolehan c++ membenarkan beberapa fungsi yang mempunyai nama yang sama ditakrifkan, asalkan setiap fungsi tersebut mempunyai set parameter yang berbeza.
Apabila sesuatu function overloading dipanggil, pengkompil c++ akan memeriksa fungsi tersebut berdasarkan bilangan, jenis data dan susunan argumen dalam panggilan.
Kebiasaan fungsi overloading digunakan untuk menghasilkan beberapa fungsi dengan nama yang sama untuk melaksanakan tugas yang sama, tetapi mempunyai jenis data yang berlainan.
contoh1

            //using overloading function
            #include <iostream.h>
            int square (int x){return x*x;}
            double square (double y) { return y*y;}
            int main(){
                cout << "The square of integer 7 is " << square(7)
                        << "\nThe square of double 7.5 is " << square(7.5)
                        << endl;
                return 0;
            }

contoh2

            #include <iostream.h>
            void show(int val){
                cout << " integer " << val << endl;
            }

            void show (double val){
                cout << " double " << val << endl;
            }

            void show (char *val) {
                cout << " string " << val << endl;
            }

            int main(){
                show(12);
                show(3.1415);
                show(" Hello world");
                return 0;
            }

CONSTRUCTOR OVERLOADING

to gain flexibility
to support array
contoh1

            #include <iostream.h>
            class myclass {
                int x;
            public:
                //overload constructor two ways
                myclass() {x=0;}        // no initializer
                myclass(int n) { x= n;}    // initializer
                int getx() { return x;}
            };

            main(){
                myclass o1(10);        // declare with initial value
                myclass o2;               // declare without initializer
                cout << "o1: " << o1.getx() << endl;
                cout << "o2: " << o2.getx() << endl;
                return 0;
            }

contoh 2:

            #include <iostream.h>
            class myclass{
                int x;
            public:
                //overload constructor two ways
                myclass() {x=0;}        // no initializer
                myclass(int n) { x= n;}    // initializer
                int getx() { return x;}
            };

            main(){
                myclass o1[0];        // declare array withot initializers
                myclass o2[10]={1,2,3,4,5,6,7,8,9,10};               // declare without initializer
                int i;
                for (i=0; i<10; i++){
                    cout << "o1[ " << i<<"] : "<< o1[i].getx() << endl;
                    cout << "o2[ " << i<<"] : "<< o2[i].getx() << endl;
                }
                return 0;
            }

COPY CONSTRUCTOR

semua constructor mempunyai ciri-ciri berikut :-

tidak memulangkan nilai
boleh ditakrifkan sebagai fungsi-fungsi yang mempunyai nama yang sama
senarai argumen bagi sesuatu constructor boleh diringkaskan daripada kod atau copy constructor.

berasaskan pernyataan (iii), copy constructor yang digunakan untuk construct object boleh disediakan dengan membuat salinan daripada object lain.
aturcara menunjukkan copy constructor TAnyClass(TAnyClass &copy) yang mempunyai nama yang sama dengan nama kelas iaitu TAnyClass & menakrifkan satu reference &copy kepada object TAnyClass.
ex:

            #include <string.h>
            class TAnyClass {
            private:
                int i; double r; char *s;
            public:
                TAnyClass() {
                    i=0; r=0; s=NULL;
                TAnyClass(int ii, double rr, const char *ss){
                    i=ii; r=rr; s=strdup(ss);
                }
                ~TAnyClass() {delete s;}
                const char *GetStar(void) { return s;}
                TAnyClass(TAnyClass &copy);                //copy constructor
            };

            TAnyClass::TAnyClass(TAnyClass &copy){
                cout << "\ninside TAnyClass's copy constructor\n";
                i = copy.i;
                r = copy.r;
                if (copy.s)
                    s = strdup(copy.s)
                else
                    s = NULL;
            }

            main(){
                TAnyClass v1;
                TAnyClass v2(1,2, " a test string ");
                TAnyClass v3 = v2;
            }

POLYMORPHISM

Polymorphism bermaksud :

kebolehan objek-objek dari kelas yang berlainan, bertindakbalas terhadap mesej yang sama secara berlainan.
mesej yang sama (contoh member function call) dihantar kepada objek berlainan yang akan menghasilkan keputusan yang berlainan.
contohnya :

kelas rectangle dihasilkan dari kelas quadrilateral, dimana objek rectangle merupakan versi yang spesifik bagi objek quadrilateral. Satu operasi (contohnya pengiraan ukurliling atau luas) boleh dilaksanakan oleh objek quadrilateral dan juga objek rectangle.

Polymorphism dilaksanakan bersama virtual function.

virtual function?
pure virtual function?

VIRTUAL FUNCTION

Ahli fungsi sesuatu kelas yang ditakrifkan dalam base class kemudian ditakrif semula dalam derived class.
ex1:

            #include <iostream.h>
            class base{
            public:
                int i;
                base(int x) {i = x;}
                virtual void func(){
                    cout << " using base version of func():";
                    cout << i << endl;
                }
            };

            class derived1 : public base{
            public:
                derived(int x) : base(x) {}
                void func(){
                    cout << " using derived1's version of func() : ";
                    cout << i*i << endl;
                }
            };

            class derived2 : public base {
            public:
                derived2(int x) : base (x) {}
                void func(){
                    cout << "using derived2's version of func():";
                    cout << i + i << endl;
                }
            };

            main() {
                base *p;
                base ob(10);
                derived1 d_ob1(10);
                derived2 d_ob2(10);
                p = &ob;
                p->func();     //use base's func()
                p = &d_ob1;
                p->func();        //use derived1's func()
                p = &d_ob2;
                p->func();        //use derived2's func()
                return 0;
            }

virtual function inherit dalam bentuk susunan hiraki.
sekiranya derived class tidak override virtual function, function yang ditakrifkan dalam base akan digunakan.
contoh :

            #include <iostream.h>
            class base{
            public:
                int i;
                base (int x) { i =x; }
                virtual void func(){
                    cout << " using base version of func():";
                    cout << i << endl;
                }
            };

            class derived1 : public base{
            public:
                derived1(int x) : base(x){}
                void func(){
                    cout << "using derived1's version of func():";
                    cout << i * i << endl;
                }
            };

            class derived2 : public base{
            public:
                derived2(int x) : base(x) {}
                //derived2 does not override func()
            };

contoh1

            #include <iostream.h>
            class TValue {
            protected:
                int value;
            public:
                TValue(int n) {value = n;}
                virtual int GetValue(void) { return value;}
            };

            class TMult : public TValue{
            protected:
                int multiplier;
            public:
                TMult(int n, int m) : TValue(n) { multiplier = m;}
                virtual int GetValue(void) {return value * multiplier;}
            };

            main(){
                TValue *basep;
                basep = new TValue (10);
                cout << basep ->GetValue() << endl;
                delete basep;
                basep = new TMult(10,2);
                cout << basep->GetValue() << endl;
                delete basep;
                return 0;
            }

PURE VIRTUAL FUNCTION

a pure virtual function is an unfinished placeholder that a derived class is expected to complete.
penakrifan pure virtual function adalah sama seperti virtual function biasa, tetapi diakhiri penakrifan dengan = 0.
contoh:

            class AbstractClass {
            public:
                virtual void f1(void);                // normal virtual function
                virtual void f2(void) = 0;          // pure virtual function
                ..............
            };

Jika sesuatu kelas mempunyai satu atau lebih pure virtual function :

dipanggil kelas abstrak
oleh itu objek tidak boleh dihasilkan dalam kelas abstrak.
contoh :

Bagaimanapun ahli fungsi f1 boleh panggil f2

contoh :

Untuk menggunakan kelas abstract, anda perlu menghasilkan kelas baru.

contoh :

derived class myClass inherits pure virtual function, tetapi takrifannya tanpa =0. (Jika tidak jadi abstract class)

myClass perlu pelaksanaan bagi f2
contoh :

COMPOSITION

Composition bermaksud sesuatu kelas yang mengandungi object kelas lain
Hubungan kelas dengan sub-kelas dipanggil 'has a'
Dengan cara :

create instances of other class inside another class

Jika sesuatu objek mempunyai constructor yang mempunyai argumen

objek tersebut hendklah dinilai awalkan secara jelas di dalam senarai penilai awalan constructor.
gunakan nama object dan bukan nama kelas sebagai pewarisan (inheritance).

contoh

#include <iostream.h>

            class Date{
            int month, day, year;
            public:
                 Date(int,int,int);
                 void print();
            };

            Date::Date(int m,int d,int y){
             month=m;
             day=d;
             year=y;
             cout<<"Date object constructor:"<<endl;
            }

            void Date::print(){
             cout << month << day<< year;
            }

            class child{
            private:
                 char *name; Date birthday; Date regdate;
            public:
                 child(char*, int, int,int,int,int,int);
                 void print(void);
            };

            child:: child(char *nama,int bm, int bd, int by, int rm, int rd, int ry)
                     :birthday(bm,bd,by), regdate(rm,rd,ry){
                 name=nama;
                 cout<<"child object constructor:"<< name;
            }

            void child:: print(){
                 cout<<"\nchild name:"<< name;
                 cout<<"\nBirthdate:";birthday.print();
                 cout<<"\nRegister date for school:"; regdate.print();
            }

            main(){
                 child a ("azman",10,11,92,1,1,99);
                 a.print();
                 return 0;
            }

Anda dikehendaki sentiasa menyemak latihan lab anda dari masa ke semasa