Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Kurs C z elementami C++
Marek Piotrów - Wykład 13
22 stycznia 2008
Uwaga: w załacznikach do tego pliku znajdują si ę teksty prezentowanych przykładów (do łatwiejszego kopiowania).
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Zad. 2 - pierwsze.h
#ifndef __PIERWSZE__
#define __PIERWSZE__
typedef unsigned long long int ullint; ullint *next_primes(size_t n);
void reset_primes(ullint m);
#endif
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Zad. 2 - pierwsze.c
#include <stdlib.h>
#include "pierwsze.h"
static ullint next=2;
void reset_primes(ullint m)
{ next=(m > 2 ? m : 2); }
static int is_prime(ullint n)
{
if (n == 2) return 1;
if (n < 2 || n%2 == 0) return 0;
for (ullint i=3,ikw=9; ikw <= n; ikw+=4*i+4,i+=2) if (n%i == 0) return 0;
return 1;
}
ullint *next_primes(size_t n)
{
ullint *tab=(ullint *)calloc(n,sizeof(ullint)); if (tab == NULL) return NULL;
for (size_t i=0; i < n && next > 0; ++next) if (is_prime(next)) tab[i++]=next;
return tab;
}
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Zad 3 - rekurencyjne przekształcenie drzewa w kolejkę
#include <stdlib.h>
typedef struct wezel {
int x;
struct wezel *lewy, *prawy;
} WEZEL;
static WEZEL *scal(WEZEL *k1,WEZEL *k2)
{
if (k1 == NULL) return k2;
if (k2 == NULL) return k1;
WEZEL *k1_ostatni=k1->lewy, *k2_ostatni=k2->lewy; k1_ostatni->prawy=k2; k2->lewy=k1_ostatni; k2_ostatni->prawy=k1; k1->lewy=k2_ostatni; return k1;
}
WEZEL *do_kolejki(WEZEL *korzen)
{
if (korzen == NULL) return NULL;
WEZEL * lewy=do_kolejki(korzen->lewy); WEZEL * prawy=do_kolejki(korzen->prawy); korzen->lewy=korzen->prawy=korzen; lewy=scal(lewy,scal(korzen,prawy));
return lewy;
}
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Wzorzec klasy kolejka
# include <iostream>
# include <string>
using namespace std;
template <class Typ> class kolejka
{
private:
class element
{
friend class kolejka;
private:
Typ info;
element *nastepny;
public:
element(element *&list, const Typ &i);
~element(void);
public:
const Typ wartosc(void) { return(info); }
};
element *lista;
public:
kolejka(void);
~kolejka(void);
public:
void wstaw(const Typ &i);
void usun(void);
const Typ podaj(void);
};
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Kolejka - konstruktory i destruktory
template <class Typ>
kolejka<Typ>::element::element(element *&list, const Typ &i):info(i)
{
if (list != NULL) {
nastepny=list->nastepny;
list->nastepny=this;
}
else nastepny=this;
list=this;
}
template <class Typ>
kolejka<Typ>::element::~element(void)
{
}
template <class Typ>
kolejka<Typ>::kolejka(void)
{
lista=NULL;
}
template <class Typ>
kolejka<Typ>::~kolejka(void)
{
while (lista != NULL) usun();
}
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Kolejka - operacje
template <class Typ>
void kolejka<Typ>::wstaw(const Typ &i)
{
new element(lista,i);
}
template <class Typ>
void kolejka<Typ>::usun(void)
{
if (lista == NULL)
return;
if (lista->nastepny == lista)
{
delete lista;
lista=NULL;
return;
}
element *pom;
pom=lista->nastepny;
lista->nastepny=pom->nastepny;
delete pom;
}
template <class Typ>
const Typ kolejka<Typ>::podaj(void)
{
return (lista != NULL ? lista->nastepny->wartosc() : NULL);
}
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Kolejka - funkcja main
int main(void)
{
kolejka<int> kint;
kolejka<string> kstring;
cout<<"=== int ==="<<endl; for (int i=0; i < 10; i++) {
int liczba;
cin>>liczba;
kint.wstaw(liczba);
}
cout<<"==========="<<endl; for (int i=0;i < 10; i++) {
cout<<kint.podaj()<<’ ’;
kint.usun();
}
cout<<endl<<"=== String ==="<<endl; for (int i=0; i < 10; i++) {
char buf[128];
cin.getline(buf,sizeof(buf));
kstring.wstaw(string(buf));
}
cout<<"=============="<<endl; for (int i=0;i < 10; i++) {
cout<<kstring.podaj()<<endl; kstring.usun();
}
Marek Piotrów - Wykład 13
cout<<"=============="<<endl; return 0;
}
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Pola i metody statyczne
#include <iostream>
using namespace std;
class Figura2D {
protected:
static const double maxX=2000.0,maxY=1000.0; static unsigned liczbaFigur;
double x,y;
public:
Figura2D(double x0=0.0,double y0=0.0) {
if (x0 >= 0.0 && x0 <= maxX && y0 >= 0.0 && y0 <= maxY) {
x=x0; y=y0;
} else {
x=y=0.0;
cerr<<"Figura2D: inicjalizacja poza obszarem"<<endl;
}
++liczbaFigur;
}
virtual ~Figura2D() { --liczbaFigur; }
void przesun (double dx,double dy) { x+=dx; y+=dy; }
static unsigned ileFigur() { return liczbaFigur; }
};
unsigned Figura2D::liczbaFigur = 0;
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Klasy bazowe i pochodne
class Figura2D {
protected:
double x,y;
public:
Figura2D(double x0=0.0,double y0=0.0): x(x0),y(y0) { }
void przesun (double dx,double dy) { x+=dx; y+=dy; }
};
class Prostokat: public Figura2D {
protected:
double dl_x,dl_y;
public:
Prostokat(double x,double y,double dx,double dy): Figura2D(x,y),dl_x(dx),dl_y(dy) { }
};
class Kolo: public Figura2D {
protected:
double r;
public:
Kolo(double x,double y,double r0): Figura2D(x,y),r(r0) { }
};
class Pierscien: private Kolo {
protected:
double rw; // promien wewnetrzny
public:
Pierscien(double x,double y,double r,double rw0): Kolo(x,y,r),rw(rw0) { }
};
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Funkcje wirtualne
class Figura2D {
protected:
double x,y;
public:
Figura2D(double x0=0.0,double y0=0.0): x(x0),y(y0) { }
void przesun (double dx,double dy) { x+=dx; y+=dy; }
virtual void skaluj(double wsp=1.0) {}
virtual void wypisz() { cout<<"Poz=("<<x<<’,’<<y<<’)’; }
};
class Kolo: public Figura2D {
protected:
double r;
public:
Kolo(double x,double y,double r0): Figura2D(x,y),r(r0) { }
virtual void skaluj(double wsp=1.0) { r*=wsp; }
virtual void wypisz() { Figura2D::wypisz(); cout<<",promien="<<r; }
};
class Pierscien: private Kolo {
protected:
double rw; // promien wewnetrzny
public:
Pierscien(double x,double y,double r,double rw0): Kolo(x,y,r),rw(rw0) { }
virtual void skaluj(double wsp=1.0) { r*=wsp; rw*=wsp; }
void przesun(double dx,double dy) { Figura2D::przesun(dx,dy); }
virtual void wypisz() { Kolo::wypisz(); cout<<",promien wew.="<<rw; }
};
Marek Piotrów - Wykład 13
Elementy statyczne klasy, dziedziczenie i funkcje wirtualne
Kolejka figur dwuwymiarowych
#include "kolejka.h"
#include "figura2d.h"
int main(void)
{
kolejka<Figura2D &> kol;
Prostokat p(5.0,5.0,10.0,20.0);
Kolo k(10.0,10.0,6.0);
kol.wstaw(p); kol.wstaw(k);
kol.podaj().wypisz(); kol.usun();
kol.podaj().wypisz(); kol.usun();
return 0;
}
Marek Piotrów - Wykład 13