Programowanie Obiektowe 05

Wzorce klas, dziedziczenie

Uwaga: proszę uruchamiać poniższe programy tworząc dla każdego z nich oddzielny projekt w Dev­

cpp.   Projekty   proszę   zapisywać   w   katalogu   „Moje  dokumenty”.  Dla   każdego  projektu   proszę 
utworzyć oddzielny katalog, np: przyklad_1_wzorzec_funkcji.

Przykład 1 – wzorzec funkcji.

// wzorzec funkcji oblicz_max

#include <cstdlib>
#include <iostream>

using namespace std;

template <typename T>//standardowa definicja wzorca funkcji

T oblicz_max (T a, T b) {
  T rezultat;

  rezultat = (a>b)? a : b;
  return (rezultat);

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

{
    int i=5, j=6, k;

  long l=10, m=5, n;
  double o=­1.23, p=0.12, q;

  k=oblicz_max<int>(i,j);//wywolanie funkcji dla liczb typu 'int'
  n=oblicz_max<long>(l,m);//wywolanie funkcji dla liczb typu 'long'

  q=oblicz_max<double>(o,p);//wywolanie funkcji dla liczb typu 'double'
  cout << k << endl;

  cout << n << endl;
  cout << q << endl;

    system("PAUSE");
    return EXIT_SUCCESS;

}

Przykład 2 – wzorzec klasy „sumowanie”

#include <iostream.h>
//skladnia definicji wzorca: template <lista_parametrow> deklaracja klasy

template <class typ_uniwersalny>
class sumowanie

{       typ_uniwersalny operand1;
        typ_uniwersalny operand2;

        typ_uniwersalny wynik;

 public:
        typ_uniwersalny oblicz(typ_uniwersalny aa, typ_uniwersalny bb);

 };

template <class typ_uniwersalny>
        typ_uniwersalny sumowanie<typ_uniwersalny>::oblicz(typ_uniwersalny aa, typ_uniwersalny bb)

{
operand1=aa;

operand2=bb;
wynik=operand1+operand2;

return wynik;
}

main()

{
 //int sum1;

     AnsiString suma1;
     //sumowanie<float> sum1;

     sumowanie<AnsiString> sum1;
     //suma1= sum1.oblicz(15,25);

     suma1=sum1.oblicz("to jest ","napis");
     cout<<suma1<<endl;

     system("PAUSE");
    return EXIT_SUCCESS;

}

Przykład 3 – wzorzec klasy do tworzenia obiektów typu wektor.

//przyklad wzorca klas
#include <iostream.h>

#include <vector>//biblioteka zawierajaca definicje klasy 'vector'

using namespace std;
//standardowa definicja wzorca klasy

template <typename T> //T okresla pewien "uniwersalny" typ
class MyQueue

{
     std::vector<T> data; //zmienna klasy "vector" obiektow typu T

   public:
     void Add(T const &); //metoda dodajaca element do wektora

     void Remove(); //metoda usuwajaca pierwszy element wektora
     void Print(); //drukuje na ekranie wektor

};

template <typename T> void MyQueue<T> ::Add(T const &d)
{

     data.push_back(d); //metoda dodajaca element na konec wektora, za
                        //aktualnym ostatnim elementem

}

template <typename T> void MyQueue<T>::Remove()
{

     data.erase(data.begin( ) + 0,data.begin( ) + 1);//metoda usuwa elementy
                                                     //wektora; w tym przypadku

                                                     //usuwa pierwszy element
}

template <typename T> void MyQueue<T>::Print()

{
     std::vector <int>::iterator It1;//zmienna, ktora pozwala na iterowanie po

                                     //elementach wektora
     It1 = data.begin(); //ustawienie iteratora na pierwszy element wektora

     for ( It1 = data.begin( ) ; It1 != data.end( ) ; It1++ )//petla iteruje po wszystkich
                                                            //elementach wektora

        cout << " " << *It1<<endl; //drukowanie wartosci elementow wektora
}

//Usage for C++ class templates
main()

{
     MyQueue<int> q; //tworzymy wektor liczb typu "int"

     q.Add(1);//dodajemy do wektora element o wartosci 1
     q.Add(2);//dodajemy do wektora element o wartosci 2

     cout<<"Przed usunieciem danych"<<endl;

     q.Print();//wydruk

     q.Remove();//kasowanie pierwszego elementu
     cout<<"Po usunieciu danych"<<endl;

     q.Print();//wydruk
     system("PAUSE");

    return EXIT_SUCCESS;
}

Przykład 4 ­ Dziedziczenie .

Poziomy dostępu dla dziedziczenia:

public – składowe publiczne klasy bazowej pozostają publiczne w klasie pochodnej. Składowe 

chronione klasy bazowej pozostają chronione w klasie pochodnej. 
protected­składowe publiczne klasy bazowej stają się chronionymi w klasie pochodnej.

private­składowe publiczne i chronione klasy bazowej stają się prywatnymi w klasie 
pochodnej.

#include <cstdlib>

#include <iostream>

using namespace std;

//definicja tworzenia klasy pochodnej:
//slowo_kluczowe (class) nazwa_klasy : modyfikator_praw_dostepu nazwa_klasy_bazowej

class student{

 protected:
        char *Imie;

        char *Nazwisko;
 public:

        student(char*, char*);
        ~student();

        void wyswietl_student();
 };

 student::student(char *nImie, char *nNazwisko)
 {Imie=new char[strlen(nImie)+1];

  strcpy(Imie,nImie);
  Nazwisko=new char[strlen(nNazwisko)+1];

  strcpy(Nazwisko,nNazwisko);
  }

 student::~student(){delete Imie; delete Nazwisko;}

 void student::wyswietl_student()
 {  char *tymczasowy=new char[50];

 strcat(tymczasowy,"Imie: ");
 strcat(tymczasowy,Imie);

 strcat(tymczasowy,"\n");
 strcat(tymczasowy,"Nazwisko: ");

 strcat(tymczasowy,Nazwisko);
 cout<<tymczasowy;

 delete tymczasowy;
 }

 class student_pwsz:public student{

  char *specjalnosc;
  public:

        student_pwsz(char *nImie, char *nNazwisko, char *specjalnosc);
        student_pwsz();

        ~student_pwsz();

 };

 student_pwsz::student_pwsz(char *nImie, char *nNazwisko, char *nspecjalnosc)
 :student(nImie, nNazwisko)

 {
  specjalnosc=new char[strlen(nspecjalnosc)+1];

  strcpy(specjalnosc,nspecjalnosc);
 }

 student_pwsz::~student_pwsz()

 {delete specjalnosc;}

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

    
    student *st1;

       st1=new student("Anna","Kowalska");
       st1­>wyswietl_student();

       delete st1;
       student_pwsz *st2=new student_pwsz("Jan","Kowalski","ASiSK");

       st2­>wyswietl_student();
       delete st2;

    
    system("PAUSE");

    return EXIT_SUCCESS;
}