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



Prototyp

Przykład 4
#include <iostream>

#include "manager.h"
#include "modul.h"

int main () {
	Manager manager;

	// rejestracja regulatora z dodatkowego modulu
	manager.rejestrujPrototyp ("GPC", new RegulatorGPC(3, 2, 0.5, 0.5, 1, 1));

	Regulator * regP = 0;
	Regulator * regPID = 0;
	Regulator * regGPC = 0;

	try {
		regP = manager.zwrocPrototyp("P");
		regP->symuluj(0.0);

		regPID = manager.zwrocPrototyp("PID");
		regPID->symuluj(0.0);

		regGPC = manager.zwrocPrototyp("GPC");
		regGPC->symuluj(0.0);
	} catch (const std::exception & e) {
		std::clog << e.what() << std::endl;
	}

	delete regP;
	delete regPID;
	delete regGPC;

	return 0;
}
#ifndef __MANAGER_H__
#define __MANAGER_H__
#include "regulator.h"
#include <map>
#include <string>

class Manager {
public:
	Manager ();
	~Manager ();
	bool rejestrujPrototyp (const std::string & id, Regulator * prototyp);
	bool usunPrototyp (const std::string & id);
	Regulator * zwrocPrototyp (const std::string & id) const;
private:
	std::map<std::string, Regulator *> s_mapa;
};

#endif
#include "manager.h"
#include <algorithm>

namespace {
	class DestObiektFun {
	public:
		void operator() (std::pair<std::string, Regulator *> w) {
			delete w.second;
		}
	};
}

Manager::Manager () {
	rejestrujPrototyp ("P", new RegulatorP(1.0));
	rejestrujPrototyp ("PID", new RegulatorPID(1.0, 5.0, 0.5));
}

Manager::~Manager () {
	std::for_each(s_mapa.begin(), s_mapa.end(), DestObiektFun());
}
	
bool Manager::rejestrujPrototyp (const std::string & id, Regulator * prototyp) {
	if (s_mapa.count(id) == 0) {
		s_mapa[id] = prototyp;
		return true;
	} else
		return false;
}
	
bool Manager::usunPrototyp (const std::string & id) {
	if (s_mapa.count(id) != 0) {
		s_mapa.erase(id);
		return true;
	} else
		return false;
}
	
Regulator * Manager::zwrocPrototyp (const std::string & id) const {
	if (s_mapa.count(id) != 0)
		return s_mapa.find(id)->second->klonuj();
	else 
		throw std::exception (std::string("Nie znaleziono prototypu o identyfikatorze ").append(id).c_str());
}
#ifndef __MODUL_H__
#define __MODUL_H__
#include "regulator.h"

class RegulatorGPC : public Regulator {
public:
	RegulatorGPC (unsigned int H, unsigned int L, double alfa, double ro, unsigned int stA, unsigned int stB);
	virtual double symuluj (double wej);
	virtual RegulatorGPC * klonuj () const;
private:
	unsigned int s_H;
	unsigned int s_L;
	double s_alfa;
	double s_ro;
	unsigned int s_stA;
	unsigned int s_stB;
};

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

RegulatorGPC::RegulatorGPC (unsigned int H, unsigned int L, double alfa, double ro, unsigned int stA, unsigned int stB)
	: s_H(H), s_L(L), s_alfa(alfa), s_ro(ro), s_stA(stA), s_stB(stB)
{

}

double RegulatorGPC::symuluj (double wej) {
	std::clog << "Symulacja regulatora GPC" << std::endl;
	return 0;
}
	
RegulatorGPC * RegulatorGPC::klonuj () const {
	return new RegulatorGPC(*this);
}
#ifndef __REGULATOR_H__
#define __REGULATOR_H__

class Regulator {
public:
	virtual double symuluj (double wej) = 0;
	virtual Regulator * klonuj () const = 0;
};

class RegulatorP : public Regulator {
public:
	RegulatorP (double k);
	virtual double symuluj (double wej);
	virtual RegulatorP * klonuj () const;
private:
	double s_k;
};

class RegulatorPID : public Regulator {
public:
	RegulatorPID (double k, double Ti, double Td);
	virtual double symuluj (double wej);
	virtual RegulatorPID * klonuj () const;
private:
	double s_k;
	double s_Ti;
	double s_Td;
};

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

RegulatorP::RegulatorP (double k) 
	: s_k(k)
{

}
	
double RegulatorP::symuluj (double wej) {
	std::clog << "Symulacja regulatora P" << std::endl;
	return 0;
}

RegulatorP * RegulatorP::klonuj () const {
	return new RegulatorP(*this);
}

RegulatorPID::RegulatorPID (double k, double Ti, double Td) 
	: s_k(k), s_Ti(Ti), s_Td(Td)
{

}
	
double RegulatorPID::symuluj (double wej) {
	std::clog << "Symulacja regulatora PID" << std::endl;
	return 0;
}

RegulatorPID * RegulatorPID::klonuj () const {
	return new RegulatorPID(*this);
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11