GalloFile, OOP c++

Gallo.h

#pragma once
#include <vector>
#include "GalloFile.h"

class Gallo {
private:
	std::vector<GalloFile*> files;

public:
	Gallo(const std::vector<GalloFile*> v) :
		files(v) {}

	~Gallo() {
		for (GalloFile* gf : files) {
			delete gf;
		}
		files.clear();
	}

	std::vector<GalloFile*> Files() const {
		return files;
	}

	std::vector<GalloFile*> selectHQ() const {
		std::vector<GalloFile*> result;

		for (std::vector<GalloFile*>::const_iterator it = files.cbegin(); it != files.cend(); it++) {
			if ((*it)->highQuality()) {
				Foto* f = dynamic_cast<Foto*>(*it);

				if (!f || f->Flash()) { // se non sono una foto, o se sono una foto scattata col flash
					result.push_back(*it);
				}
			}
		}

		return result;
	}

	void removeNonFoto(double size) throw(std::logic_error) {
		std::size_t original_size = files.size();
		for (std::vector<GalloFile*>::iterator it = files.begin(); it != files.end();) {
			bool remove = (*it)->Dimension() > size;
			if (!remove) {
				Foto* f = dynamic_cast<Foto*>(*it);
				remove = (f == nullptr);
			}
			if (remove) {
				it = files.erase(it);
			}
			else {
				it++;
			}
		}

		if (files.size() == original_size) {
			throw std::logic_error("NoRemove");
		}
	}

	const GalloFile* insert(const GalloFile* pf) {
		const Video* cv = dynamic_cast<const Video*>(pf);

		bool add = (cv == nullptr);
		if (!add) {
			add = cv->Lenght() < 60;
		}

		if (add) {
			Video* v = const_cast<Video*>(cv);
			files.push_back(v);
			std::vector<GalloFile*>::const_iterator end = files.cend() - 1;
			return *end;
		}

		return nullptr;
	}
};

GalloFile.h

#pragma once

class GalloFile {
private:
	double dim;

public:
	GalloFile(double d) :
		dim(d) {}
	virtual ~GalloFile() {};

	double Dimension() const {
		return dim;
	}

	virtual GalloFile* clone() const = 0;

	virtual bool highQuality() const = 0;
};

class Foto : public GalloFile {
private:
	unsigned int iso;
	bool flash;

public:
	Foto(double d, unsigned int i, bool f) :
		GalloFile(d),
		iso(i),
		flash(f) {}

	bool Flash() const {
		return flash;
	}

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

	virtual bool highQuality() const override {
		return iso >= 500;
	}
};

class Video : public GalloFile {
private:
	double len;
	bool fullHD;

public:
	Video(double d, double l, bool h) :
		GalloFile(d),
		len(l),
		fullHD(h) {}

	double Lenght() const {
		return len;
	}

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

	virtual bool highQuality() const override {
		return fullHD;
	}
};

main.cpp

#include "Gallo.h"
#include "GalloFile.h"
#include <iostream>

int main() {
	Foto* f1 = new Foto(6, 500, true); // 6MB, 500 ISO, Flash
	Foto* f2 = new Foto(1, 250, true); // 1MB, 250 ISO, Flash
	Foto* f3 = new Foto(10, 750, true); // 10MB, 750 ISO, No flash

	Video* v1 = new Video(12, 30, true); // 12MB, 30s, FullHD
	Video* v2 = new Video(2, 30, false); // 2MB, 15s, no FullHD
	Video* v3 = new Video(50, 90, true); // 50MB, 90s, FullHD

	std::vector<GalloFile*> container{
		f1, f2, f3,
		v1, v2, v3
	};

	Gallo pollo(container);

	std::vector<GalloFile*> hq = pollo.selectHQ();

	for (auto gf : hq) {
		std::cout << gf->Dimension() << " "; // 6 10 12 50
	}
	std::cout << std::endl;

	pollo.removeNonFoto(9);

	for (auto gf : pollo.Files()) {
		std::cout << gf->Dimension() << " "; // 6 1
	}
	std::cout << std::endl;

	try {
		pollo.removeNonFoto(1000);
	}
	catch (std::logic_error& e) {
		std::cout << e.what() << std::endl; // NoRemove
	}

	const GalloFile* pv1 = pollo.insert(v1);

	std::cout << pv1->Dimension() << std::endl; // 12

	const GalloFile* pvNull = pollo.insert(v3);

	std::cout << (pvNull != nullptr) << std::endl; // 0
	
	std::getchar();
}