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



Polecenie

Przykład 4
#include "managermanipulatora.h"
#include "polecenie.h"

#include <iostream>

int main () {
	try {
		ManagerManipulatora manager(new Manipulator(20));
		manager.ustawPolecenie(new ZmienPredkosc(10));
		manager.ustawPolecenie(new PrzesunManipulator(10, 10));
		manager.ustawPolecenie(new PrzesunManipulator(20, -10));
		manager.ustawPolecenie(new ZmienPredkosc(20));
		manager.ustawPolecenie(new PrzesunManipulator(10, 10));

		for (unsigned int i = 0; i < 10; ++i) 
			manager.przesunManipulator();

	} catch (const std::exception & e) {
		std::clog << e.what() << std::endl;
	}

	return 0;
}
#ifndef __MANAGERMANIPULATORA_H__
#define __MANAGERMANIPULATORA_H__
#include "manipulator.h"
#include <list>

class Polecenie;

class ManagerManipulatora {
public:
	ManagerManipulatora (Manipulator * manipulator);
	~ManagerManipulatora ();

	void przesunManipulator ();
	void ustawPolecenie (Polecenie * polecenie);
private:
	Manipulator * s_manipulator;
	std::list<Polecenie *> s_kolejkaPolecen;
};

#endif
#include "managermanipulatora.h"
#include "polecenie.h"
#include <exception>
#include <algorithm>

namespace {
	class ObiektFunUsun {
	public:
		void operator() (Polecenie * polecenie) {
			delete polecenie;
		}
	};
};

ManagerManipulatora::ManagerManipulatora (Manipulator * manipulator)
	: s_manipulator(manipulator)
{
	if (!manipulator)
		throw std::exception("Nie mozna skonfigurowac managera wksaznikiem pustym");
}
	
ManagerManipulatora::~ManagerManipulatora () {
	delete s_manipulator;
	std::for_each(s_kolejkaPolecen.begin(), s_kolejkaPolecen.end(), ObiektFunUsun());
}

void ManagerManipulatora::przesunManipulator () {
	if (s_manipulator->czyPrzesunieto() && !s_kolejkaPolecen.empty()) {
		Polecenie * nowePolecenie = s_kolejkaPolecen.front();
		s_kolejkaPolecen.pop_front();
		nowePolecenie->wykonaj(s_manipulator);
	} 
		
	s_manipulator->przesun();
}
	
void ManagerManipulatora::ustawPolecenie (Polecenie * polecenie) {
	s_kolejkaPolecen.push_back(polecenie);
}
#ifndef __MANIPULATOR_H__
#define __MANIPULATOR_H__

class Manipulator {
public:
	Manipulator (double predkosc);
	
	bool przesun ();
	bool czyPrzesunieto () const;

	void ustawPrzesuniecie (double dx, double dy);
	void ustawPredkosc (double predkosc);
private:
	void sprawdzUstawialnosc() const;

	double s_predkosc;
	double s_x;
	double s_y;
	double s_dx;
	double s_dy;

	static const double EPS;
};

#endif
#include "manipulator.h"
#include <cstdlib>
#include <cmath>
#include <exception>
#include <iostream>

Manipulator::Manipulator (double predkosc) 
	: s_predkosc(predkosc), s_x(0), s_y(0), s_dx(0), s_dy(0)
{
}
	
bool Manipulator::przesun () {
	if (czyPrzesunieto()) {
		return true;
	} else {
		double dxMax = s_dx;
		double dyMax = s_dy;
		double dxdyMax = std::sqrt (dxMax*dxMax + dyMax*dyMax);
		double dxdy = (dxdyMax > s_predkosc) ? s_predkosc : dxdyMax;
	
		double dx = (dxdy / dxdyMax) * dxMax;
		double dy = (dxdy / dxdyMax) * dyMax;

		s_dx -= dx;
		s_dy -= dy;
		s_x += dx;
		s_y += dy;

		std::clog << "Przesuniecie manipulatora na wspolrzedne (" << s_x << ", " << s_y << ")" << std::endl;
	}

	return czyPrzesunieto();
}
	
bool Manipulator::czyPrzesunieto () const {
	return ((std::fabs(s_dx) < EPS) && (std::fabs(s_dy) < EPS));
}

void Manipulator::ustawPrzesuniecie (double dx, double dy) {
	sprawdzUstawialnosc();

	s_dx = dx;
	s_dy = dy;
}
	
void Manipulator::ustawPredkosc (double predkosc) {
	sprawdzUstawialnosc();

	s_predkosc = (predkosc) ? predkosc : 0;
}

void Manipulator::sprawdzUstawialnosc() const {
	if (!czyPrzesunieto())
		throw std::exception ("Blad ustawienia - Manipulator nie wykonal poprzedniego zadania");
}

const double Manipulator::EPS = 1e-3;
#ifndef __POLECENIE_H__
#define __POLECENIE_H__
#include "manipulator.h"

class Polecenie {
public:
	virtual ~Polecenie ();
	virtual void wykonaj (Manipulator * manipulator) = 0;
};

class PrzesunManipulator : public Polecenie {
public:
	PrzesunManipulator (double dx, double dy);
	virtual void wykonaj (Manipulator * manipulator);
private:
	double s_dx;
	double s_dy;
};

class ZmienPredkosc : public Polecenie {
public:
	ZmienPredkosc (double predkosc);
	virtual void wykonaj (Manipulator * manipulator);
private:
	double s_predkosc;
};

#endif
#include "polecenie.h"

Polecenie::~Polecenie () {
}

PrzesunManipulator::PrzesunManipulator (double dx, double dy) 
	: s_dx(dx), s_dy(dy)
{
}
	
void PrzesunManipulator::wykonaj (Manipulator * manipulator) {
	manipulator->ustawPrzesuniecie (s_dx, s_dy);
}

ZmienPredkosc::ZmienPredkosc (double predkosc) 
	: s_predkosc(predkosc)
{
}
	
void ZmienPredkosc::wykonaj (Manipulator * manipulator) {
	manipulator->ustawPredkosc (s_predkosc);
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11