Pakiet programów do zdalnego nauczania Programowania Orientowanego Obiektowo
Dzisiaj jest
Poniedziałek, 16 Lipiec 2018
Zarejestrowanych użytkowników: 4
Dostępnych pytań testowych: 102
HOME
Strona tytułowa pracy dyplomowej
NAUKA
Materiały dydaktyczne związane z OOP
TESTY
Sprawdzenie poziomu zdobytej wiedzy
ZASOBY
Literatura i zasoby sieciowe o OOP
ŹRÓDŁA
Zbiór projektów dydaktycznych z OOP
KONTO
Możliwość śledzenia własnych postępów
INFO



Dekorator

Przykład 2
#include <iostream>

#include "sygnal.h"
#include "dekorator.h"

int main () {
	// Tworzenie sygnalu prostokatnego bez ograniczenia
	Sygnal * s1 = new FalaProstokatna (1, 10, 0.5);

	// Tworzenie sygnalu sinusoidalnego z ograniczeniem na czas koncowy aktywnosci
	Sygnal * s2 = new SygnalSinusoidalny (1, 20);
	s2 = new DekoratorStartu(s2, 10);

	for (unsigned int t = 0; t < 20; ++t)
		std::clog << t << " " << s1->symuluj(t) << std::endl;

	std::clog << std::endl;

	for (unsigned int t = 0; t < 20; ++t)
		std::clog << t << " " << s2->symuluj(t) << std::endl;

	delete s1;
	delete s2;

	return 0;
}
#ifndef __DEKORATOR_H__
#define __DEKORATOR_H__
#include "sygnal.h"

class Dekorator : public Sygnal {
public:
	Dekorator (Sygnal * s);
	virtual ~Dekorator ();
	virtual double symuluj (int t) = 0;
protected:
	Sygnal * s_dekorowany;
};

class DekoratorStartu : public Dekorator {
public:
	DekoratorStartu (Sygnal * s, int start);
	virtual double symuluj (int t);
private:
	int s_start;
};

class DekoratorKonca : public Dekorator {
public:
	DekoratorKonca (Sygnal * s, int koniec);
	virtual double symuluj (int t);
private:
	int s_koniec;
};

#endif
#include "dekorator.h"

Dekorator::Dekorator (Sygnal * s) 
	: s_dekorowany(s)
{
}
	
Dekorator::~Dekorator () {
	delete s_dekorowany;
}

DekoratorStartu::DekoratorStartu (Sygnal * s, int start) 
	: Dekorator(s), s_start(start)
{
}

double DekoratorStartu::symuluj (int t) {
	return (t >= s_start) ? s_dekorowany->symuluj(t) : 0;
}

DekoratorKonca::DekoratorKonca (Sygnal * s, int koniec)
	: Dekorator(s), s_koniec(koniec)
{
}

double DekoratorKonca::symuluj (int t) {
	return (t <= s_koniec) ? s_dekorowany->symuluj(t) : 0;
}
#ifndef __SYGNAL_H__
#define __SYGNAL_H__

class Sygnal {
public:
	Sygnal ();
	virtual double symuluj (int t) = 0;
};

class FalaProstokatna : public Sygnal {
public:
	FalaProstokatna (double amp, int okres, double wypelnienie);
	virtual double symuluj (int t);
private:
	double s_amp;
	int s_okres;
	double s_wypelnienie;
};

class SygnalSinusoidalny : public Sygnal {
public:
	SygnalSinusoidalny (double amp, int okres);
	virtual double symuluj (int t);
private:
	double s_amp;
	int s_okres;
};

#endif
#include "sygnal.h"
#include <cmath>

Sygnal::Sygnal () 
{
}

FalaProstokatna::FalaProstokatna (double amp, int okres, double wypelnienie) 
	: s_amp(amp), s_okres(okres), s_wypelnienie(wypelnienie) 
{
}

double FalaProstokatna::symuluj (int t) {
	return ((t % s_okres) < (s_wypelnienie * s_okres)) ? s_amp : 0;
}

SygnalSinusoidalny::SygnalSinusoidalny (double amp, int okres) 
	: s_amp(amp), s_okres(okres)
{
}

double SygnalSinusoidalny::symuluj (int t) {
	return s_amp*std::sin((static_cast<double>(t % s_okres) / s_okres) * 6.28);
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11