Pakiet programów do zdalnego nauczania Programowania Orientowanego Obiektowo
Dzisiaj jest
Sobota, 21 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 3
#include "proces.h"
#include "modeldanych.h"

#include <iostream>

int main () {
	Proces proces(0.1, 0, 0.1, 10, 0.01);
	ModelDanych model;

	// zapis danych procesowych do modelu
	for (unsigned int t = 0; t <= 400; ++t) model.dodajDane(t, proces.symuluj());

	// odczyt danych z modelu
	ModelDanych::iterator it1 = model.pobierzIteratorOdDo(200, 250);
	ModelDanych::iterator it2 = model.pobierzIteratorOstatnieN(100);

	while (!it1.czyKoniec()) {
		std::clog << it1.x() << " " << it1.y() << std::endl;
		it1.nastepny();
	}

	while (!it2.czyKoniec()) {
		std::clog << it2.x() << " " << it2.y() << std::endl;
		it2.nastepny();
	}

	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;

	class iterator {
	private:
		iterator (const std::map<int, double> & model);
		iterator (int start, int koniec, const std::map<int, double> & model);
	public:
		int x() const;
		double y() const;
		void nastepny ();
		bool czyKoniec () const;
	private:
		typedef std::map<int, double> TypModelu;
		const TypModelu &s_model;
		TypModelu::const_iterator s_iter;
		TypModelu::const_iterator s_iterKoniec;

		friend class ModelDanych;
	};

	iterator pobierzIterator() const;
	iterator pobierzIteratorOdDo (int M, int N) const;
	iterator pobierzIteratorOstatnieN (int N) const;
private:
	std::map<int, double> s_impl;
};

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

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() const {
	return iterator(s_impl);
}

ModelDanych::iterator ModelDanych::pobierzIteratorOdDo (int M, int N) const {
	return iterator(M, N+1, s_impl);
}
	
ModelDanych::iterator ModelDanych::pobierzIteratorOstatnieN (int N) const {
	if (s_impl.empty())
		return pobierzIterator ();
	else {
		int maxIndeks = s_impl.rbegin()->first;
		return iterator (maxIndeks-N, maxIndeks+1, 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::iterator::iterator (int start, int koniec, const std::map<int, double> & model) 
	: s_model(model)
{
	s_iter = (s_model.count(start) != 0) ? s_model.find(start) : s_model.upper_bound(start);
	s_iterKoniec = (s_model.count(koniec) != 0) ? s_model.find(koniec) : s_model.lower_bound(koniec);
}

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

class Proces {
public:
	Proces (double a, double b, double sinAmp, int sinOkres, double maxLos);
	double symuluj ();
private:
	double s_a;
	double s_b;
	double s_sinAmp;
	int s_sinOkres;
	double s_maxLos;
	int s_t;
};

#endif
#include "proces.h"
#include <cstdlib>
#include <cmath>

Proces::Proces (double a, double b, double sinAmp, int sinOkres, double maxLos) 
	: s_a(a), s_b(b), s_sinAmp(sinAmp), s_sinOkres(sinOkres), s_maxLos(maxLos), s_t(0)
{
}

double Proces::symuluj () {
	double skladnikLiniowy = s_a*s_t + s_b;
	double skladnikSinusoidalny = 
		s_sinAmp*std::sin((static_cast<double>(s_t % s_sinOkres) / s_sinOkres) * 6.28);
	
	double skladnikLosowy = (((std::rand() % 1000) / 500.0) - 1.0) * s_maxLos;

	++s_t;
	return skladnikLiniowy + skladnikSinusoidalny + skladnikLosowy;
}
Adamik Łukasz, Politechnika Śląska w Gliwicach (AEiI) - 2010/11