Pakiet programów do zdalnego nauczania Programowania Orientowanego Obiektowo
Dzisiaj jest
Sobota, 21 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


Obserwator

Przykład 2
#include "proces.h"
#include "alarm.h"

#include <iostream>

int main () {
	Alarm * alarm = new Alarm (10);
	Proces * proces = new Proces (4, 0.1, 20, 0.1);
	proces->rejestrujObserwatora(alarm);

	for (unsigned int i = 0; i < 5; ++i)
		proces->symuluj(5);
	
	for (unsigned int i = 0; i < 10; ++i)
		proces->symuluj(15);

	delete proces;
	delete alarm;

	return 0;
}
#ifndef __ALARM_H__
#define __ALARM_H__
#include "obserwator.h"

class Alarm : public Obserwator {
public:
	Alarm (double wartGraniczna);
	virtual void aktualizuj (double wartosc);
	void sprawdz (double wartosc) const;
private:
	double s_wartGraniczna;
};

#endif
#include "alarm.h"
#include <cstdlib>
#include <iostream>

Alarm::Alarm (double wartGraniczna)
	: s_wartGraniczna(wartGraniczna)
{
}

void Alarm::aktualizuj (double wartosc) {
	sprawdz (wartosc);
}

void Alarm::sprawdz (double wartosc) const {
	if (std::abs(wartosc) > std::abs(s_wartGraniczna))
		std::clog << " ALARM! - przekroczono wartosc graniczna |" << s_wartGraniczna << "|" << std::endl;
}
#ifndef __OBSERWATOR_H__
#define __OBSERWATOR_H__

class Obserwator {
public:
	virtual ~Obserwator () {}
	virtual void aktualizuj (double wartosc) = 0;
};

#endif
#ifndef __OBSERWOWANY_H__
#define __OBSERWOWANY_H__
#include <list>

class Obserwator;

class Obserwowany {
public:
	virtual ~Obserwowany ();
	bool rejestrujObserwatora (Obserwator * obserwator);
	bool wyrejestrujObserwator (Obserwator * obserwator);
	void powiadom (double wartosc) const;
private:
	std::list<Obserwator * > s_obserwatorzy;
};

#endif
#include "obserwowany.h"
#include "obserwator.h"
#include <algorithm>

Obserwowany::~Obserwowany () {
}
	
bool Obserwowany::rejestrujObserwatora (Obserwator * obserwator) {
	if (std::find(s_obserwatorzy.begin(), s_obserwatorzy.end(), obserwator) == s_obserwatorzy.end()) {
		s_obserwatorzy.push_back(obserwator);
		return true;
	} else 
		return false;
}
	
bool Obserwowany::wyrejestrujObserwator (Obserwator * obserwator) {
	std::list<Obserwator *>::iterator it;
	it = std::find(s_obserwatorzy.begin(), s_obserwatorzy.end(), obserwator);
	if (it != s_obserwatorzy.end()) {
		s_obserwatorzy.erase(it);
		return true;
	} else
		return false;
}
	
void Obserwowany::powiadom (double wartosc) const {
	std::list<Obserwator *>::const_iterator it = s_obserwatorzy.begin();
	for (; it != s_obserwatorzy.end(); ++it) {
		(*it)->aktualizuj(wartosc);
	}
}
#ifndef __PROCES_H__
#define __PROCES_H__
#include "proces.h"
#include "obserwowany.h"

class Proces : public Obserwowany {
public:
	Proces (double zmianaJedn, double sinAmp, int sinOkres, double maxLos);
	double symuluj (double wej);
private:
	double s_zmianaJedn;
	double s_sinAmp;
	int s_sinOkres;
	double s_maxLos;
	
	double s_skladnikLiniowy;
	int s_t;
};

#endif
#include "proces.h"
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <iostream>

Proces::Proces (double zmianaJedn, double sinAmp, int sinOkres, double maxLos) 
	: s_zmianaJedn(zmianaJedn), s_sinAmp(sinAmp), s_sinOkres(sinOkres), s_maxLos(maxLos), s_skladnikLiniowy(0), s_t(0)
{
	std::srand(static_cast<unsigned int> (std::time(0)));
}

double Proces::symuluj (double wej) {
	if (s_skladnikLiniowy < wej)
		s_skladnikLiniowy = (s_skladnikLiniowy + s_zmianaJedn > wej) ? wej : (s_skladnikLiniowy + s_zmianaJedn);
	else if (s_skladnikLiniowy > wej) 
		s_skladnikLiniowy = (s_skladnikLiniowy - s_zmianaJedn < wej) ? wej : (s_skladnikLiniowy - s_zmianaJedn);

	double skladnikSinusoidalny = s_sinAmp*std::sin((static_cast<double>(s_t % s_sinOkres) / s_sinOkres) * 6.28);
	double skladnikLosowy = (((std::rand() % 1000) / 500.0) - 1.0) * s_maxLos;
	double wyj = s_skladnikLiniowy + skladnikSinusoidalny + skladnikLosowy;

	std::clog << "Symulujacja procesu, wej: " << wej << ", wyj: " << wyj << std::endl;
	
	powiadom (wyj);

	++s_t;
	return wyj;
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11