tugas pak tedi buat class antrian(Queue)

#include <cstdlib>
#include <iostream>
#include "queue"

using namespace std;
class Queue {
public:
       Queue(int MaxQueueSize= 5);
       ~Queue(){delete [] queue;}
       bool IsEmpty()const {return front == rear ;}
       bool IsFull () const{
            return( ((rear+1)% MaxSize == front ) ? 1:0);}
       int First() const;
       int Last() const;
       Queue& Add(const int x);
       Queue& Delete(int x);
private:
         int front;
         int rear;
         int MaxSize;
         int*queue;
         };
        
Queue::Queue(int MaxQueueSize){
       MaxSize = MaxQueueSize +1;
       queue = new int[MaxSize];
       front = rear = 0;
       }

int Queue::First()const
{      return queue[(front+1)% MaxSize];
       }

int Queue::Last()const
{      return queue [rear];
}

Queue& Queue::Add(const int x){
       rear =(rear + 1)%MaxSize;
       queue[rear] = x;
       return*this;
       }
      
Queue& Queue::Delete(int x){
      front =(front + 1)%MaxSize;
      x = queue[front];
       return*this;
       }
      

int main(int argc, char *argv[])
{
   
    Queue Q(3);
    int x;
    try{Q.Add(1).Add(2).Add(3).Add(4);
       cout<<"No queue add failed"<<endl;}
    catch(...)
       {cout<<"\nA queue add failed"<<endl;}
    cout<<"\nQueue is now 123"<<endl;
    Q.Delete(x);
    cout<<" Deleted "<<x<<endl;
    cout<<Q.First()<<" == is at front "<<endl;
    cout<<Q.Last()<<" == is at end "<<endl;
    try{
        Q.Delete(x);
        cout<<"Deleted"<<x<<endl;
        Q.Delete(x);
        cout<<"Deleted"<<x<<endl;
        Q.Delete(x);
        cout<<"Deleted"<<x<<endl;
        cout<<"No queue delete failed"<<endl;
        }
        catch(...)
        {cout<<"A delete has failed"<<endl;}
       
    system("PAUSE");
    return EXIT_SUCCESS;
}



atau program kelas dengan yang ini  yaitu kelas antrian





template<class T>
class antrian{
      public:
             antrian(int maksAntri=10);
             ~antrian(){delete[]antri;}
             bool isempty()const{return front==rear;}
             bool isfull()const{
                  return(((rear+1)%makssize==front)?1:0);}
             T first()const;
             T last()const;
             antrian<T>& add(const T& x);
             antrian<T>& hapus(T& x);
      private:
              int front;
              int rear;
              int makssize;
              T *antri;
     
      };

template<class T>
      antrian<T>::antrian(int maksAntri){
      makssize=maksAntri+1;
      antri=new T[makssize];
      front=rear=0;                       
                                    }
     
template<class T>
      T maksAntri::first()const{
      return antri[(front+1)%makssize];
                                }

template<class T>
      T antrian<T>::last()const{
      return antri[rear];
                                }

template<class T>
      antrian<T>& antrian<T>::add(const T& x){
      rear=(rear+1)%makssize;
      antri[rear]=x;
      return *this;
                  }

      template<class T>
      antrian<T>& antrian<T>::hapus(T& x){
      front=(front+1)%makssize;
      x=antrian[front];
      return *this;
      }

prak 2 kbk

#include <cstdlib>
#include <iostream>


using namespace std;
class Operasi;

class Kompleks
{
friend class Operasi;
friend ostream& operator<<(ostream&, const Kompleks&);
friend istream& operator>>(istream&, Kompleks&);
public:
Kompleks(int s=0, int t=0):a(s),b(t){}
void cetak();
Kompleks operator-();
Kompleks operator-(const Kompleks&);
Kompleks operator+(const Kompleks&);
private:
int a;
int b;
};

void Kompleks::cetak(){


if(b>0) cout << "Bilangan Kompleks : " << a << "+" << b << "i";
else cout << "Bilangan kompleks : " << a << b << "i";
cout << endl;
}

Kompleks Kompleks::operator-(){
Kompleks x;
x.a=a;
x.b=-b;
return x;
}

Kompleks Kompleks::operator-(const Kompleks& m){
Kompleks x;
x.a=a-m.a;
x.b=b-m.b;
return x;
}

Kompleks Kompleks::operator+(const Kompleks& m){
Kompleks x;
x.a=a+m.a;
x.b=b+m.b;
}

ostream& operator<<(ostream& out, const Kompleks& x){
if(x.b==0) out << '[' << x.a << ']';
else if (x.a==0&&x.b==1) out << '[' << "i" << ']';
else if (x.a==0&&x.b==-1) out << '[' << "-i" << ']';
else if (x.a==0&&x.b>1) out << '[' << x.b << "i" << ']';
else if (x.a==0&&x.b<-1) out << '[' << x.b << "i" << ']';
else if (x.b==1) out << '[' << x.a << "+" << "i" << ']';
else if (x.b>1) out << '[' << x.a << "+" << x.b << "i" << ']';
else if (x.b==-1) out << '[' << x.a << "-i" << ']';
else out << '[' << x.a << x.b << ']';
return out;
}

istream& operator>>(istream& in, Kompleks& x){
cout << "Masukan bagian real     : ";
in >> x.a;
cout << "Masukan bagian imajiner : ";
in >> x.b;
return in;
}

class Operasi
{
public:
void cetak();
Kompleks jumlah(const Kompleks&, const Kompleks&);
Kompleks kali(const Kompleks&, const Kompleks&);
Kompleks kurang(const Kompleks&, const Kompleks&);
private:
int a;
int b;
};
void Operasi::cetak(){
if(b>0) cout << "Bilangan Kompleks : " << a << "+" << b << "i";
else cout << "Bilangan kompleks : " << a << b << "i";
cout << endl;
}

Kompleks Operasi::jumlah(const Kompleks& m, const Kompleks& n){
Kompleks temp;
temp.a=m.a+n.a;
temp.b=m.b+n.b;
return temp;
}

Kompleks Operasi::kurang(const Kompleks& m, const Kompleks& n){
Kompleks temp;
temp.a=m.a-n.a;
temp.b=m.b-n.b;
return temp;
}

Kompleks Operasi::kali(const Kompleks& m, const Kompleks& n){
Kompleks temp;
temp.a=(m.a*n.a)-(m.b*n.b);
temp.b=(m.a*n.b)-(m.b*n.a);
return temp;
}

int main(int argc, char *argv[])
{
Kompleks x(2, 3), y(4, -4), t;
Operasi z;
cout << "Menggunakan cetak() : "; x.cetak();
cout << "Menggunakan Overloading : " << x;
cout << "Konjugat : " << -x;
y.cetak();
cout << "\nPenjumlahan menggunakan method : ";
t=z.jumlah(x, y);
t.cetak();
cout << "Penjumlahan menggunakan operator : ";
t=x+y;
cout << x << "+" << y << "=" << t;
cout << "\nPerkalian menggunakan method : ";
t=z.kali(x, y);
z.cetak();
cout << "\nPerkalian menggunakan operator : ";

t-y;
cout << "\n" << x << "-" << y << "=" << t << endl;
Kompleks n;
cin >> n;
cout << n;
system("PAUSE");
return EXIT_SUCCESS;
}

prak 5 kbk

#include <iostream.h>
template <class T>

class Array1D{
      friend ostream& operator<<(ostream&,const Array1D<T>&);
public:
       Array1D(int size=0);
       Array1D(const Array1D<T>& v);
       Array1D(){delete[]element;}
       T& operator[](int i)const;
       int Size(){return size;}
       Array1D<T>& operator =(const Array1D<T>& v);
       Array1D<T> operator+()const;
       Array1D<T> operator+(const Array1D<T>& v)const;
       Array1D<T> operator-()const;
       Array1D<T> operator-(const Array1D<T>& v)const;
       Array1D<T> operator*(const Array1D<T>& v)const;
       Array1D<T>&operator+=(const T& x);
       Array1D<T>& ReSize(int sz);
       Array1D<T>& geser_kanan();
       Array1D<T>& geser_kiri();
private:
        int size;
        T*element;
};
template <class T>
Array1D<T>::Array1D(int sz)
{
                         size =sz;
                         element=new T[sz];
}
template <class T>
Array1D<T>::Array1D(const Array1D<T>& v)
{
                           size = v.size;
                           element=new T[size]; // get space
                           for (int i=0;i<size;i++)// copy elements
                           element[i]=v.element[i];
}
template <class T>
T& Array1D<T>::operator[](int i)const
{
                          return element[i];
}
template <class T>
Array1D<T>&Array1D<T>::operator =(const Array1D<T>& v)
{
                             if (this !=&v){
                                      size=v.size;
                                      delete[]element;
                                      element=new T[size];
                                      for(int i=0;i<size;i++)
                                      element[i]=v.element[i];
                                      }
                                      return *this;
}
template <class T>
Array1D<T>Array1D<T>::operator+(const Array1D<T>& v)const
{
             Array1D<T>w(size);
             for(int i=0; i<size;i++)
             w.element[i]=element[i]- v.element[i];
             return w;
}
template <class T>
Array1D<T>Array1D<T>::operator-(const Array1D<T>& v)const
{
         Array1D<T>w(size);
         for(int i=0; i<size;i++)
         w.element[i]=element[i]+ v.element[i];
         return w;
}
template <class T>
Array1D<T>Array1D<T>::operator-()const
{
          Array1D<T>w(size);
          for(int i=0; i<size;i++)
          w.element[i]=-element[i];
          return w;
}
template <class T>
Array1D<T>Array1D<T>::operator*(const Array1D<T>& v)const
{
         Array1D<T>w(size);
         for(int i=0; i<size;i++)
         w.element[i]=element[i]* v.element[i];
         return w;
}
template <class T>
Array1D<T>&Array1D<T>::operator+=(const T& x)
{
            for(int i=0; i<size;i++)
            element[i]+=x;
            return *this;
}
template <class T>
ostream& operator<<(ostream& out,const Array1D<T>& x)
{
            for(int i=0; i<x.size;i++)
            out<<x.element[i]<<" ";
            return out;
}
template <class T>
Array1D<T>&Array1D<T>::ReSize(int sz)
{
         delete[]element;
         size=sz;
         element=new T[size];
         return *this;
}
template <class T>
Array1D<T>&Array1D<T>::geser_kanan()
{
     int n = size;
     int temp = element[n-1];
     for (int i=n-1; i>=0; i--)
     element[i+1]=element[i];
     element[0]=temp;
}
template <class T>
Array1D<T>&Array1D<T>::geser_kiri()
{
     int n=size;
     int temp = element[0];
     for(int i=0; i<n; i++)
     element[i]=element[i+1];
     element[n-1]=temp;
    
}

int main()
{
    int X(10),Y,Z;
    for (int i=0; i<10; i++)
    X=i;
    cout<<" X = "<< X <<endl;
    cout<<" X is "<< X <<endl;
    Y=X;
    cout<<" Y is "<< Y <<endl;
    Y += 2;
    cout << " X incremented by 2 is " <<X<<endl;
    Z=(Y+X)*Y;
    cout<<"(Y+X)*y is " << Z <<endl;
    cout<< "-(Y+X)*Y is " << -Z <<endl;
    cout<<"setelah digeser kekanan :"<<(Y-X)*Y<<endl;
    cout<<"setelah digeser kekiri  :"<<(Y+X)<<endl;
    system("PAUSE");
}

prak 4

#include <cstdlib>
#include <iostream>
#define maks5

using namespace std;

class Array1D{
      friend ostream& operator<<(ostream&, const Array1D&);
      friend istream& operator>>(istream&, Array1D&);
public:
       Array1D();
       void cetak();
      
       void geser_kiri();
       void geser_kanan();
       void hapus_elemen();
private:
        char A[5];
};

//konstrukstor
Array1D::Array1D(){
                   for(int i=0;i<5;i++)
                   A[i]='O';
}

//methods yang sebetulnya tidak perlu ditulis
//jika sudeh ada overloading cout<<
void Array1D::cetak(){
     for(int i=0;i<5;i++)
     cout<<A[i]<<" ";
}

//overloading fungsi cetak
ostream& operator<<(ostream& out, const Array1D& x){
         for(int i=0;i<5;i++)
         out<<x.A[i]<<" ";
         out<<endl;
         return out;
}
        

//overloading input
istream& operator>>(istream& in, Array1D& x){
        
         //modifikasi untuk operator overloading
         //memasukkan nilai pada masing2 indeks secara terurut
         for(int i=0;i<5;i++){
                 cout<<"nilai array ke-"<<i+1<<" : ";
                 in>>x.A[i];
                 }
                 
         /*  badan fungsi sebelum di modifikasi
         int posisi;
         cout<<"Mengisi array posisi ke : ";
         in>>posisi;
         if(posisi>0 && posisi<=5){
                     cout<<"Masukkan elemen array-nya ; ";
                     in>>x.A[posisi-1];
                     }
         else
         cout<<"Anda memasukkan posisi di luar range....!";*/
         return in;
}

//fungsi untuk menggeser semua nilai 1 indeks ke kanan



void Array1D::geser_kanan(){
     int n=5;
     int temp=A[n-1];
     for(int i=n-1;i>=0;i--)
        A[i+1]=A[i];
     A[0]=temp;
}

//fungsi untuk menggeser semua nilai 1 indeks ke kiri
void Array1D::geser_kiri(){
     int n=5;
     int temp=A[0];
     for(int i=0;i<n;i++)
        A[i]=A[i+1];
     A[n-1]=temp;
}

//menthods yang di tambahkan untuk menghapus nilai dari indeks tertentu
void Array1D::hapus_elemen(){
     int posisi;
     cout<<"Pilih indeks berapa yang akan di hapus : ";
     cin>>posisi;
     if(posisi>0 && posisi<=5)
        A[posisi-1]=' ';
     else cout<<"indeks hanya terdiri dari 1 - 5\n";
}

//main fingsi
int main(int argc, char *argv[])
{
    Array1D x;
    cout<<"Array masih kosong : "<<x; //pemanggilan overloading output
    cin>>x; //penggunaan overloading input
    cout<<"Isi Array saat ini : "<<x;
    x.geser_kiri();  //penggunaan fungsi
    cout<<"Isi Array setelah di geser kiri : "<<x;
    x.geser_kanan();
    cout<<"Isi Array setelah di geser kanan : "<<x;
    cout<<"Urutan elemen pada indeksnya saat ini : "<<x;
    x.hapus_elemen();
    cout<<"Setelah dihapus menjadi : "<<x;
   
    system("PAUSE");
    return EXIT_SUCCESS;
}

#include <cstdlib>
#include <iostream>

using namespace std;
class bilangan{
      friend ostream& operator<<(ostream&, const bilangan&);
      friend istream& operator>>(istream&, bilangan&);
      public:
            bilangan(int a0=0, float b0=0.0):a(a0),b(b0){}
            void banding_int(const bilangan&, const bilangan&);
            bilangan& operator=(const bilangan&);
            bilangan operator+(const bilangan&)const;
            bilangan operator-()const;
      protected:
                int a;
                float b;
                float c;
    
      };

ostream& operator<<(ostream& out, const bilangan& x){
        out<<"Bagian integer: "<<x.a<<endl;
        out<<"Bagian float: "<<x.b<<endl;
        out<<"Bagian float: "<<x.c<<endl;
        return out;
        }
      
void bilangan::banding_int(const bilangan& x, const bilangan& y){
    if(x.a>y.a)cout<<x.a<<"::x lebih besar dari"<<y.a<<"::y";
    else cout<<x.a<<"::x lebih kecil dari"<<y.a<<"::y";
    }
  
bilangan& bilangan::operator=(const bilangan& x){
          a=x.a;
          b=x.b;
          c=x.c;
          return *this;
          }

istream& operator>>(istream& in, bilangan& x){
        cout<<"\nMasukkan bagian integer: ";
        in>>x.a;
        cout<<"Masukkan bagian float: ";
        in>>x.b;
        cout<<"Masukkan bagian float: ";
        in>>x.c;
        return in;
        }
      
bilangan bilangan::operator+(const bilangan& x)const{
        bilangan cc;
        cc.a=a+x.a;
        cc.b=b+x.b;
        cc.b=b+x.c;
        return cc;
        }
      
bilangan bilangan::operator-()const{
        bilangan x;
        x.a=-a;
        x.b=-b;
        x.b=-c;
        return x;
        }

class bil_char:public bilangan{
      friend ostream& operator<<(ostream&, const bil_char&);
      public:
            bil_char(int a0=0, int b0=0,char ch='x')
            :bilangan(a0,b0),c(ch){}
      private:
              char c;
            };
          
ostream& operator<<(ostream& out,const bil_char& x){
        out<<"Bagian integer: "<<x.a<<endl;
        out<<"Bagian float: "<<x.b<<endl;
        out<<"Bagian char: "<<x.c<<endl;
        return out;
        }

class bil_float:public bilangan{
      friend ostream& operator<<(ostream&, const bil_float&);
      public:
            bil_float(int a0=0, int b0=0,float fl='x')
            :bilangan(a0,b0),c(fl){}
      private:
              float c;
            };
//kelas Turunan Bil_Float
ostream& operator<<(ostream& out,const bil_float& x){
        out<<"Bagian integer: "<<x.a<<endl;
        out<<"Bagian float: "<<x.b<<endl;
        out<<"Bagian float: "<<x.c<<endl;
        return out;
        }
      
int main(int argc, char *argv[])
{
    cout<<"CLASS TURUNAN, CONSTRUKTOR CLASS BILANGAN, OPERATOR OVERLOADING :";
    cout <<"\nMETHOD BANDING"<<endl;
    bilangan s,t(-2,3.14),d;
    cout<<"Nilai awal s\n"<<s;
    cout<<"Nilai awal t dari deklarasi\n"<<t;
    s=t;
    cout<<"Setelah diassign t\n";
    cout<<"Nilai s\n"<<s;
    cout<<"Masukkan nilai-nilai objek d";
    cin>>d;
    cout<<"Setelah d+t=>\n"<<d+t;
    cout<<"Nilai d dinegatifkan\n"<<-d;
    bil_char ss;
    cout<<"Nilai awal ss\n"<<ss;
   
      
    system("PAUSE");
    return EXIT_SUCCESS;
}