Вот это обкатал на 6-м билдере. К сожалению C++ Builder - это не компилятор C++
Код: Выделить всё
#pragma hdrstop
//------------------------------
#include <iostream>
#include <string>
#include <stdexcept>
using namespace std;
/*-----------------23.11.2008 22:01-----------------
* Класс Book - доступ к видимым полям, ввод-вывод
* --------------------------------------------------*/
class Book
{
public:
Book(const string& author1,
const string& title1,
const string& genre1,
unsigned int year1);
Book(); // для стандартных контейнеров книг
// установка свойств
void setAuthor(const string& author1) {_author = _checkLength(author1);}
void setTitle(const string& title1) {_title = _checkLength(title1); }
void setGenre(const string& genre1) {_genre = _checkLength(genre1); }
void setYear(unsigned int year1) {_year = _checkYear (year1); }
// чтение свойств
const string& author() const throw() { return _author; }
const string& title() const throw() { return _title; }
const string& genre() const throw() { return _genre; }
unsigned int year() const throw() { return _year; }
// ввод-вывод
friend ostream& operator<<(ostream&, const Book&);
friend istream& operator>>(istream&, Book&);
// разделитель полей для ввода-вывода
static const char _io_field_delimiter;
// ввод-вывод для пользователя.
void human_read_unsafe();
void human_write();
private:
string _author;
string _title;
string _genre;
unsigned int _year;
static const string& _checkLength(const string& str);
static const unsigned& _checkYear(const unsigned&);
};
/*-----------------23.11.2008 22:01-----------------
* Функции ввода-вывода не роботу
* --------------------------------------------------*/
void Book::human_write()
{
// просто в красивом виде
cout << "Author:." << _author << "\n"
<< "Title:.." << _title << "\n"
<< "Genre:.." << _genre << "\n"
<< "Year:..." << _year << "\n\n";
}
void Book::human_read_unsafe()
{
// читаем, проверяем на ошибки, но пишем сразу в книгу,
// то есть портим сам объект, поэтому unsafe.
// А вот если потом скопировать результат в хранилище,
// получается вполне безопасно
cout << "Type in book properties:\n";
// ws(istream&) - пропускает пробелы (enter тоже) между словами
// getline(istream&, string&, int symbol='\n') - читает строчку до появления символа symbol
cout << "Author:.";
getline(ws(cin), _author, '\n');
_checkLength(_author);
cout << "Title:..";
getline(ws(cin), _title, '\n');
_checkLength(_title );
cout << "Genre:..";
getline(ws(cin), _genre, '\n');
_checkLength(_genre );
cout << "Year:...";
cin >> _year;
_checkYear (_year );
cout << "thank you!\n\n";
}
/*-----------------23.11.2008 22:02-----------------
* и как это всё делается.
* --------------------------------------------------*/
// прикольно выглядит, если поставить = '|'
//const char Book::_io_field_delimiter = '|';
const char Book::_io_field_delimiter = '\t';
Book::Book() :
_author ("Unknown Author"),
_title ("Unknown Title"),
_genre ("Unknown Genre"),
_year ()
{
// не хочется, но надо...
}
Book::Book(const string& author1, const string& title1,
const string& genre1, unsigned int year1) :
_author (_checkLength(author1)),
_title (_checkLength(title1 )),
_genre (_checkLength(genre1 )),
_year (_checkYear (year1 ))
{
// один из подходов последовательной проверки при построении класса.
// неправильного класса не получится.
}
const string& Book::_checkLength(const string& str)
{
// вынесли отдельно, чтоб съэкономить код
if (str.empty() || 255<=str.size())
{
throw out_of_range(
"Book::checkLength "
"a string which is empty or greater 255 chars is not permitted");
}
return str;
}
const unsigned& Book::_checkYear(const unsigned& year)
{
if (2008 <= year)
{
throw out_of_range(
"Book::checkYear "
"year>=2008 is not permitted");
}
return year;
}
ostream& operator<<(ostream& out, const Book& book)
{
// вывод в таблицу, разделённую табуляторами и переводом строки
// после вывод буфер не сбрасываем.
return
out << book._author << Book::_io_field_delimiter
<< book._title << Book::_io_field_delimiter
<< book._genre << Book::_io_field_delimiter
<< book._year << "\n";
}
istream& operator>>(istream& in, Book& book)
{
// немного подумав обрал коснтруктор из потока.
// потому что при чтении итератором istream_iterator<Book> будет всё равно
// использоваться копия Book, которая находятся в самом итераторе.
// использование копирования позволяет сохранить объект в целости и сохранности
// в случае исключения. Например если при чтении любого поля возникнет ошибка,
// то следующий код оставит книгу b1 без изменений:
// Book b1(...);
// b1.setAuthorBook(...);
// ...
// try
// {
// b1 = Book(cin); // произошла ошибка при чтении года!!!
// }
// catch(runtime_error& err)
// {
// clog << "error: " << err.what() << endl;
// }
if (getline(ws(in), book._author, Book::_io_field_delimiter) &&
getline(ws(in), book._title, Book::_io_field_delimiter) &&
getline(ws(in), book._genre, Book::_io_field_delimiter) &&
(in >> book._year))
{
// проверяем только в случае, если считалось полностью.
// если не полностью (поток кончился), то in.good(),
// он же `operator istream::bool()` выдаст false
Book::_checkLength(book._author);
Book::_checkLength(book._title );
Book::_checkLength(book._genre );
Book::_checkYear (book._year );
}
// чтобы отловить случаи неполного чтения, нужно установить флаг:
// in.exceptions(ios::badbit|ios::failbit);
// но это мешает чтению из потока до его конца (в конце выйдет исключение)
return in;
}
/*-----------------23.11.2008 22:14-----------------
* Демонстрация возможностей
* --------------------------------------------------*/
#include <fstream>
#include <iterator>
#include <list>
#include <map>
// пример использования функционального класса
// title_predicate(book) возвращает true если введённое название книги совпадает
// иначе false
// используется в Job::cmd_erase(), но сюда вынесено, потому что борландовский
// компилятор умеет подставлять в шаблоны только классы, видимые снаружи
// (а не в текущем блоке). Дебильная урезка по-моему.
struct title_predicate
{
string _title1;
title_predicate()
{
cout << "Enter title to erase: ";
getline(ws(cin), _title1);
}
bool operator()(const Book& book)
{
return book.title()==_title1;
}
};
void main()
{
// прикольный способ создавать функции в теле функции (как в паскале) - если кто не знал ;-)
// но, к сожалению, длинный код может запутать, пожтому при возможности лучше выносить наружу.
class Job
{
private:
string _cmd;
list<Book> _books;
// да, в C++ писанины много...
// void (Job::*)() - так выглядит тип "указатель на функцию void Job::function()"
// борланд такую конструкцию не воспринимает :( ему обязательно надо typedef
// и вообще у него из-за ввода __closure началась путаница с указателями на методы
// я привёл к стандартному сишному вызову cdecl
typedef void (cdecl Job::*handler_type)();
// без этого тоже не хотел собирать почему-то.
// а всё глюкавый сборщик шаблонов виноват...
typedef map<string,pair<handler_type, const char*> > handler_map_type;
handler_map_type _handlers;
bool enter_cmd()
{
cout << "Enter what to do (\"exit\" to quit or \"help\" for more info): ";
_cmd.clear();
return (cin >> _cmd) && _cmd!="exit";
}
public:
Job()
{
// борландовский компилятор не по правилам делает порядок подстановки типов аргументов в шаблон
// поэтому приходится указывать тип аргумента явно.
// Указатель на функцию тоже почему-то стал браться с амперсандом, хотя по правилам - без...
_handlers["help" ] = make_pair(static_cast<handler_type>(&Job::cmd_help), "brief about instructions");
_handlers["add" ] = make_pair(static_cast<handler_type>(&Job::cmd_add), "add book to storage");
_handlers["clear" ] = make_pair(static_cast<handler_type>(&Job::cmd_clear), "clear storage");
_handlers["save" ] = make_pair(static_cast<handler_type>(&Job::cmd_save), "save storage to file \"storage.txt\"");
_handlers["load" ] = make_pair(static_cast<handler_type>(&Job::cmd_load), "load storage from file \"storage.txt\"");
_handlers["erase" ] = make_pair(static_cast<handler_type>(&Job::cmd_erase), "erase one book from storage");
_handlers["list" ] = make_pair(static_cast<handler_type>(&Job::cmd_list), "display storage content");
}
// так класс превращается в функциональный объект.
// Job job1;
// ...
// job1();
void cdecl operator()()
{
// полезный приём для избежания break внутри цикла. Облегчает чтение кода
// описание функции в теле класса даёт указание раскрывать её как inline
while (enter_cmd())
{
handler_map_type::iterator iter = _handlers.find(_cmd);
// оператор map<...>::operator[] добавляет элемент, если он не найден в списке,
// а нам этого совсем не надо. Поэтому используем поиск по ключу
if (iter!=_handlers.end())
{
try
{
// програмное исключение exception не приводит к неработоспособности этого кода,
// поэтому останавливаем их обработку здесь с чистым сердцем.
// часто люди злоупотребляют блоками try..catch и оставляют работать
// повреждённую программу.
(this->*iter->second.first)();
}
catch(exception& e)
{
clog << "runtime error: " << e.what() << endl;
}
}
else
{
cout << "Unexpected command! Type \"help\" for list of avaible commands\n";
}
}
cout << "Bye!";
}
// далее пошли наши команды
void cdecl cmd_help()
{
// прикольно выглядит:
// cout.fill('.');
cout.flags(ios::left);
// map<> держит ключи в сортированном виде, поэтому вывод будет в
// алфавитном порядке
for (handler_map_type::iterator
first=_handlers.begin(), last=_handlers.end(); first!=last; ++first)
{
cout.width(10);
cout << first->first << first->second.second << "\n";
}
}
void cdecl cmd_list()
{
// вот так просто теперь выглядит вывод
// ostream_iterator<> использует оператор << для вывода в поток
copy(_books.begin(), _books.end(), ostream_iterator<Book,char>(cout));
}
void cdecl cmd_add()
{
// небезопасно читаем новую книгу
// и безопасно добавляем в контейнер
Book new_book;
new_book.human_read_unsafe();
_books.push_back(new_book);
}
void cdecl cmd_clear()
{
_books.clear();
}
void cmd_save()
{
// вот так просто теперь выглядит сохранение
ofstream out("storage.txt");
copy(_books.begin(), _books.end(), ostream_iterator<Book,char>(out));
}
void cdecl cmd_load()
{
// загружаем в отдельный список - безопасно при исключениях
list<Book> new_list;
ifstream in("storage.txt");
copy(istream_iterator<Book,char>(in), istream_iterator<Book,char>(), back_inserter(new_list));
if (!in.eof())
{
in.clear(ios::goodbit);
string error_word;
getline(in, error_word);
clog << "Job::cmd_load parser error before: " << error_word << endl;
throw runtime_error("Job::cmd_load parser error");
}
// меняем местами содержимое списков. При чистке стека старый список удалится.
new_list.swap(_books);
}
void cdecl cmd_erase()
{
// remove_if перемещает в конец списка все элементы, которые удовлетворяют условию.
// если до выполнения erase произойдёт исключение, книги не потеряются. Но правда
// изменится порядок.
_books.remove_if<title_predicate>(/*это вызов конструктора*/ title_predicate());
}
};
// вот теперь настал тот момент, когда непонятно, что кончилось и что началось,
// если помещать описание класса внутрь функции.
Job()();
}
//------------------------------
Если переделать, то ошибки пропадут 
Сейчас напишу самый "доведённый до ума" вариант:
Только у меня опять ошибки, 26 штук... Компилирую Borland C++ Builder 6.0. 
