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



Fabryka abstrakcyjna

Przykład 4
#include "fabryka.h"

#include <iostream>

int main () {
	ManagerFabryki manager;
	
	manager.dodajFabryke ("Zestaw 1", 
		new Fabryka(
			new ProcesorIntel("Core i5", 2400), 
			new KartaGraficznaNVidia("GFX260", 2048, true), 
			new	NapedBluRay("BH10LS30Box", 8)));

	manager.dodajFabryke ("Zestaw 2",
		new Fabryka(
			new ProcesorAMD("Phenom II X4", 2000),
			new KartaGraficznaNVidia("GF9800", 512, false),
			new NapedDVD("iHAS624", 8)));

	manager.dodajFabryke ("Zestaw 3",
		new Fabryka(
			new ProcesorIntel("Core2Quad Q9650", 3000),
			new KartaGraficznaATI("HD5870", 512),
			new NapedDVD("SE-084F", 48)));

	try {
		std::string zestaw = "Zestaw 3";
		Procesor * procesor = manager.zwrocFabryke(zestaw)->podajProcesor();
		KartaGraficzna * karta = manager.zwrocFabryke(zestaw)->podajKarta();
		Naped * naped = manager.zwrocFabryke(zestaw)->podajNaped();

		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 (Procesor * procesor, KartaGraficzna * karta, Naped * naped);
	~Fabryka ();
	Procesor * podajProcesor () const;
	KartaGraficzna * podajKarta () const;
	Naped * podajNaped () const;
private:
	Procesor * s_procesor;
	KartaGraficzna * s_karta;
	Naped * s_naped;
};

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 <algorithm>

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

Fabryka::Fabryka (Procesor * procesor, KartaGraficzna * karta, Naped * naped) 
	: s_procesor(procesor), s_karta(karta), s_naped(naped)
{
	if (!(procesor && karta && naped))
		throw std::exception("Fabryka nie moze zostac zainicjowana zerowym wskaznikiem");
}

Fabryka::~Fabryka () {
	delete s_procesor;
	delete s_karta;
	delete s_naped;
}
	
Procesor * Fabryka::podajProcesor () const {
	return s_procesor->klonuj();
}
	
KartaGraficzna * Fabryka::podajKarta () const {
	return s_karta->klonuj();
}

Naped * Fabryka::podajNaped () const {
	return s_naped->klonuj();
}

ManagerFabryki::ManagerFabryki () {
}

ManagerFabryki::~ManagerFabryki () {
	std::for_each(s_mapa.begin(), s_mapa.end(), ObiektFunUsun());
}
	
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