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


Stan

Przykład 2
#include "silnik.h"
#include "stan.h"

#include <iostream>

int main () {
	Stan * stan = new Zatrzymany(0);

	unsigned int i = 0;

	Silnik silnik;
	silnik.ustawRuchPrawoskretny ();

	silnik.zwiekszPredkosc (20);
	for (i = 0; i < 10; ++i) 
		silnik.symuluj ();

	silnik.zmniejszPredkosc (15);
	for (i = 0; i < 5; ++i) 
		silnik.symuluj ();

	silnik.zwiekszPredkosc (30);
	for (i = 0; i < 10; ++i) 
		silnik.symuluj ();

	silnik.zatrzymaj();
	for (i = 0; i < 5; ++i) 
		silnik.symuluj ();

	silnik.ustawRuchLewoskretny();
	silnik.zwiekszPredkosc(10);
	for (i = 0; i < 5; ++i) 
		silnik.symuluj ();

	silnik.ustawRuchPrawoskretny();

	return 0;
}
#ifndef __SILNIK_H__
#define __SILNIK_H__

class Stan;

class Silnik {
public:
	Silnik ();
	~Silnik ();
	int symuluj ();
	void zmniejszPredkosc (unsigned int deltaP);
	void zwiekszPredkosc (unsigned int deltaP);
	void zatrzymaj ();
	void ustawRuchPrawoskretny ();
	void ustawRuchLewoskretny ();
private:
	void zmienStan (Stan * nowyStan);
	
	int s_predkoscBiezaca;
	Stan * s_stan;

	friend class Stan;
};

#endif
#include "silnik.h"
#include "stan.h"

Silnik::Silnik ()
	: s_predkoscBiezaca(0)
{	
	s_stan = new Zatrzymany(this);
}
	
Silnik::~Silnik () {
	delete s_stan;
}

void Silnik::zmniejszPredkosc (unsigned int deltaP) {
	s_stan->zmniejszPredkosc(deltaP);
}
	
void Silnik::zwiekszPredkosc (unsigned int deltaP) {
	s_stan->zwiekszPredkosc(deltaP);
}
	
void Silnik::zatrzymaj () {
	s_stan->zatrzymaj();
}
	
void Silnik::ustawRuchPrawoskretny () {
	s_stan->ustawRuchPrawoskretny();
}
	
void Silnik::ustawRuchLewoskretny () {
	s_stan->ustawRuchLewoskretny();
}

int Silnik::symuluj () {
	s_predkoscBiezaca = s_stan->symuluj(s_predkoscBiezaca);
	return s_predkoscBiezaca;
}

void Silnik::zmienStan (Stan * nowyStan) {
	delete s_stan;
	s_stan = nowyStan;
}
#ifndef __STAN_H__
#define __STAN_H__
#include <string>

#define PREDKOSC_GRANICZNA 10
#define DELTA_PREDKOSC_ROZRUCH 2
#define DELTA_PREDKOSC 4
#define DELTA_PREDKOSC_ZATRZYMYWANIE 8

class Silnik;

class Stan {
protected:
	Stan (Silnik * silnik, const std::string & nazwaStanu, int maxDelta);
public:
	virtual ~Stan ();
	virtual int symuluj (int predkoscBiezaca);
	virtual void zmniejszPredkosc (unsigned int deltaP);
	virtual void zwiekszPredkosc (unsigned int deltaP);
	virtual void zatrzymaj ();
	virtual void ustawRuchPrawoskretny ();
	virtual void ustawRuchLewoskretny ();

	void zmienStan (Stan * nowyStan);
	int predkoscBiezacaSilnika () const;
	int predkoscPrzyrost () const;
protected:
	Silnik * s_silnik;
	int s_predkoscPrzyrost;

	const std::string s_nazwaStanu;
	const int s_maxDelta;
};

class Zatrzymany : public Stan {
public:
	Zatrzymany (Silnik * silnik);
	virtual void ustawRuchPrawoskretny ();
	virtual void ustawRuchLewoskretny ();
};

class Zatrzymywanie : public Stan {
public:
	Zatrzymywanie (Silnik * silnik);
};

class Ruch : public Stan {
protected:
	Ruch (Silnik * silnik, const std::string & nazwaStanu, int maxDelta);
public:
	virtual void zmniejszPredkosc (unsigned int deltaP);
	virtual void zwiekszPredkosc (unsigned int deltaP);
	virtual void zatrzymaj ();
};

class RuchLewoskretnyRozruch : public Ruch {
public:
	RuchLewoskretnyRozruch (Silnik * silnik);
	virtual int symuluj (int predkoscBiezaca);
};

class RuchPrawoskretnyRozruch : public Ruch {
public:
	RuchPrawoskretnyRozruch (Silnik * silnik);
	virtual int symuluj (int predkoscBiezaca);
};

class RuchLewoskretny : public Ruch {
public:
	RuchLewoskretny (Silnik * silnik, int deltaPInit);
};

class RuchPrawoskretny : public Ruch {
public:
	RuchPrawoskretny (Silnik * silnik, int deltaPInit);
};

#endif
#include "stan.h"
#include "silnik.h"
#include <iostream>

Stan::Stan (Silnik * silnik, const std::string & nazwaStanu, int maxDelta) 
	: s_silnik(silnik), s_predkoscPrzyrost(0), s_nazwaStanu(nazwaStanu), s_maxDelta(maxDelta)
{
}
	
Stan::~Stan () {
}
	
int Stan::symuluj (int predkoscBiezaca) {
	int przyrostKrok = 0;
	if (s_predkoscPrzyrost > 0) {
		przyrostKrok = (s_predkoscPrzyrost >= s_maxDelta) ? s_maxDelta : s_predkoscPrzyrost;
		predkoscBiezaca += przyrostKrok;
		s_predkoscPrzyrost -= przyrostKrok;
	} else if (s_predkoscPrzyrost < 0) {
		przyrostKrok = (-s_predkoscPrzyrost >= s_maxDelta) ? -s_maxDelta : s_predkoscPrzyrost;
		predkoscBiezaca += (predkoscBiezaca > -przyrostKrok) ? przyrostKrok : -predkoscBiezaca;
		s_predkoscPrzyrost -= przyrostKrok;
	}

	std::clog << "\tSymulacja silnika w stanie: " << s_nazwaStanu << ", predkosc: " << predkoscBiezaca;

	if (predkoscBiezaca == 0) {
		zmienStan(new Zatrzymany(s_silnik));
		std::clog << " (zatrzymano silnik)";
	}

	std::clog << std::endl;

	return predkoscBiezaca;
}
	
void Stan::zmniejszPredkosc (unsigned int deltaP) {
	std::clog << "BLAD! - operacja zmniejszPredkosc() nie jest obslugiwana w stanie: " << s_nazwaStanu << std::endl;
}
	
void Stan::zwiekszPredkosc (unsigned int deltaP) {
	std::clog << "BLAD! - operacja zwiekszPredkosc() nie jest obslugiwana w stanie: " << s_nazwaStanu << std::endl;
}
	
void Stan::zatrzymaj () {
	std::clog << "BLAD! - operacja zatrzymaj() nie jest obslugiwana w stanie: " << s_nazwaStanu << std::endl;
}
	
void Stan::ustawRuchPrawoskretny () {
	std::clog << "BLAD! - operacja ustawRuchPrawoskretny() nie jest obslugiwana w stanie: " << s_nazwaStanu << std::endl;
}
	
void Stan::ustawRuchLewoskretny () {
	std::clog << "BLAD! - operacja ustawRuchLewoskretny() nie jest obslugiwana w stanie: " << s_nazwaStanu << std::endl;
}

void Stan::zmienStan (Stan * nowyStan) {
	s_silnik->zmienStan(nowyStan);
}

int Stan::predkoscBiezacaSilnika () const {
	return s_silnik->s_predkoscBiezaca;
}

int Stan::predkoscPrzyrost () const {
	return s_predkoscPrzyrost;
}

/************************/

Zatrzymany::Zatrzymany (Silnik * silnik)
	: Stan(silnik, "Silnik zatrzymany", 0)
{
}
	
void Zatrzymany::ustawRuchPrawoskretny () {
	zmienStan(new RuchPrawoskretnyRozruch(s_silnik));
}
	
void Zatrzymany::ustawRuchLewoskretny () {
	zmienStan(new RuchLewoskretnyRozruch(s_silnik));
}

/************************/

Ruch::Ruch (Silnik * silnik, const std::string & nazwaStanu, int maxDelta) 
	: Stan(silnik, nazwaStanu, maxDelta)
{
}

void Ruch::zmniejszPredkosc (unsigned int deltaP) {
	s_predkoscPrzyrost = -static_cast<int>(deltaP);
	int predkoscDocelowa = (predkoscBiezacaSilnika() - deltaP >= 0) ? (predkoscBiezacaSilnika() - deltaP) : 0;
	std::clog << "Zmniejszenie predkosci o: " << deltaP << ", predkosc docelowa: " << predkoscDocelowa << std::endl;
}

void Ruch::zwiekszPredkosc (unsigned int deltaP) {
	s_predkoscPrzyrost = deltaP;
	int predkoscDocelowa = predkoscBiezacaSilnika() + deltaP;
	std::clog << "Zwiekszenie predkosci o: " << deltaP << ", predkosc docelowa: " << predkoscDocelowa << std::endl;
}

void Ruch::zatrzymaj () {
	zmienStan(new Zatrzymywanie(s_silnik));
	std::clog << "Zarzymanie silnika (wymuszone ze stanu ruchu)" << std::endl;
}

/************************/

RuchLewoskretnyRozruch::RuchLewoskretnyRozruch (Silnik * silnik) 
	: Ruch(silnik, "Ruch lewoskretny (rozruch)", DELTA_PREDKOSC_ROZRUCH)
{
}

int RuchLewoskretnyRozruch::symuluj (int predkoscBiezaca) {
	predkoscBiezaca = Stan::symuluj(predkoscBiezaca);
	
	if (predkoscBiezaca >= PREDKOSC_GRANICZNA)
		zmienStan(new RuchLewoskretny(s_silnik, s_predkoscPrzyrost));
	
	return predkoscBiezaca;
}

/************************/

RuchLewoskretny::RuchLewoskretny (Silnik * silnik, int deltaPInit) 
	: Ruch(silnik, "Ruch lewoskretny", DELTA_PREDKOSC)
{
	s_predkoscPrzyrost = deltaPInit;
}

/************************/

RuchPrawoskretnyRozruch::RuchPrawoskretnyRozruch (Silnik * silnik) 
	: Ruch(silnik, "Ruch prawoskretny (rozruch)", DELTA_PREDKOSC_ROZRUCH)
{
}

int RuchPrawoskretnyRozruch::symuluj (int predkoscBiezaca) {
	predkoscBiezaca = Stan::symuluj(predkoscBiezaca);
	
	if (predkoscBiezaca >= PREDKOSC_GRANICZNA)
		zmienStan(new RuchPrawoskretny(s_silnik, s_predkoscPrzyrost));
	
	return predkoscBiezaca;
}

/************************/

RuchPrawoskretny::RuchPrawoskretny (Silnik * silnik, int deltaPInit) 
	: Ruch(silnik, "Ruch prawoskretny", DELTA_PREDKOSC)
{
	s_predkoscPrzyrost = deltaPInit;
}

/************************/

Zatrzymywanie::Zatrzymywanie (Silnik * silnik)
	: Stan(silnik, "Zatrzymywanie silnika", DELTA_PREDKOSC_ZATRZYMYWANIE)
{
	s_predkoscPrzyrost = -predkoscBiezacaSilnika();
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11