P2 - 3° appello, 14.06.2016

FileAudio.h

#pragma once

class FileAudio {
private:
	double dim;
public:
	FileAudio(double d) :
		dim(d) {}
	~virtual FileAudio() {}

	virtual FileAudio* clone() const = 0;
	virtual bool quality() const = 0;
	double Dimension() const {
		return dim;
	}
};

class Mp3 : public FileAudio {
private:
	unsigned int bitRate;
public:
	Mp3(double d, unsigned int br) :
		FileAudio(d),
		bitRate(br) {}

	virtual Mp3* clone() const {
		return new Mp3(*this);
	}

	virtual bool quality() const {
		return bitRate >= 256;
	}

	unsigned int BitRate() const {
		return bitRate;
	}
};

class WAW : public FileAudio {
private:
	unsigned int freq;
public:
	WAW(double d, unsigned int f) :
		FileAudio(d),
		freq(f) {}

	virtual WAW* clone() const {
		return new WAW(*this);
	}

	virtual bool quality() const {
		return freq >= 192;
	}
};

main.cpp

#include <iostream>
#include "FileAudio.h"
#include "MusicPlay.h"

int main() {
	const FileAudio* m1 = new WAW(15, 192);
	const FileAudio* m2 = new Mp3(10, 128);
	const FileAudio* m3 = new Mp3(12, 256);

	std::list<const FileAudio*> lst = std::list<const FileAudio*>{
		m1, m2, m3
	};

	MusicPlay app(lst);

	std::vector<WAW*> qw = app.qualityWAW(192);

	for (auto item : qw) {
		std::cout << item->Dimension() << " "; // 15
	}
	std::cout << std::endl;

	std::list<FileAudio*> nca = app.nonConstCopy();

	for (auto item : nca) {
		std::cout << item->Dimension() << " "; // 15 10 12
	}
	std::cout << std::endl;

	std::vector<Mp3> vm = app.removeMp3(320);

	for (auto item : vm) {
		std::cout << item.BitRate() << " "; // 128 256
	}
	std::cout << std::endl;

	std::getchar();
}

MusicPlay.h

#pragma once
#include <list>
#include <vector>
#include "FileAudio.h"

class MusicPlay {
private:
	std::list<const FileAudio*> lst;
	typedef std::list<const FileAudio*>::const_iterator ci;

public:
	MusicPlay(const std::list<const FileAudio*>& l) :
		lst(l) {}

	std::vector<WAW*> qualityWAW(double dim) const {
		std::vector<WAW*> result;
		for (ci it = lst.cbegin(); it != lst.cend(); it++) {
			if ((*it)->Dimension() <= dim) {
				const WAW* cw = dynamic_cast<const WAW*>(*it);
				if (cw && cw->quality()) {
					WAW* w = const_cast<WAW*>(cw);
					result.push_back(w);
				}
			}
		}

		return result;
	}

	std::list<FileAudio*> nonConstCopy() const {
		std::list<FileAudio*> result;
		for (ci it = lst.cbegin(); it != lst.cend(); it++) {
			const FileAudio* cf = (*it)->clone();
			FileAudio* f = const_cast<FileAudio*>(cf);
			result.push_back(f);
		}

		return result;
	}

	std::vector<Mp3> removeMp3(unsigned int br) {
		std::vector<Mp3> result;
		for (ci it = lst.cbegin(); it != lst.cend();) {
			const Mp3* cm = dynamic_cast<const Mp3*>(*it);
			if (cm && cm->BitRate() < br) {
				Mp3* m = const_cast<Mp3*>(cm);
				result.push_back(*m);
				// delete *it; // Non c'è scritto di deallocare
				it = lst.erase(it);
			}
			else {
				it++;
			}
		}

		return result;
	}
};