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


Fabryka abstrakcyjna

Przykład 3
#include "fabryka.h"

#include <iostream>

int main () {
	FabrykaObiektow * fabryka = new FabrykaTustina();
	ObiektDyskretny * obiekt = fabryka->utworzObiektNieminimalnofazowy(1.0, 1.0, 2.0, 6.0, 4.0);

	std::clog << obiekt->naString();
	try {
		obiekt->zmienParametr("T3", 5.0);

		// Powtorne wypisanie wlasnosci obiektu
		std::clog << std::endl << obiekt->naString();
	} catch (const std::exception & e) {
		std::clog << "Wyjatek : " << e.what() << std::endl;
	}

	delete fabryka;
	delete obiekt;

	return 0;
}
#ifndef __FABRYKA_H__
#define __FABRYKA_H__
#include "obiekt.h"

class FabrykaObiektow {
public:
	virtual Inercja1Rzedu * utworzInercje1rzedu (double Tp, double k, double T1) const = 0;
	virtual Inercja2Rzedu * utworzInercje2rzedu (double Tp, double k, double T1, double T2) const = 0;
	virtual ObiektNieminimalnofazowy * utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const = 0;
protected:
	Inercja1Rzedu * utworzInercje1rzeduAB (const std::string & A, const std::string & B, double Tp, double k, double T1) const;
	Inercja2Rzedu * utworzInercje2rzeduAB (const std::string & A, const std::string & B, double Tp, double k, double T1, double T2) const;
	ObiektNieminimalnofazowy * utworzObiektNieminimalnofazowyAB (const std::string & A, const std::string & B, double Tp, double k, double T1, double T2, double T3) const;
};

class FabrykaEurelPrzod : public FabrykaObiektow {
public:
	virtual Inercja1Rzedu * utworzInercje1rzedu (double Tp, double k, double T1) const;
	virtual Inercja2Rzedu * utworzInercje2rzedu (double Tp, double k, double T1, double T2) const;
	virtual ObiektNieminimalnofazowy * utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const;
};

class FabrykaEurerTyl : public FabrykaObiektow {
public:
	virtual Inercja1Rzedu * utworzInercje1rzedu (double Tp, double k, double T1) const;
	virtual Inercja2Rzedu * utworzInercje2rzedu (double Tp, double k, double T1, double T2) const;
	virtual ObiektNieminimalnofazowy * utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const;
};

class FabrykaTustina : public FabrykaObiektow {
public:
	virtual Inercja1Rzedu * utworzInercje1rzedu (double Tp, double k, double T1) const;
	virtual Inercja2Rzedu * utworzInercje2rzedu (double Tp, double k, double T1, double T2) const;
	virtual ObiektNieminimalnofazowy * utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const;
};

#endif
#include "fabryka.h"

Inercja1Rzedu * FabrykaObiektow::utworzInercje1rzeduAB (const std::string & A, const std::string & B, double Tp, double k, double T1) const {
	return new Inercja1Rzedu (A, B, Tp, k, T1, this);
}
	
Inercja2Rzedu * FabrykaObiektow::utworzInercje2rzeduAB (const std::string & A, const std::string & B, double Tp, double k, double T1, double T2) const {
	return new Inercja2Rzedu (A, B, Tp, k, T1, T2, this);
}

ObiektNieminimalnofazowy * FabrykaObiektow::utworzObiektNieminimalnofazowyAB (const std::string & A, const std::string & B, double Tp, double k, double T1, double T2, double T3) const {
	return new ObiektNieminimalnofazowy (A, B, Tp, k, T1, T2, T3, this);
}

Inercja1Rzedu * FabrykaEurelPrzod::utworzInercje1rzedu (double Tp, double k, double T1) const {
	std::string A = "z(T1)+(Tp-T1)";
	std::string B = "kTp";
	return utworzInercje1rzeduAB (A, B, Tp, k, T1);
}
	
Inercja2Rzedu * FabrykaEurelPrzod::utworzInercje2rzedu (double Tp, double k, double T1, double T2) const {
	std::string A = "z^2(T1T2)+z((T1+T2)Tp-2T1T2)+(T1T2-Tp(T1+T2)+(Tp^2))";
	std::string B = "k(Tp^2)";
	return utworzInercje2rzeduAB (A, B, Tp, k, T1, T2);
}

ObiektNieminimalnofazowy * FabrykaEurelPrzod::utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const {
	std::string A = "z^2(T1T2)+z((T1+T2)Tp-2T1T2)+(T1T2-Tp(T1+T2)+(Tp^2))";
	std::string B = "z(-TpT3k)+kTp(T3+Tp)";
	return utworzObiektNieminimalnofazowyAB (A, B, Tp, k, T1, T2, T3);
}

Inercja1Rzedu * FabrykaEurerTyl::utworzInercje1rzedu (double Tp, double k, double T1) const {
	std::string A = "z(T1+Tp)-T1";
	std::string B = "z(kTp)";
	return utworzInercje1rzeduAB (A, B, Tp, k, T1);
}

Inercja2Rzedu * FabrykaEurerTyl::utworzInercje2rzedu (double Tp, double k, double T1, double T2) const {
	std::string A = "z^2(T1T2+Tp(T1+T2)+(Tp^2))+z(-2T1T2-Tp(T1+T2))+(T1T2)";
	std::string B = "z^2(k(Tp^2))";
	return utworzInercje2rzeduAB (A, B, Tp, k, T1, T2);
}

ObiektNieminimalnofazowy * FabrykaEurerTyl::utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const {
	std::string A = "z^2(T1T2+Tp(T1+T2)+(Tp^2))+z(-2T1T2-Tp(T1+T2))+(T1T2)";
	std::string B = "z^2((Tp^2)k-T3Tp)+z(TpT3)";
	return utworzObiektNieminimalnofazowyAB (A, B, Tp, k, T1, T2, T3);
}

Inercja1Rzedu * FabrykaTustina::utworzInercje1rzedu (double Tp, double k, double T1) const {
	std::string A = "z(Tp+2T1)+(Tp-2T1)";
	std::string B = "z(kTp)+(kTp)";
	return utworzInercje1rzeduAB (A, B, Tp, k, T1);
}

Inercja2Rzedu * FabrykaTustina::utworzInercje2rzedu (double Tp, double k, double T1, double T2) const {
	std::string A = "z^2(4T1T2+2Tp(T1+T2)+(Tp^2))+z(-8T1T2+2(Tp^2))+(4T1T2-2Tp(T1+T2)+(Tp^2))";
	std::string B = "z^2(k(Tp^2))+z(2k(Tp^2))+(k(Tp^2))";
	return utworzInercje2rzeduAB (A, B, Tp, k, T1, T2);
}

ObiektNieminimalnofazowy * FabrykaTustina::utworzObiektNieminimalnofazowy (double Tp, double k, double T1, double T2, double T3) const {
	std::string A = "z^2(4T1T2+2Tp(T1+T2)+(Tp^2))+z(-8T1T2+2(Tp^2))+(4T1T2-2Tp(T1+T2)+(Tp^2))";
	std::string B = "z^2(-2kT3Tp+k(Tp^2))+z(2k(Tp^2))+(2kTpT3+k(Tp^2))";
	return utworzObiektNieminimalnofazowyAB (A, B, Tp, k, T1, T2, T3);
}
#include "obiekt.h"
#include "fabryka.h"
#include <exception>
#include <sstream>

ObiektDyskretny::ObiektDyskretny (const std::string & A, const std::string & B, double Tp, double k, const FabrykaObiektow * const fabryka) 
	: s_A(A), s_B(B), s_Tp(Tp), s_k(k), fabryka_(fabryka)
{
}
	
double ObiektDyskretny::zwrocParametr (const std::string & parametr) const {
	if (parametr == "Tp") return s_Tp;
	else if (parametr == "k") return s_k;
	else 
		throw std::exception(std::string("Podany parametr (" + parametr + ") nie jest znany").c_str());
}

void ObiektDyskretny::zmienParametr (const std::string & parametr, double wartosc) {
	if (parametr == "Tp") s_Tp = wartosc;
	else if (parametr == "k") s_k = wartosc;
	else
		throw std::exception(std::string("Podany parametr (" + parametr + ") nie jest znany").c_str());
}

Inercja1Rzedu::Inercja1Rzedu (const std::string & A, const std::string & B, double Tp, double k, double T1, const FabrykaObiektow * const fabryka) 
	: ObiektDyskretny(A, B, Tp, k, fabryka), s_T1(T1)
{
}

std::string Inercja1Rzedu::naString () const {
	std::stringstream temp;
	temp << "Inercja 1-go rzedu: " << std::endl
		<< " A: " << s_A << std::endl
		<< " B: " << s_B << std::endl
		<< " Tp : " << s_Tp << std::endl
		<< " T1 : " << s_T1 << std::endl;
	return temp.str();
}
	
double Inercja1Rzedu::zwrocParametr (const std::string & parametr) const {
	if (parametr == "T1") 
		return s_T1;
	else 
		return ObiektDyskretny::zwrocParametr(parametr);
}

void Inercja1Rzedu::zmienParametr (const std::string & parametr, double wartosc) {
	if (parametr == "T1") s_T1 = wartosc;
	else
		ObiektDyskretny::zmienParametr(parametr, wartosc);

	Inercja1Rzedu * temp = fabryka_->utworzInercje1rzedu(s_Tp, s_k, s_T1);
	s_A = temp->s_A;
	s_B = temp->s_B;
}

Inercja2Rzedu::Inercja2Rzedu (const std::string & A, const std::string & B, double Tp, double k, double T1, double T2, const FabrykaObiektow * const fabryka) 
	: ObiektDyskretny (A, B, Tp, k, fabryka), s_T1(T1), s_T2(T2)
{
}

std::string Inercja2Rzedu::naString () const {
	std::stringstream temp;
	temp << "Inercja 2-go rzedu: " << std::endl
		<< " A: " << s_A << std::endl
		<< " B: " << s_B << std::endl
		<< " Tp : " << s_Tp << std::endl
		<< " T1 : " << s_T1 << std::endl
		<< " T2 : " << s_T2 << std::endl;
	return temp.str();
}
	
double Inercja2Rzedu::zwrocParametr (const std::string & parametr) const {
	if (parametr == "T1") return s_T1;
	else if (parametr == "T2") return s_T2;
	else
		return ObiektDyskretny::zwrocParametr(parametr);
}

void Inercja2Rzedu::zmienParametr (const std::string & parametr, double wartosc) {
	if (parametr == "T1") s_T1 = wartosc;
	else if (parametr == "T2") s_T2 = wartosc;
	else
		ObiektDyskretny::zmienParametr(parametr, wartosc);

	Inercja2Rzedu * temp = fabryka_->utworzInercje2rzedu(s_Tp, s_k, s_T1, s_T2);
	s_A = temp->s_A;
	s_B = temp->s_B;
}

ObiektNieminimalnofazowy::ObiektNieminimalnofazowy (const std::string & A, const std::string & B, double Tp, double k, double T1, double T2, double T3, const FabrykaObiektow * const fabryka) 
	: ObiektDyskretny (A, B, Tp, k, fabryka), s_T1(T1), s_T2(T2), s_T3(T3)
{
}

std::string ObiektNieminimalnofazowy::naString () const {
	std::stringstream temp;
	temp << "Obiekt nieminimalnofazowy: " << std::endl
		<< " A: " << s_A << std::endl
		<< " B: " << s_B << std::endl
		<< " Tp : " << s_Tp << std::endl
		<< " T1 : " << s_T1 << std::endl
		<< " T2 : " << s_T2 << std::endl
		<< " T3 : " << s_T3 << std::endl;
	return temp.str();
}
	
double ObiektNieminimalnofazowy::zwrocParametr (const std::string & parametr) const {
	if (parametr == "T1") return s_T1;
	else if (parametr == "T2") return s_T2;
	else if (parametr == "T3") return s_T3;
	else
		return ObiektDyskretny::zwrocParametr(parametr);
}

void ObiektNieminimalnofazowy::zmienParametr (const std::string & parametr, double wartosc) {
	if (parametr == "T1") s_T1 = wartosc;
	else if (parametr == "T2") s_T2 = wartosc;
	else if (parametr == "T3") s_T3 = wartosc;
	else
		ObiektDyskretny::zmienParametr(parametr, wartosc);

	ObiektNieminimalnofazowy * temp = fabryka_->utworzObiektNieminimalnofazowy(s_Tp, s_k, s_T1, s_T2, s_T3);
	s_A = temp->s_A;
	s_B = temp->s_B;
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11