Tablica.cpp

#include "stdafx.h"
#include "tablica.h"

//inicjalizowanie zmiennej statycznej klasy, licznika obiektow
//********************************************************************************
int Tablica::ilosc = 0;
int Tablica::str_lngt = 20;
//********************************************************************************
Tablica::Tablica()
{
    ilosc++;
    id = Tablica::ilosc;
    nazwa = "Tablica";
    nazwa += id;
}
//********************************************************************************
Tablica::Tablica(int rozmiar) : n(rozmiar)
{
    ilosc++;
    id = Tablica::ilosc;
    tab = new double[n];
    wyzeruj();
    nazwa = "Tablica";
    nazwa += id;
}
//********************************************************************************
Tablica::Tablica(int rozmiar, char *name) : n(rozmiar)
{
    ilosc++;
    id = Tablica::ilosc;
    tab = new double[n];
    wyzeruj();
    nazwa = name;
}
//********************************************************************************
Tablica::Tablica(const Tablica& kTablica) : n(kTablica.n)
{
    ilosc++;
    // pobieramy rozmiar kopiowanej tablicy
    tab = new double(n);
    // kopiujemy tablice
    memcpy(tab, kTablica.tab, n*sizeof(double));
    srd = kTablica.srd;
    id = Tablica::ilosc;
    nazwa = "Tablica";
    nazwa += id;
}
//********************************************************************************
Tablica::~Tablica()
{
    cout << "\nDESTRUKOR: " << this->nazwa << endl ;
    ilosc--;
    delete[] tab;
    tab = NULL;
}
//********************************************************************************
void Tablica::wypelnij()
{
    for(int i=0; i<n; i++)
        {
            do{
                cout << "Wprowadz " << i+1 << "# element: ";
                cin.clear(); cin.sync();
                cin >> tab[i]; cout <<endl;
              }while(cin.fail());
        }
    srednia();
}
//********************************************************************************
void Tablica::wyzeruj()
{
    for(int i=0; i<n; i++) {tab[i]=0;}
}
//********************************************************************************
void Tablica::srednia()
{
    double temp = 0;
    for(int i=0; i<n; i++)
    {
        temp += tab[i];
    }
    srd = (double)temp/(double)n;

}
//********************************************************************************
void Tablica::wyswietl(int m, int p) const
{
        system("CLS");
        cout << "\nTablica nr:" << this->id <<endl;
        cout << "\t--------------\n";
        cout << "\tSrednia : " << srd;
        cout << "\n\t--------------\n";

    if(m==1) //notacja dziesietna
    {
        for(int k=0; k<n; k++)
        {
            cout << "\t" << k+1 <<")\t"<< setprecision(p) << fixed << tab[k] << endl;
        }
    }
    if(m==2)//notacja naukowa
    {
        for(int k=0; k<n; k++)
        {
            cout << "\t" << k+1 <<")\t"<< setprecision(p) << scientific << tab[k] << endl;
        }
    }
    if(m==3)//notacja szesnastkowa
    {
        for(int k=0; k<n; k++)
        {
            unsigned tmp = static_cast<unsigned int>(tab[k]);
            cout << "\t" << k+1 <<")\t"<< hex << tmp << endl;
        }
    }
    cout << "\t--------------\n\n";
}
//********************************************************************************
size_t Tablica::ilosc_bajtow() const
{
    return (sizeof(*this));
}
//********************************************************************************
void Tablica::insert_sort()
    {
     int k;
     double temp;

     for(int i=0; i<(n-1); i++)
     {
        if(tab[i+1]<tab[i])                   //Sprawdzamy czy element na nastepnej pozycji jest mniejszy od obencego.
          {
            k = i;
            while(tab[i+1]<tab[k])            //Wtedy zliczamy do poczatku ile jest mniejszych elementow
            {                                 //Zmienna k to wskaznik odpowiedniego miejsca.
                k--;
            }
            if(k==i) swap(tab[i], tab[i+1]);  //Jezeli element przesuwamy tylko o jedno miejsce,
                                              //poprostu zamieniamy dwa sasiadujace.
            else                              //W innym wypadku, kopiujemy element do tempa, przesuwamy
            {                                 // wszytskie elementy w prawo, i wsadzamy go w odpowiednie miejsce.
                temp = tab[i+1];

                for(int l=i+1; l>k; l--)
                {
                    tab[l] = tab[l-1];
                }

                tab[k+1] = temp;
            }
          }
      }
     wyswietl(1,0);
    }
//********************************************************************************
Tablica Tablica::operator+(const Tablica& b)
{
    int rB = b.rozmiar();
    int rA = rozmiar();
    int k = (rA > rB) ? rA : rB;  //r --> rozmiar wiekszej z dodawanych tablic
    Tablica temp(k);
    for(int i=0; i<k ; i++)
    {
        temp.tab[i] = ((i >= rA) ? 0 : tab[i]) + ((i >= rB) ? 0 : b.tab[i]);
    }
    temp.srednia();
    return temp;
}
//********************************************************************************
Tablica& Tablica::operator=(const Tablica& obiekt)
{
    if(&obiekt == this) return *this;
    if(obiekt.n != n)
    {
        delete[] tab;
        n = obiekt.n;
        tab = new double[n];
    }

    memcpy(tab, obiekt.tab, n*sizeof(double));
    srd = obiekt.srd;
    return *this;
}
//********************************************************************************