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 3
#include <iostream>

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

int main () {
	// Tworzenie sygnalu cosinusoidalnego
	Sygnal * s1 = new DekoratorPrzesuniecia (new SygnalSinusoidalny(1.0, 20), 5);

	// Tworzenie sygnalu sinusoidalnego polokresowego
	Sygnal * s2 = new DekoratorOgraniczenia (new SygnalSinusoidalny(1.0, 20), 0.0, 5.0);

	// Tworzenie sygnalu trojkatnego z ograniczeniem 
	Sygnal * s3 = new DekoratorOgraniczenia (new SygnalTrojkatny(1.0, 20), 0.5);

	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;

	std::clog << std::endl;

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

	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;
};

class DekoratorPrzesuniecia : public Dekorator {
public:
	DekoratorPrzesuniecia (Sygnal * s, int przesuniecie);
	virtual double symuluj (int t);
private:
	int s_przesuniecie;
};

class DekoratorOgraniczenia : public Dekorator {
public:
	DekoratorOgraniczenia (Sygnal * s, double ograniczenieAbs);
	DekoratorOgraniczenia (Sygnal * s, double ograniczenieMin, double ograniczenieMax);
	virtual double symuluj (int t);
private:
	double s_ograniczenieMin;
	double s_ograniczenieMax;
};

#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;
}

DekoratorPrzesuniecia::DekoratorPrzesuniecia (Sygnal * s, int przesuniecie) 
	: Dekorator(s), s_przesuniecie(przesuniecie)
{
}
	
double DekoratorPrzesuniecia::symuluj (int t) {
	return s_dekorowany->symuluj(t + s_przesuniecie);
}

DekoratorOgraniczenia::DekoratorOgraniczenia (Sygnal * s, double ograniczenieAbs) 
	: Dekorator(s), s_ograniczenieMin(-ograniczenieAbs), s_ograniczenieMax(ograniczenieAbs)
{
}
	
DekoratorOgraniczenia::DekoratorOgraniczenia (Sygnal * s, double ograniczenieMin, double ograniczenieMax) 
	: Dekorator(s), s_ograniczenieMin(ograniczenieMin), s_ograniczenieMax(ograniczenieMax)
{

}
	
double DekoratorOgraniczenia::symuluj (int t) {
	double temp = s_dekorowany->symuluj(t);
	if (temp < s_ograniczenieMin) return s_ograniczenieMin;
	else if (temp > s_ograniczenieMax) return s_ograniczenieMax;
	else return temp;
}
#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;
};

class SygnalTrojkatny : public Sygnal {
public:
	SygnalTrojkatny (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);
}

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

double SygnalTrojkatny::symuluj (int t) {
	unsigned int resztaOkresu = t % s_okres;
	double wspolczynnikWzrostu = (resztaOkresu) ? (s_amp / (s_okres / 2.0)) : 0;
		
	return ((resztaOkresu >= (s_okres / 2.0))) ? 
		2*s_amp - (wspolczynnikWzrostu * resztaOkresu) : wspolczynnikWzrostu * resztaOkresu;
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11