Pakiet programów do zdalnego nauczania Programowania Orientowanego Obiektowo
Dzisiaj jest
Środa, 18 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


Iterator

Przykład 4
#include "modeldanych.h"

#include <iostream>

int main () {
	ModelDanych model;

	// zapis danych procesowych do modelu
	model.dodajDane(45, 10.0);
	model.dodajDane(60, 15.0);
	model.dodajDane(80, 10.0);
	model.dodajDane(90, 5.0);

	// odczyt danych z modelu
	ModelDanych::iterator * it1 = model.pobierzIterator(ModelDanych::ITERATORZWYKLY);
	ModelDanych::iterator * it2 = model.pobierzIterator(ModelDanych::ITERATORUSREDNIONY);

	std::clog << "Iterator zwykly : " << std::endl;
	while (!it1->czyKoniec()) {
		std::clog << it1->x() << " " << it1->y() << std::endl;
		it1->nastepny();
	}

	std::clog << std::endl << "Iterator usredniajacy : " << std::endl;
	while (!it2->czyKoniec()) {
		std::clog << it2->x() << " " << it2->y() << std::endl;
		it2->nastepny();
	}

	delete it1;
	delete it2;

	return 0;
}
#ifndef __MODELDANYCH_H__
#define __MODELDANYCH_H__
#include <map>

class ModelDanych {
public:
	ModelDanych ();
	void dodajDane (int t, double y);
	void wyczysc ();
	
	bool czyIstniejePomiar (int t) const;
	double pobierzPomiar (int t) const;

	enum TypIteratora { ITERATORZWYKLY = 0, ITERATORUSREDNIONY = 1 };

	class iterator {
	protected:
		iterator (const std::map<int, double> & model);
	public:
		virtual ~iterator () {}
		virtual int x() const = 0;
		virtual double y() const = 0;
		virtual void nastepny () = 0;
		virtual bool czyKoniec () const = 0;
	protected:
		typedef std::map<int, double> TypModelu;
		const TypModelu &s_model;
		TypModelu::const_iterator s_iter;
		TypModelu::const_iterator s_iterKoniec;
	};

	class iteratorZwykly : public iterator {
	private:
		iteratorZwykly (const std::map<int, double> & model);
	public:
		virtual int x() const;
		virtual double y() const;
		virtual void nastepny ();
		virtual bool czyKoniec () const;

		friend class ModelDanych;
	};

	class iteratorUsredniajacy : public iterator {
	private:
		iteratorUsredniajacy (const std::map<int, double> & model);
	public:
		virtual int x() const;
		virtual double y() const;
		virtual void nastepny ();
		virtual bool czyKoniec () const;

		friend class ModelDanych;
	private:
		int s_biezacyIndeks;
		TypModelu::const_iterator s_iterGraniczny;
	};

	iterator * pobierzIterator(TypIteratora typ) const;
private:
	std::map<int, double> s_impl;
};

#endif
#include "modeldanych.h"
#include <exception>
#include <map>

ModelDanych::ModelDanych () {

}
	
void ModelDanych::dodajDane (int t, double y) {
	s_impl[t] = y;
}
	
void ModelDanych::wyczysc () {
	s_impl.clear();
}
	
bool ModelDanych::czyIstniejePomiar (int t) const {
	return (s_impl.count(t) != 0) ? true : false;
}
	
double ModelDanych::pobierzPomiar (int t) const {
	if (!czyIstniejePomiar(t))
		throw std::exception ("Brak pomiaru z danej chwili czasu");
	else 
		return s_impl.find(t)->second;
}

ModelDanych::iterator * ModelDanych::pobierzIterator(TypIteratora typ) const {
	if (typ == ITERATORZWYKLY) 
		return new iteratorZwykly(s_impl);
	else 
		return new iteratorUsredniajacy(s_impl);
}

/******/

ModelDanych::iterator::iterator (const std::map<int, double> & model)
	: s_model(model)
{
	s_iter = s_model.begin();
	s_iterKoniec = s_model.end();
}

/******/

ModelDanych::iteratorZwykly::iteratorZwykly (const std::map<int, double> & model)
	: iterator(model)
{
}

int ModelDanych::iteratorZwykly::x() const {
	return s_iter->first;
}
		
double ModelDanych::iteratorZwykly::y() const {
	return s_iter->second;
}
		
void ModelDanych::iteratorZwykly::nastepny () {
	std::advance(s_iter, 1);
}
		
bool ModelDanych::iteratorZwykly::czyKoniec () const {
	return (s_iter == s_iterKoniec) ? true : false;
}

/******/

ModelDanych::iteratorUsredniajacy::iteratorUsredniajacy (const std::map<int, double> & model) 
	: iterator(model)
{
	if (!model.empty()) {
		s_biezacyIndeks = s_iter->first;
		s_iterGraniczny = s_iter; 
		std::advance(s_iterGraniczny, 1);
	}
}
		
int ModelDanych::iteratorUsredniajacy::x() const {
	return s_biezacyIndeks;
}
		
double ModelDanych::iteratorUsredniajacy::y() const {
	if (s_model.count(s_biezacyIndeks) != 0) {
		return s_iter->second;
	} else {
		int x1 = s_iter->first;
		int x2 = s_iterGraniczny->first;
		double y1 = s_iter->second;
		double y2 = s_iterGraniczny->second;
	
		double wartoscY = y1 + (y2-y1) * (static_cast<double>(s_biezacyIndeks-x1)/(x2-x1));
		return wartoscY;
	}
}
		
void ModelDanych::iteratorUsredniajacy::nastepny () {
	++s_biezacyIndeks;
	if (s_biezacyIndeks == s_iterGraniczny->first) {
		std::advance(s_iter, 1);
		std::advance(s_iterGraniczny, 1);
	}
}
		
bool ModelDanych::iteratorUsredniajacy::czyKoniec () const {
	return (s_model.empty()) || (s_biezacyIndeks > s_model.rbegin()->first);
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11