контроллер

[elenSV]

а здесь класс Record можно вот представить:

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>

typedef std::string word;
/***************************************************************************/

class Record {
    /* Массив слов */
    std::vector<std::string> words;
public:
    /* Конструкторы */
    Record():words() {}
    Record(const std::string& b):words() { load(b); }
    /* Деструктор */
    ~Record() {}
    /* Загружает слова из строки */
    void load(const std::string& b) {
        std::istringstream buf(b);
        word word;

        while ( buf.rdbuf()->in_avail() ) {
            buf >> word;
            words.push_back(word);
        }
    }
    /* Сохраняет слова в строку */
    void save(std::string& b) {
        std::ostringstream buf;
        std::vector<std::string>::iterator it = words.begin();
        while ( it != words.end() ) {
            buf << *it << (it == words.end()) ? "" : " ";
            ++it;
        }
        b = buf.str();
    }
    /* Добавляет одно слово */
    void add(const word& w) {
        if ( w.empty() ) return;
        words.push_back(w);
    }
    /* Проверка на присутствие слова 'w' в массиве */
    bool contains(const word& w) const {
        return std::count(words.begin(), words.end(), w) > 0;
    }
};

/***************************************************************************/
/* Информация о записи */
struct RecordInfo {
    RecordInfo():cassete_num(0),record_num(0){}
    int cassete_num;
    int record_num;
};

/***************************************************************************/
/* Из строки прочитанной из файла записей, извлекает информацию о записи */
RecordInfo get_record_info( const std::string& s ) {
    RecordInfo recinfo;
    std::string casnum;
    std::string recnum;
    
    std::string::const_iterator it1 = std::find(s.begin(), s.end(), ':');
    casnum.resize(it1-s.begin());
    std::copy(s.begin(), it1, casnum.begin());
    
    it1++;
    std::string::const_iterator it2 = std::find(it1, s.end(), ':');
    recnum.resize(it2-it1);
    std::copy(it1, it2, recnum.begin());
    
    recinfo.cassete_num = atoi(casnum.c_str());
    recinfo.record_num = atoi(recnum.c_str());
    
    return recinfo;
}

/***************************************************************************/
/* Удаляет из строки информацию о записи */
std::string trim_info(const std::string& s) {
    std::string result;
    std::string::const_iterator it1 = std::find(s.begin(), s.end(), ':')+1;
    std::string::const_iterator it2 = std::find(it1, s.end(), ':')+1;
    result.resize(s.end()-it2);
    std::copy(it2, s.end(), result.begin());
    return result;
}

/***************************************************************************/

int main(int argc, char** argv) {
    RecordInfo recinfo;
    /* Открываем файл записей для чтения из него */
    std::fstream in("records.txt", std::ios::in);
    if ( !in ) {
        std::cout << "Can`t open records file. Terminate!\n";
        return 1;
    }
    /* Читаем построчно поку не конец файла */
    while ( !in.eof() ) {
        /* Временные объекты. (пока что...) */
        Record rec;
        std::string str;
        /* Читаем строку */
        std::getline(in, str);
        /* Извлекаем из нее информацию о записи */
        recinfo = get_record_info(str);
        /* Выводим информацию о записи. (для отладки...) */
        std::cout<< "Record info - cas:" << recinfo.cassete_num
                    << " rec:" << recinfo.record_num << std::endl;
        /* Удаляем из строки информацию о записи */
        str = trim_info(str);
        /* Загружаем запись в объект 'Record' */
        rec.load(str);
    }

    return 0;
}

/***************************************************************************/

[elenSV]

вот это решение:

.h 
#ifndef __MAGNITOFON_H__
#define __MAGNITOFON_H__

#include <iostream>
#include <fstream>

/***************************************************************************/
/* Объект записи. Пустышка. */
class Record {
public:
	Record() {}
	/* Возвращает продолжительность записи в минутах. Макс = 240.
		(создан для симуляции)
	 */
	int length() const;
};

/***************************************************************************/
/* Интерфейс для производных объектов.
	Абстрактный. Для симуляции видео кассеты, и ДВД диска.
 */
class IMedia {
public:
	/* Деструктор */
	virtual ~IMedia() {}
	/* Перемотка в перёд */
	virtual void rew_begin();
	/* Добавить запись */
	virtual void add_record(const Record& rhs);
protected:
	/* Сумарная продолжительность кассеты. (симуляция) */
	int rew_range;
};

/***************************************************************************/

/* Интерфейс для производных объектов.
	Абстрактный. Для симуляции видео магнитофона, и ДВД плеера.
 */
class IRecorder {
public:
	/* Деструктор */
	virtual ~IRecorder() {}
	/* Загрузка кассеты */
	virtual void load() = 0;
	/* Выброс кассеты */
	virtual void eject() = 0;
	/* Воспроизведение */
	virtual void play() = 0;
	/* Стоп */
	virtual void stop() = 0;
	/* Перемотка */
	virtual void rew(int) = 0;
	/* Указатель на абстрактный объект которым может владеть */
	IMedia *media;
};

/***************************************************************************/
/* Видео кассета */
class vhs_caset: public IMedia {
public:
	/* Конструктор */
	vhs_caset() { rew_range = 0; }
	/* Деструктор */
	~vhs_caset() {}
};
/* ДВД диск */
class dvd_caset: public IMedia {
public:
	/* Конструктор */
	dvd_caset() { rew_range = 0; }
	/* Деструктор */
	~dvd_caset() {}
};

/***************************************************************************/
/* Видео магнитофон */
class vhs_recorder: public IRecorder{
public:
	/* Конструктор */
	vhs_recorder();
	/* Деструктор */
	~vhs_recorder();
	/* Загрузка кассеты */
	void load();
	/* Выброс кассеты */
	void eject();
	/* Воспроизведение */
	void play();
	/* Стоп */
	void stop();
	/* Перемотка */
	void rew(int pos);
};

/***************************************************************************/
/* ДВД плеер*/
class dvd_recorder: public IRecorder{
public:
	/* Конструктор */
	dvd_recorder();
	/* Деструктор */
	~dvd_recorder();
	/* Загрузка кассеты */
	void load();
	/* Выброс кассеты */
	void eject();
	/* Воспроизведение */
	void play();
	/* Стоп */
	void stop();
	/* Перемотка */
	void rew(int pos);
};

/***************************************************************************/
/cpp 

#endif // __MAGNITOFON_H__
#include "magnitofon.h"

/* Возвращает продолжительность записи в минутах. Макс = 240 */
int Record::length() const {
	return rand() % 240;
}

virtual void IMedia::rew_begin() {
	rew_range = 0;
}

virtual void IMedia::add_record(const Record& rhs) {
	rew_range += rhs.length();
}

vhs_recorder::vhs_recorder() {
	media = new vhs_caset;
}

vhs_recorder::~vhs_recorder() {
	delete media;
}

void vhs_recorder::load() {
	std::cout << "vhs load\n";
}

void vhs_recorder::eject() {
	std::cout << "vhs eject\n";
}

void vhs_recorder::play() {
	std::cout << "vhs play\n";
}

void vhs_recorder::rew(int pos) {
	std::cout << "vhs rew: " << pos << std::endl;
}

void vhs_recorder::stop() {
	std::cout << "vhs stop\n";
}

dvd_recorder::dvd_recorder() {
	media = new dvd_caset;
}

dvd_recorder::~dvd_recorder() {
	delete media;
}

void dvd_recorder::load() {
	std::cout << "dvd load\n";
}

void dvd_recorder::eject() {
	std::cout << "dvd eject\n";
}

void dvd_recorder::play() {
	std::cout << "dvd play\n";
}

void dvd_recorder::rew(int pos) {
	std::cout << "dvd rew: " << pos << std::endl;
}

void dvd_recorder::stop() {
	std::cout << "dvd stop\n";
}
Main.cpp
#include "magnitofon.h"

/***************************************************************************/

int main(int argc, char** argv) {

	dvd_recorder dvd;
	vhs_recorder vhs;
	IRecorder *recorder;

	recorder = &dvd;
	recorder->load();
	recorder->play();
	recorder->rew(12);
	recorder->rew(-10);
	recorder->stop();
	recorder->eject();

	recorder = &vhs;
	recorder->load();
	recorder->play();
	recorder->rew(42);
	recorder->rew(-30);
	recorder->stop();
	recorder->eject();

	return 0;
}

/***************************************************************************/

удовлетворяет условию:
рассмотреть модификацию магнитофона, который запоминает у себя в памяти все выполняемые пользователем действия. Считается что видиокассета обладает уникальным числовым идентификатором.