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



Stan

Przykład 1
#include <iostream>

#include "silnik.h"

int main () {
	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 Silnik {
public:
	Silnik ();
	int symuluj ();
	void zmniejszPredkosc (unsigned int deltaP);
	void zwiekszPredkosc (unsigned int deltaP);
	void zatrzymaj ();
	void ustawRuchPrawoskretny ();
	void ustawRuchLewoskretny ();
private:
	void symulujZmienPredkosc (int maxDelta);

	enum StanSilnika { ZATRZYMANY, RUCH_LEWOSKRETNY_ROZRUCH, RUCH_LEWOSKRETNY, RUCH_PRAWOSKRETNY_ROZRUCH, RUCH_PRAWOSKRETNY, ZATRZYMYWANIE };

	StanSilnika s_stan;
	int s_predkoscBiezaca;
	int s_predkoscPrzyrost;

	static const int PREDKOSC_GRANICZNA = 10;
	static const int DELTA_PREDKOSC_ROZRUCH = 2;
	static const int DELTA_PREDKOSC = 4;
	static const int DELTA_PREDKOSC_ZATRZYMYWANIE = 8;
};

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

Silnik::Silnik ()
	: s_stan(ZATRZYMANY), s_predkoscBiezaca(0), s_predkoscPrzyrost(0)
{
}

int Silnik::symuluj () {
	switch (s_stan) {
	case ZATRZYMANY:
		std::clog << "\tSilnik zatrzymany";
		break;
	case RUCH_LEWOSKRETNY_ROZRUCH:
		symulujZmienPredkosc (DELTA_PREDKOSC_ROZRUCH);
		if (s_predkoscBiezaca >= PREDKOSC_GRANICZNA) s_stan = RUCH_LEWOSKRETNY;
		std::clog << "\tRuch lewoskretny (rozruch)";
		break;
	case RUCH_LEWOSKRETNY:
		symulujZmienPredkosc (DELTA_PREDKOSC);
		std::clog << "\tRuch lewoskretny";
		break;
	case RUCH_PRAWOSKRETNY_ROZRUCH:
		symulujZmienPredkosc (DELTA_PREDKOSC_ROZRUCH);
		if (s_predkoscBiezaca >= PREDKOSC_GRANICZNA) s_stan = RUCH_PRAWOSKRETNY;
		std::clog << "\tRuch prawoskretny (rozruch)";
		break;
	case RUCH_PRAWOSKRETNY:
		symulujZmienPredkosc (DELTA_PREDKOSC);
		std::clog << "\tRuch prawoskretny";
		break;
	case ZATRZYMYWANIE:
		symulujZmienPredkosc (DELTA_PREDKOSC_ZATRZYMYWANIE);
		std::clog << "\tZatrzymywanie silnika";
		break;
	}

	if (s_predkoscBiezaca == 0) {
		s_stan = ZATRZYMANY;
		std::clog << " (SILNIK ZATRZYMAL SIE)";
	}

	std::clog << ", predkosc:" << s_predkoscBiezaca << std::endl;
	return s_predkoscBiezaca;
}

void Silnik::symulujZmienPredkosc (int maxDelta) {
	int przyrostKrok = 0;
	if (s_predkoscPrzyrost > 0) {
		przyrostKrok = (s_predkoscPrzyrost >= maxDelta) ? maxDelta : s_predkoscPrzyrost;
		s_predkoscBiezaca += przyrostKrok;
		s_predkoscPrzyrost -= przyrostKrok;
	} else if (s_predkoscPrzyrost < 0) {
		przyrostKrok = (-s_predkoscPrzyrost >= maxDelta) ? -maxDelta : s_predkoscPrzyrost;
		s_predkoscBiezaca += (s_predkoscBiezaca > -przyrostKrok) ? przyrostKrok : -s_predkoscBiezaca;
		s_predkoscPrzyrost -= przyrostKrok;
	}
}

void Silnik::zmniejszPredkosc (unsigned int deltaP) {
	if (s_stan == ZATRZYMANY || s_stan == ZATRZYMYWANIE) {
		std::clog << "BLAD! Nie mozna zmienic predkosci w stanie zatzymania lub zatrzymywania silnika" << std::endl;
	} else {
		s_predkoscPrzyrost = -static_cast<int>(deltaP);
		int predkoscDocelowa = (s_predkoscBiezaca - deltaP >= 0) ? (s_predkoscBiezaca - deltaP) : 0;
		std::clog << "Zmniejszenie predkosci o: " << deltaP << ", predkosc docelowa : " << predkoscDocelowa << std::endl;
	}
}
	
void Silnik::zwiekszPredkosc (unsigned int deltaP) {
	if (s_stan == ZATRZYMANY || s_stan == ZATRZYMYWANIE) {
		std::clog << "BLAD! Nie mozna zmienic predkosci w stanie zatzymania lub zatrzymywania silnika" << std::endl;
	} else {
		s_predkoscPrzyrost = deltaP;
		std::clog << "Zwiekszenie predkosci o: " << deltaP << ", predkosc docelowa : " << (s_predkoscBiezaca + s_predkoscPrzyrost) << std::endl;
	}
}
	
void Silnik::zatrzymaj () {
	if (s_stan == ZATRZYMANY || s_stan == ZATRZYMYWANIE) {
		std::clog << "BLAD! Silnik juz znajduje sie w stanie zatrzymania lub zatrzymywania" << std::endl;
	} else {
		s_predkoscPrzyrost = -s_predkoscBiezaca;
		s_stan = ZATRZYMYWANIE;
		std::clog << "Zatrzymywanie silnika przy predkosci: " << s_predkoscBiezaca << std::endl;
	}
}
	
void Silnik::ustawRuchPrawoskretny () {
	if (s_stan != ZATRZYMANY) {
		std::clog << "BLAD! Ustawienie ruchu prawoskretnego moze nastapic tylko przy calkowitym zatrzymaniu silnika" << std::endl;
	} else {
		s_stan = RUCH_PRAWOSKRETNY_ROZRUCH;
	}
}
	
void Silnik::ustawRuchLewoskretny () {
	if (s_stan != ZATRZYMANY) {
		std::clog << "BLAD! Ustawienie ruchu lewoskretnego moze nastapic tylko przy calkowitym zatrzymaniu silnika" << std::endl;
	} else {
		s_stan = RUCH_LEWOSKRETNY_ROZRUCH;
	}
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11