Document Outline

Kurs C z elementami C++

Marek Piotrów - Wykład 13

22 stycznia 2008

Uwaga: w załacznikach do tego pliku znajduj ˛

a si ˛e 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˛e

#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();

}

cout<<"=============="<<endl;

return 0;

}

Marek Piotrów - Wykład 13

Elementy statyczne klasy, dziedziczenie i funkcje wirtualne

Elementy statyczne

Dziedziczenie
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

Elementy statyczne

Dziedziczenie

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

Elementy statyczne
Dziedziczenie

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

Elementy statyczne
Dziedziczenie

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();

return 0;

}

Marek Piotrów - Wykład 13