Pakiet programów do zdalnego nauczania Programowania Orientowanego Obiektowo
Dzisiaj jest
Wtorek, 17 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 5
#include "fabryka.h"

#include <iostream>

int main () {
	ManagerFabryki manager;
	
	Fabryka * fabryka;

	fabryka = new Fabryka();
	fabryka->dodajElement("Procesor", new ProcesorIntel("Core i5", 2400));
	fabryka->dodajElement("Karta", new KartaGraficznaNVidia("GFX260", 2048, true));
	fabryka->dodajElement("Naped", new	NapedBluRay("BH10LS30Box", 8));		
	manager.dodajFabryke("Zestaw 1", fabryka);

	fabryka = new Fabryka();
	fabryka->dodajElement("Procesor", new ProcesorAMD("Phenom II X4", 2000));
	fabryka->dodajElement("Karta", new KartaGraficznaNVidia("GF9800", 512, false));
	fabryka->dodajElement("Naped", new NapedDVD("iHAS624", 8));		
	manager.dodajFabryke("Zestaw 2", fabryka);

	fabryka = new Fabryka();
	fabryka->dodajElement("Procesor", new ProcesorIntel("Core2Quad Q9650", 3000));
	fabryka->dodajElement("Karta", new KartaGraficznaATI("HD5870", 512));
	fabryka->dodajElement("Naped", new NapedDVD("SE-084F", 48));		
	fabryka->dodajElement("Naped 2", new NapedBluRay("BH10LS30Box", 8));		
	manager.dodajFabryke("Zestaw 3", fabryka);

	try {
		std::string zestaw = "Zestaw 3";
		Element * procesor = manager.zwrocFabryke(zestaw)->podajElement("Procesor");
		Element * karta = manager.zwrocFabryke(zestaw)->podajElement("Karta");
		Element * naped = manager.zwrocFabryke(zestaw)->podajElement("Naped");

		std::clog << procesor->opis() << std::endl;
		std::clog << karta->opis() << std::endl;
		std::clog << naped->opis() << std::endl;

		delete procesor;
		delete karta;
		delete naped;
	} catch (const std::exception & e) {
		std::clog << "Wyjatek : " << e.what();
	}

	return 0;
}
#ifndef __ELEMENT_H__
#define __ELEMENT_H__
#include <string> 

class Element {
public:
	Element (const std::string & id) : s_id(id) {}
	virtual ~Element () {}
	virtual std::string opis () const = 0;
	virtual Element * klonuj () const = 0;
protected:
	std::string s_id;
};

#endif
#ifndef __FABRYKA_H__
#define __FABRYKA_H__
#include "procesor.h"
#include "kartagraficzna.h"
#include "naped.h"
#include <map>

class Fabryka {
public:
	Fabryka ();
	~Fabryka ();
	bool dodajElement (const std::string & id, Element * element);
	Element * podajElement (const std::string & id) const;
	bool czyIstnieje (const std::string & id) const;
private:
	std::map<std::string, Element *> s_elementy;
};

class ManagerFabryki {
public:
	ManagerFabryki ();
	~ManagerFabryki ();
	bool dodajFabryke (const std::string & id, Fabryka * fabryka);
	Fabryka * zwrocFabryke (const std::string & id) const;
	bool czyIstnieje (const std::string & id) const;
private:
	std::map<std::string, Fabryka *> s_mapa;
};

#endif
#include "fabryka.h"
#include <exception>
#include <algorithm>

namespace {
	template<class T>
	class ObiektFunUsun {
	public:
		void operator() (const std::pair<std::string, T> el) {
			delete el.second;
		}
	};
}

Fabryka::Fabryka () {
}

Fabryka::~Fabryka () {
	std::for_each(s_elementy.begin(), s_elementy.end(), ObiektFunUsun<Element *>());
}
	
bool Fabryka::dodajElement (const std::string & id, Element * element) {
	if (czyIstnieje(id)) return false;
	else {
		s_elementy[id] = element;
		return true;
	}
}
	
Element * Fabryka::podajElement (const std::string & id) const {
	if (czyIstnieje(id)) return (s_elementy.find(id)->second)->klonuj();
	else 
		throw std::exception("Nie ma elementu o wskazanym identyfikatorze");
}

bool Fabryka::czyIstnieje (const std::string & id) const {
	return (s_elementy.count(id) != 0) ? true : false;
}

ManagerFabryki::ManagerFabryki () {
}

ManagerFabryki::~ManagerFabryki () {
	std::for_each(s_mapa.begin(), s_mapa.end(), ObiektFunUsun<Fabryka *>());
}
	
bool ManagerFabryki::dodajFabryke (const std::string & id, Fabryka * fabryka) {
	if (czyIstnieje(id))
		return false;
	else {
		s_mapa[id] = fabryka;
		return true;
	}
}
	
Fabryka * ManagerFabryki::zwrocFabryke (const std::string & id) const {
	if (czyIstnieje(id))
		return s_mapa.find(id)->second;
	else
		throw std::exception("Nie ma fabryki o wskazanym identyfikatorze");
}

bool ManagerFabryki::czyIstnieje (const std::string & id) const {
	return (s_mapa.count(id) != 0) ? true : false;
}
#ifndef __KARTAGRAFICZNA_H__
#define __KARTAGRAFICZNA_H__
#include "element.h"

class KartaGraficzna : public Element {
public:
	KartaGraficzna (const std::string & id, int pamiec);
	virtual std::string opis () const = 0;
	virtual KartaGraficzna * klonuj () const = 0;
protected:
	int s_pamiec;
};

class KartaGraficznaNVidia : public KartaGraficzna {
public:
	KartaGraficznaNVidia (const std::string & id, int pamiec, bool CUDA);
	virtual std::string opis () const;
	virtual KartaGraficznaNVidia * klonuj () const;
private:
	bool s_CUDA;
};

class KartaGraficznaATI : public KartaGraficzna {
public:
	KartaGraficznaATI (const std::string & id, int pamiec);
	virtual std::string opis () const;
	virtual KartaGraficznaATI * klonuj () const;
};

#endif
#include "kartagraficzna.h"
#include <sstream>

KartaGraficzna::KartaGraficzna (const std::string & id, int pamiec) 
	: Element(id), s_pamiec(pamiec)
{

}

KartaGraficznaNVidia::KartaGraficznaNVidia (const std::string & id, int pamiec, bool CUDA) 
	: KartaGraficzna (id, pamiec), s_CUDA(CUDA)
{
}

std::string KartaGraficznaNVidia::opis () const {
	std::stringstream temp;
	temp << "Karta graficzna nVidia (" << s_id << ", " << s_pamiec << "MB";
	if (s_CUDA) temp << "+CUDA";
	temp << ")";
	return temp.str();
}

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

KartaGraficznaATI::KartaGraficznaATI (const std::string & id, int pamiec)
	: KartaGraficzna (id, pamiec)
{

}

std::string KartaGraficznaATI::opis () const {
	std::stringstream temp;
	temp << "Karta graficzna ATI (" << s_id << ", " << s_pamiec << "MB)";
	return temp.str();
}

KartaGraficznaATI * KartaGraficznaATI::klonuj () const {
	return new KartaGraficznaATI (*this);
}
#ifndef __NAPED_H__
#define __NAPED_H__
#include "element.h"

class Naped : public Element {
public:
	Naped (const std::string & id);
	virtual std::string opis () const = 0;
	virtual Naped * klonuj () const = 0;
};

class NapedDVD : public Naped {
public:
	NapedDVD (const std::string & id, int szybkoscDVD);
	virtual std::string opis () const;
	virtual NapedDVD * klonuj () const;
private:
	int s_szybkoscDVD;
};

class NapedBluRay : public Naped {
public:
	NapedBluRay (const std::string & id, int szybkoscBR);
	virtual std::string opis () const;
	virtual NapedBluRay * klonuj () const;
private:
	int s_szybkoscBR;
};

#endif
#include "naped.h"
#include <sstream>

Naped::Naped (const std::string & id) 
	: Element (id)
{
}

NapedDVD::NapedDVD (const std::string & id, int szybkoscDVD)
	: Naped (id), s_szybkoscDVD(szybkoscDVD)
{
}

std::string NapedDVD::opis () const {
	std::stringstream temp;
	temp << "Naped DVD " << s_id << " (" << s_szybkoscDVD << "x)";
	return temp.str();
}

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

NapedBluRay::NapedBluRay (const std::string & id, int szybkoscBR) 
	: Naped (id), s_szybkoscBR(szybkoscBR)
{
}

std::string NapedBluRay::opis () const {
	std::stringstream temp;
	temp << "Naped Blu-Ray " << s_id << " (" << s_szybkoscBR << "x)";
	return temp.str();
}

NapedBluRay * NapedBluRay::klonuj () const {
	return new NapedBluRay(*this);
}
#ifndef __PROCESOR_H__
#define __PROCESOR_H__
#include "element.h"

class Procesor : public Element {
public:
	Procesor (const std::string & id, int Hz);
	virtual std::string opis () const = 0;
	virtual Procesor * klonuj () const = 0;
protected:
	int s_Hz;
};

class ProcesorIntel : public Procesor {
public:
	ProcesorIntel (const std::string & id, int Hz);
	virtual std::string opis () const;
	virtual ProcesorIntel * klonuj () const;
};

class ProcesorAMD : public Procesor {
public:
	ProcesorAMD (const std::string & id, int Hz);
	virtual std::string opis () const;
	virtual ProcesorAMD * klonuj () const;
};


#endif
#include "procesor.h"
#include <sstream>

Procesor::Procesor (const std::string & id, int Hz) 
	: Element(id), s_Hz(Hz)
{
}

ProcesorIntel::ProcesorIntel (const std::string & id, int Hz) 
	: Procesor(id, Hz)
{
}
	
std::string ProcesorIntel::opis () const {
	std::stringstream temp;
	temp << "Procesor Intel (" << s_id << ", " << s_Hz << "Hz)";
	return temp.str();
}

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

ProcesorAMD::ProcesorAMD (const std::string & id, int Hz) 
	: Procesor(id, Hz)
{
}
	
std::string ProcesorAMD::opis () const {
	std::stringstream temp;
	temp << "Procesor AMD (" << s_id << ", " << s_Hz << "Hz)";
	return temp.str();
}
	
ProcesorAMD * ProcesorAMD::klonuj () const {
	return new ProcesorAMD(*this);
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11