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


Budowniczy

Przykład 1
#include <iostream>

#include "produkt.h"
#include "budowniczyascii.h"
#include "budowniczyupadkowany.h"
#include "zarzadca.h"

int main () {
	Budowniczy * budowniczy1 = new BudowniczyAscii();
	Budowniczy * budowniczy2 = new BudowniczyUpakowany();

	Zarzadca zarzadca1(budowniczy1);
	Zarzadca zarzadca2(budowniczy2);
	
	Produkt * produkt1 = zarzadca1.tworzProc_zapiszZmienna(0xffeeffee, 0x00999999, 2011);
	Produkt * produkt2 = zarzadca2.tworzProc_zapiszZmienna(0xffeeffee, 0x00999999, 2011);
		
	std::clog << "Ramka Budowniczego ASCII: \n"; 
	produkt1->pokazTrescRamki(); 
	std::clog << "\n\n";

	std::clog << "Ramka Budowniczego upakowanego: \n"; 
	produkt2->pokazTrescRamki(); 
	std::clog << std::endl; 
	produkt2->pokazTrescRamki(true);

	delete produkt1;
	delete produkt2;

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

enum NazwaProcedury { BRAK_PROCEDURY, POBIERZ_ZMIENNA, ZAPISZ_ZMIENNA, SPRAWDZ_ODPOWIEDZ }; 

class MapowanieProcedur {
public:
	static int enumNaInt (NazwaProcedury nazwa);
	static std::string enumNaString (NazwaProcedury nazwa);
};

class Produkt;

class Budowniczy {
public:
	Budowniczy ();
	~Budowniczy ();
	virtual void ustawAdres (int adres) = 0;
	virtual void ustawProcedure (NazwaProcedury nazwa) = 0;
	virtual void dodajArgument (int arg) = 0;
	virtual void dodajCRC () = 0;
	Produkt * zwrocProdukt () const;
	void resetujBudowniczego ();
protected:
	void dodajSlowoRamki (char slowo);
	unsigned int rozmiarRamki () const;
	char pobierzBajt (unsigned int indeks) const;
	
	Produkt * s_produkt;
};


#endif
#include "budowniczy.h"
#include "produkt.h"

int MapowanieProcedur::enumNaInt (NazwaProcedury nazwa) {
	switch (nazwa) {
		case POBIERZ_ZMIENNA: return 0x0100;
		case ZAPISZ_ZMIENNA: return 0x0101;
		case SPRAWDZ_ODPOWIEDZ: return 0xff00;
		default: return 0x0000;
	}
}
	
std::string MapowanieProcedur::enumNaString (NazwaProcedury nazwa) {
	switch (nazwa) {
		case POBIERZ_ZMIENNA: return "pobierzZmienna";
		case ZAPISZ_ZMIENNA: return "zapiszZmienna";
		case SPRAWDZ_ODPOWIEDZ: return "sprawdzOdpowiedz";
		default: return "brakProcedury";
	}
}

Budowniczy::Budowniczy () {
	s_produkt = new Produkt();
}
	
Budowniczy::~Budowniczy () {
	delete s_produkt;
}

Produkt * Budowniczy::zwrocProdukt () const {
	return new Produkt(*s_produkt);
}

void Budowniczy::resetujBudowniczego () {
	s_produkt->resetujRamke();
}

void Budowniczy::dodajSlowoRamki (char slowo) {
	s_produkt->dodajSlowoRamki(slowo);
}
	
unsigned int Budowniczy::rozmiarRamki () const {
	return s_produkt->rozmiarRamki();
}
	
char Budowniczy::pobierzBajt (unsigned int indeks) const {
	return (*s_produkt)(indeks);
}
#ifndef __BUDOWNICZYASCII_H__
#define __BUDOWNICZYASCII_H__
#include "budowniczy.h"

class BudowniczyAscii : public Budowniczy {
public:
	virtual void ustawAdres (int adres);
	virtual void ustawProcedure (NazwaProcedury nazwa);
	virtual void dodajArgument (int arg);
	virtual void dodajCRC ();
private:
	void zapiszDoRamki (const std::string & lancuch);
};

#endif
#include "budowniczyascii.h"
#include <iostream>
#include <sstream>

void BudowniczyAscii::ustawAdres (int adres) {
	std::ostringstream temp;
	temp << std::hex << "0x" << adres;
	zapiszDoRamki ("Adr: ");
	zapiszDoRamki (temp.str());
}
	
void BudowniczyAscii::ustawProcedure (NazwaProcedury nazwa) {
	zapiszDoRamki (" Proc: ");
	zapiszDoRamki (MapowanieProcedur::enumNaString(nazwa));
}
	
void BudowniczyAscii::dodajArgument (int arg) {
	std::ostringstream temp;
	temp << " 0x";
	temp << std::hex << arg;
	zapiszDoRamki (temp.str());
}
	
void BudowniczyAscii::dodajCRC () {
	return;
}

void BudowniczyAscii::zapiszDoRamki (const std::string & lancuch) {
	for (unsigned int i = 0; i < lancuch.size(); ++i)
		dodajSlowoRamki(lancuch[i]);
}
#ifndef __PRODUKT_H__
#define __PRODUKT_H__
#include <vector>

class Produkt {
public:
	void pokazTrescRamki (bool podajKodowo = false) const;
private:
	Produkt ();
	void dodajSlowoRamki (char slowo);
	unsigned int rozmiarRamki () const;
	char operator()(unsigned int indeks) const;
	void resetujRamke ();

	std::vector<char> s_ramka;

	friend class Budowniczy;
};

#endif
#include "produkt.h"
#include <iostream>
#include <iterator>

void Produkt::pokazTrescRamki (bool podajKodowo) const {
	std::clog << "\t";
	if (podajKodowo)
		std::copy(s_ramka.begin(), s_ramka.end(), std::ostream_iterator<int>(std::clog, " "));
	else {
		std::clog << "##";
		std::copy(s_ramka.begin(), s_ramka.end(), std::ostream_iterator<char>(std::clog, ""));
		std::clog << "##";
	}
}

Produkt::Produkt () {
	s_ramka.reserve(256);
}
	
void Produkt::dodajSlowoRamki (char slowo) {
	s_ramka.push_back(slowo);
}

unsigned int Produkt::rozmiarRamki () const {
	return s_ramka.size();
}
	
char Produkt::operator()(unsigned int indeks) const {
	return s_ramka.at(indeks);
}

void Produkt::resetujRamke () {
	s_ramka.clear();
}
#ifndef __ZARZADCA_H__
#define __ZARZADCA_H__
#include "budowniczy.h"

class Produkt;

class Zarzadca {
public:
	Zarzadca (Budowniczy * budowniczy);
	~Zarzadca ();

	Produkt * tworzProc_pobierzZmienna (int adresUrz, int adresZm);
	Produkt * tworzProc_zapiszZmienna (int adresUrz, int adresZm, int wartoscZm);
	Produkt * tworzProc_sprawdzOdpowiedz (int adresUrz);
private:
	Zarzadca (const Zarzadca & zarzadca);
	Zarzadca operator= (const Zarzadca & zarzadca);

	Budowniczy * s_budowniczy;
};

#endif
#include "zarzadca.h"

Zarzadca::Zarzadca (Budowniczy * budowniczy) 
	: s_budowniczy(budowniczy)
{
}

Zarzadca::~Zarzadca () {
	delete s_budowniczy;
}

Produkt * Zarzadca::tworzProc_pobierzZmienna (int adresUrz, int adresZm) {
	s_budowniczy->resetujBudowniczego();
	s_budowniczy->ustawAdres(adresUrz);
	s_budowniczy->ustawProcedure(ZAPISZ_ZMIENNA);
	s_budowniczy->dodajArgument(adresZm);
	s_budowniczy->dodajCRC();
	return s_budowniczy->zwrocProdukt();
}
	
Produkt * Zarzadca::tworzProc_zapiszZmienna (int adresUrz, int adresZm, int wartoscZm) {
	s_budowniczy->resetujBudowniczego();
	s_budowniczy->ustawAdres(adresUrz);
	s_budowniczy->ustawProcedure(POBIERZ_ZMIENNA);
	s_budowniczy->dodajArgument(adresZm);
	s_budowniczy->dodajArgument(wartoscZm);
	s_budowniczy->dodajCRC();
	return s_budowniczy->zwrocProdukt();
}
	
Produkt * Zarzadca::tworzProc_sprawdzOdpowiedz (int adresUrz) {
	s_budowniczy->resetujBudowniczego();
	s_budowniczy->ustawAdres(adresUrz);
	s_budowniczy->ustawProcedure(SPRAWDZ_ODPOWIEDZ);
	s_budowniczy->dodajCRC();
	return s_budowniczy->zwrocProdukt();
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11