Pakiet programów do zdalnego nauczania Programowania Orientowanego Obiektowo
Dzisiaj jest
Poniedziałek, 23 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


Kompozyt

Przykład 4
#include <iostream>

#include "urzadzeniausb.h"

int main(void) {
	try {
		UrzadzenieUSB * kontroler = new HubUSB(4);

		// podlaczanie elementow na pierwszym poziomie
		kontroler->podlaczUrzadzenie(0, new HubUSB(4));
		kontroler->podlaczUrzadzenie(1, new DyskTwardy());
		kontroler->podlaczUrzadzenie(2, new DyskTwardy());

		// podlaczanie elementow na drugim poziomie
		kontroler->port(0)->podlaczUrzadzenie(0, new Klawiatura());
		kontroler->port(0)->podlaczUrzadzenie(1, new Mysz());
		kontroler->port(0)->podlaczUrzadzenie(2, new Pendrive());
		kontroler->port(0)->podlaczUrzadzenie(3, new HubUSB(2));

		// podlaczenie elementow na trzecim poziomie
		kontroler->port(0)->port(3)->podlaczUrzadzenie(0, new AparatFotograficzny());

		// wyznaczanie poziomu zaglebienia poszczegolnych urzadzen
		std::clog << kontroler->poziomZagniezdzenia() << std::endl;
		std::clog << kontroler->port(0)->poziomZagniezdzenia() << std::endl;
		std::clog << kontroler->port(0)->port(3)->port(0)->poziomZagniezdzenia() << std::endl;
	} catch (const std::exception & e) {
		std::clog << "WYJATEK: " << e.what() << std::endl;
	}

	return 0;
}
#ifndef __URZADZENIAUSB_H__
#define __URZADZENIAUSB_H__

#include <vector>

class HubUSB;

class UrzadzenieUSB {
public:
	UrzadzenieUSB ();
	virtual ~UrzadzenieUSB ();
	virtual HubUSB * podlaczUrzadzenie (unsigned int port, UrzadzenieUSB * urzUSB);
	virtual UrzadzenieUSB * odlaczUrzadzenie (unsigned int port);
	virtual UrzadzenieUSB * port (unsigned int aPort);
	virtual unsigned int liczbaPortow () const;
	virtual void pracuj () = 0;

	unsigned int poziomZagniezdzenia () const;
private:
	UrzadzenieUSB * s_przodek;
	void ustawPrzodka (UrzadzenieUSB * przodek);
	unsigned int poziomZagniezdzeniaPriv (unsigned int start = 0) const;

	friend class HubUSB;
};

class HubUSB : public UrzadzenieUSB {
public:
	HubUSB (unsigned int liczbaPortow);
	virtual ~HubUSB ();
	virtual HubUSB * podlaczUrzadzenie (unsigned int port, UrzadzenieUSB * urzUSB);
	virtual UrzadzenieUSB * odlaczUrzadzenie (unsigned int port);
	virtual UrzadzenieUSB * port (unsigned int aPort);
	virtual unsigned int liczbaPortow () const;
	void pracuj ();
private:
	std::vector<UrzadzenieUSB *> s_porty;
};

class Klawiatura : public UrzadzenieUSB {
public:
	Klawiatura ();
	virtual void pracuj ();
};

class Mysz : public UrzadzenieUSB {
public:
	Mysz ();
	virtual void pracuj ();
};

class DyskTwardy : public UrzadzenieUSB {
public:
	DyskTwardy ();
	virtual void pracuj ();
};

class Pendrive : public UrzadzenieUSB {
public:
	Pendrive ();
	virtual void pracuj ();
};

class AparatFotograficzny : public UrzadzenieUSB {
public:
	AparatFotograficzny ();
	virtual void pracuj ();
};

#endif
#include "urzadzeniausb.h"

#include <algorithm>
#include <iostream>

namespace {
	class ObFunUsun {
	public:
		void operator() (UrzadzenieUSB * urz) {
			delete urz;
		}
	};
}

UrzadzenieUSB::UrzadzenieUSB () : s_przodek(0)
{

}

UrzadzenieUSB::~UrzadzenieUSB () {

}

HubUSB * UrzadzenieUSB::podlaczUrzadzenie (unsigned int port, UrzadzenieUSB * urzUSB) {
	throw std::exception("Nie mozna podlaczac urzadzen");
}

UrzadzenieUSB * UrzadzenieUSB::odlaczUrzadzenie (unsigned int port) {
	throw std::exception("Nie mozna odlaczac urzadzen");
}

UrzadzenieUSB * UrzadzenieUSB::port (unsigned int aPort) {
	throw std::exception("Nie mozna zwrocic uzadzenia z portu");
}

unsigned int UrzadzenieUSB::liczbaPortow () const {
	return 0;
}

unsigned int UrzadzenieUSB::poziomZagniezdzenia () const {
	return poziomZagniezdzeniaPriv(0);
}

void UrzadzenieUSB::ustawPrzodka (UrzadzenieUSB * przodek) {
	s_przodek = przodek;
}

unsigned int UrzadzenieUSB::poziomZagniezdzeniaPriv (unsigned int start) const {
	return (s_przodek) ? s_przodek->poziomZagniezdzeniaPriv(start+1) : start;
}

HubUSB::HubUSB (unsigned int liczbaPortow) 
	: s_porty(liczbaPortow, 0)
{

}

HubUSB::~HubUSB () {
	std::for_each(s_porty.begin(), s_porty.end(), ObFunUsun());
}

void HubUSB::pracuj () {
	std::clog << "Hub pracuje" << std::endl;
	
	std::vector<UrzadzenieUSB *>::iterator it;
	for (it = s_porty.begin(); it != s_porty.end(); ++it) {
		if (*it) 
			(*it)->pracuj();
	}
}

HubUSB * HubUSB::podlaczUrzadzenie (unsigned int port, UrzadzenieUSB * urzUSB) {
	s_porty.at(port) = urzUSB;
	urzUSB->ustawPrzodka(this);				//<
	return this;
}

UrzadzenieUSB * HubUSB::odlaczUrzadzenie (unsigned int port) {
	UrzadzenieUSB * temp = s_porty.at(port);
	temp->ustawPrzodka(0);					//<
	s_porty.at(port) = 0;
	return temp;
}


UrzadzenieUSB * HubUSB::port (unsigned int aPort) {
	return s_porty.at(aPort);
}

unsigned int HubUSB::liczbaPortow () const {
	return s_porty.size();
}

Klawiatura::Klawiatura () {
	
}

void Klawiatura::pracuj () {
	std::clog << "Klawiatura pracuje" << std::endl;
}

Mysz::Mysz () {
	
}

void Mysz::pracuj () {
	std::clog << "Mysz pracuje" << std::endl;
}

DyskTwardy::DyskTwardy () {
	
}

void DyskTwardy::pracuj () {
	std::clog << "Dysk twardy pracuje" << std::endl;
}

Pendrive::Pendrive () {

}

void Pendrive::pracuj () {
	std::clog << "Pendrive pracuje" << std::endl;
}

AparatFotograficzny::AparatFotograficzny () {

}

void AparatFotograficzny::pracuj () {
	std::clog << "Aparat fotograficzny pracuje" << std::endl;
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11