/*
  Name: Zadanie tablica1D dziedziczenie
  Author: Piotr Leżoń
  Date: 10-01-06 21:01
  Description: 
*/

#include <iostream.h>                                                       
class tablica1D               
{
    protected:
        int rozmiar1; int *tab;
    public:
        tablica1D(int rozm=5);
        ~tablica1D();
        tablica1D& operator=(const tablica1D& p);
        void wysw();
        int minimum();
};   
                                             
tablica1D::tablica1D(int r)
{                
    rozmiar1=r;
    tab = new int[rozmiar1];   //tworzymy dynamicznie nowa tablice o rozmiarze r
    assert(tab != 0);
    for(int i=0;i<rozmiar1;i++)
    {                  
    tab[i]=rand()%100;         //wypelniamy tablice losowymi wartosciami 0-99                           
    }                                               
}
                                                   
tablica1D::~tablica1D()                             
{                                                   
    delete []tab;              //destruktor - zwalniamy pamiec po tablicy
}
                                                   

tablica1D& tablica1D::operator=(const tablica1D& k) 
{      
    if(this->tab != k.tab)               //nie kopiujemy tablicy na siebie sama!               
    {
    this->rozmiar1=k.rozmiar1;                                        
    delete []tab;                                               
    tab = new int[k.rozmiar1];                                  
    assert(tab != 0);                                               
    for(int i=0;i<rozmiar1;i++) tab[i]=k.tab[i];                
    }
    return *this;            
}


void tablica1D::wysw()        //wyswietlamy zawarosc tablicy                   
{
    for(int i=0;i<rozmiar1;i++) 
    {
            cout<<tab[i]<<"\t";
    }
}

int tablica1D::minimum()      //znajdujemy sobie minimum
{
    int min=tab[0];
    for(int i=0;i<rozmiar1;i++)
    {
        if(tab[i]<min) min=tab[i];
    }
    return min;
}                                                               

class tablica2D:public tablica1D         //tablica2D dziedziczy z tablica1D
{
       tablica1D *tab2;                  //tablica wskaznikow na tablica1D
       int rozmiar2;
       public:                                 
           tablica2D(int rozm2=4);      //konstruktor domyslny
           ~tablica2D();                //destruktor
           void wysw();                 //metoda klasy wyswietlajaca tablice dwuwymiarowa
           tablica1D minimum();               //metoda klasy znajdujaca minimum
};                                                              

tablica2D::tablica2D(int rozm)          //konstruktor
{          
    rozmiar2=rozm;
    tab2=new tablica1D[rozmiar2];       //tworzymy nowa tablice wskaznikow na tablica1D
    assert(tab2 != 0);
    for(int i=0;i<rozmiar2;i++)                                 
    {
     tab2[i]=tablica1D(i+3);            //tworzymy tablica1D(i+3) rozmiar2 razy
    }
}

tablica2D::~tablica2D()                                 
{                           
     delete []tab2;                                      
} 
                                                     
void tablica2D::wysw()                              
{                                                                     
     for(int i=0;i<rozmiar2;i++)                         
     {                   
         tab2[i].wysw();
         cout << endl;
     }                                                   
}      
                                                 
tablica1D tablica2D::minimum()                                
{
  rozmiar1=rozmiar2;
  for(int i=0;i<rozmiar2;i++)
  {
          this->tab[i]=tab2[i].minimum();
  }
  return *this;                      
}                                                       

int main()                                              
{                                                       
     srand(time(NULL)); 
     //tablica1D
     int r1, r2;
     r1=rand()%10+1;
     r2=rand()%10+1;
     tablica1D t1(r1),t2(r2),t3;                                                         
     t1=t2;         //test operatora prypisania
     t1.wysw();
     cout<<"\nMinimum: "<<t2.minimum()<<endl;       //minimum z tablicy t2 
     cout<<endl;  
     //teraz tablica2D
     tablica2D a1;
     a1.wysw();      
     t3=a1.minimum();
     cout<<"Minimum z tablicy dwuwymiarowej: ";
     t3.wysw(); 
     cout<<endl<<endl;       
     system("PAUSE");                                    
     return 0;                                           
}