Geum.ru

* законченный учебник и руководство по языку

Вид материалаЗакон
Подобный материал:
1   ...   18   19   20   21   22   23   24   25   ...   34
может выглядеть следующим

образом:


class streambuf { // управление буфером потока

protected:

char* base; // начало буфера

char* pptr; // следующий свободный байт

char* gptr; // следующий заполненный байт

char* eptr; // один из указателей на конец буфера

char alloc; // буфер, размещенный с помощью "new"

//...

// Опустошить буфер:

// Вернуть EOF при ошибке, 0 - удача

virtual int overflow(int c = EOF);


// Заполнить буфер:

// Вернуть EOF в случае ошибки или конца входного потока,

// иначе вернуть очередной символ

virtual int underflow();

//...

public:

streambuf();

streambuf(char* p, int l);

virtual ~streambuf();


int snextc() // получить очередной символ

{

return (++gptr==pptr) ? underflow() : *gptr&0377;

}

int allocate(); // отвести память под буфер

//...

};


Подробности реализации класса streambuf приведены здесь только для

полноты представления. Не предполагается, что есть общедоступные

реализации, использующие именно эти имена. Обратите внимание на

определенные здесь указатели, управляющие буфером; с их помощью

простые посимвольные операции с потоком можно определить максимально

эффективно (и причем однократно) как функции-подстановки. Только

функции overflow() и underflow() требует своей реализации для каждого

алгоритма буферизации, например:


class filebuf : public streambuf {

protected:

int fd; // дескриптор файла

char opened; // признак открытия файла

public:

filebuf() { opened = 0; }

filebuf(int nfd, char* p, int l)

: streambuf(p,l) { /* ... */ }

~filebuf() { close(); }


int overflow(int c=EOF);

int underflow();


filebuf* open(char *name, ios::open_mode om);

int close() { /* ... */ }

//...

};

int filebuf::underflow() // заполнить буфер из "fd"

{

if (!opened || allocate()==EOF) return EOF;


int count = read(fd, base, eptr-base);

if (count < 1) return EOF;


gptr = base;

pptr = base + count;

return *gptr & 0377; // &0377 предотвращает размножение знака

}


За дальнейшими подробностями обратитесь к руководству по реализации

класса streambuf.


10.6 Ввод-вывод в С


Поскольку текст программ на С и на С++ часто путают, то путают иногда

и потоковый ввод-вывод С++ и функции ввода-вывода семейства printf для

языка С. Далее, т.к. С-функции можно вызывать из программы на С++, то

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

По этой причине здесь будет дана основа функций ввода-вывода С.

Обычно операции ввода-вывода на С и на С++ могут идти по очереди на

уровне строк. Перемешивание их на уровне посимвольного ввода-вывода

возможно для некоторых реализаций, но такая программа может быть

непереносимой. Некоторые реализации потоковой библиотеки С++ при допущении

ввода-вывода на С требуют вызова статической функции-члена

ios::sync_with_stdio().

В общем, потоковые функции вывода имеют перед стандартной

функцией С printf() то преимущество, что потоковые функции обладают

определенной типовой надежностью и единообразно определяют вывод

объектов предопределенного и пользовательского типов.

Основная функция вывода С есть


int printf(const char* format, ...)


и она выводит произвольную последовательность параметров в формате,

задаваемом строкой форматирования format. Строка форматирования состоит

из объектов двух типов: простые символы, которые просто копируются в

выходной поток, и спецификации преобразований, каждая из которых

преобразует и печатает очередной параметр. Каждая спецификация

преобразования начинается с символа %, например


printf("there were %d members present.",no_of_members);


Здесь %d указывает, что no_of_members следует считать целым и печатать

как соответствующую последовательность десятичных цифр. Если

no_of_members==127, то будет напечатано


there were 127 members present.


Набор спецификаций преобразований достаточно большой и обеспечивает

большую гибкость печати. За символом % может следовать:

- необязательный знак минус, задающий выравнивание влево в указанном

поле для преобразованного значения;

d необязательная строка цифр, задающая ширину поля; если в

преобразованном значении меньше символов, чем ширина строки, то оно

дополнится до ширины поля пробелами слева (или справа, если дана

спецификация выравнивания влево); если строка ширины поля начинается

с нуля, то дополнение будет проводится нулями, а не пробелами;

. необязательный символ точка служит для отделения ширины поля от

последующей строки цифр;

d необязательная строка цифр, задающая точность, которая определяет

число цифр после десятичной точки для значений в спецификациях

e или f, или же задает максимальное число печатаемых символов

строки;

* для задания ширины поля или точности может использоваться * вместо

строки цифр. В этом случае должен быть параметр целого типа, который

содержит значение ширины поля или точности;

h необязательный символ h указывает, что последующая спецификация d,

o, x или u относится к параметру типа короткое целое;

l необязательный символ l указывает, что последующая спецификация d,

o, x или u относится к параметру типа длинное целое;

% обозначает, что нужно напечатать сам символ %; параметр не нужен;

c символ, указывающий тип требуемого преобразования. Символы

преобразования и их смысл следующие:

d Целый параметр выдается в десятичной записи;

o Целый параметр выдается в восьмеричной записи;

x Целый параметр выдается в шестнадцатеричной записи;

f Вещественный или с двойной точностью параметр выдается в

десятичной записи вида [-]ddd.ddd, где число цифр после

точки равно спецификации точности для параметра. Если точность

не задана, печатается шесть цифр; если явно задана точность 0,

точка и цифры после нее не печатаются;

e Вещественный или с двойной точностью параметр выдается в

десятичной записи вида [-]d.ddde+dd; здесь одна цифра перед

точкой, а число цифр после точки равно спецификации точности

для параметра; если она не задана печатается шесть цифр;

g Вещественный или с двойной точностью параметр печатается по той

спецификации d, f или e, которая дает большую точность при

меньшей ширине поля;

c Символьный параметр печатается. Нулевые символы игнорируются;

s Параметр считается строкой (символьный указатель), и печатаются

символы из строки до нулевого символа или до достижения числа

символов, равного спецификации точности; но, если точность

равна 0 или не указана, печатаются все символы до нулевого;

p Параметр считается указателем и его вид на печати зависит от

реализации;

u Беззнаковый целый параметр печатается в десятичной записи.

Несуществующее поле или поле с шириной, меньшей реальной, приведет

к усечению поля. Дополнение пробелами происходит, если только

спецификация ширины поля больше реальной ширины.

Ниже приведен более сложный пример:


char* src_file_name;

int line;

char* line_format = "\n#line %d \"%s\"\n";

main()

{

line = 13;

src_file_name = "C++/main.c";


printf("int a;\n");

printf(line_format,line,src_file_name);

printf("int b;\n");

}


в котором печатается


int a;


#line 13 "C++/main.c"

int b;


Использование printf() ненадежно в том смысле, что нет никакого

контроля типов. Так, ниже приведен известный способ получения

неожиданного результата - печати мусорного значения или чего похуже:


char x;

// ...

printf("bad input char: %s",x);


Однако, эти функции обеспечивают большую гибкость и знакомы

программирующим на С.

Как обычно, getchar() позволяет знакомым способом читать символы из

входного потока:


int i;:

while ((i=getchar())!=EOF) { // символьный ввод C

// используем i

}


Обратите внимание: чтобы было законным сравнение с величиной EOF типа

int при проверке на конец файла, результат getchar() надо помещать в

переменную типа int, а не char.

За подробностями о вводе-выводе на С отсылаем к вашему руководству

по С или книге Кернигана и Ритчи "Язык программирования С".


10.7 Упражнения


1. (*1.5) Читая файл вещественных чисел, составлять из пар прочитанных

чисел комплексные числа, записать комплексные числа.

2. (*1.5) Определить тип name_and_address (тип_и_адрес). Определить для

него << и >>. Написать программу копирования объектов потока

name_and_address.

3. (*2) Разработать несколько функций для запроса и чтения данных

разных типов. Предложения: целое, вещественное число, имя файла,

почтовый адрес, дата, личная информация, и т.п. Попытайтесь сделать

их устойчивыми к ошибкам.

4. (*1.5) Напишите программу, которая печатает: (1) строчные буквы,

(2) все буквы, (3) все буквы и цифры, (4) все символы, входящие в

идентификатор в вашей версии С++, (5) все знаки пунктуации,

(6) целые значения всех управляющих символов, (7) все обобщенные

пробелы, (8) целые значения всех обобщенных пробелов, и, наконец,

(9) все изображаемые символы.

5. (*4) Реализуйте стандартную библиотеку ввода-вывода С ()

с помощью стандартной библиотеки ввода-вывода С++ ().

6. (*4) Реализуйте стандартную библиотеку ввода-вывода С++

() с помощью стандартной библиотеки ввода-вывода С

().

7. (*4) Реализуйте библиотеки С и С++ так, чтобы их можно было

использовать одновременно.

8. (*2) Реализуйте класс, для которого операция [] перегружена так,

чтобы обеспечить произвольное чтение символов из файла.

9. (*3) Повторите упражнение 8, но добейтесь, чтобы операция [] была

применима для чтения и для записи. Подсказка: пусть [] возвращает

объект "дескриптор типа", для которого присваивание означает:

присвоить через дескриптор файлу, а неявное приведение к типу char

означает чтение файла по дескриптору.

10.(*2) Повторите упражнение 9, позволяя операции [] индексировать

объекты произвольных типов, а не только символы.

11.(*3.5) Продумайте и реализуйте операцию форматного ввода.

Используйте для задания формата строку спецификаций как в printf().

Должна быть возможность попыток применения нескольких спецификаций для

одного ввода, чтобы найти требуемый формат. Класс форматного ввода

должен быть производным класса istream.

12.(*4) Придумайте (и реализуйте) лучшие форматы ввода.

13.(**2) Определите для вывода манипулятор based с двумя параметрами:

система счисления и целое значение, и печатайте целое в

представлении, определяемом системой счисления. Например, based(2,9)

напечатает 1001.

14.(**2) Напишите "миниатюрную" систему ввода-вывода, которая реализует

классы istream, ostream, ifstream, ofstream и предоставляет функции,

такие как operator<<() и operator>>() для целых, и операции, такие

как open() и close() для файлов. Используйте исключительные

ситуации, а не переменные состояния, для сообщения об ошибках.

15.(**2) Напишите манипулятор, который включает и отключает эхо

символа.


* ПРОЕКТИРОВАНИЕ И РАЗВИТИЕ


"Серебряной пули не существует."

- Ф. Брукс


В этой главе обсуждаются подходы к разработке программного обеспечения.

Обсуждение затрагивает как технические, так и социологические аспекты

процесса развития программного обеспечения. Программа рассматривается

как модель реальности, в которой каждый класс представляет определенное

понятие. Ключевая задача проектирования состоит в определении доступной

и защищенной частей интерфейса класса, исходя из которых определяются

различные части программы. Определение этих интерфейсов есть

итеративный процесс, обычно требующий экспериментирования. Упор

делается на важной роли проектирования и организационных факторов

в процессе развития программного обеспечения.


11.1 Введение


Создание любой нетривиальной программной системы - сложная и часто

выматывающая задача. Даже для отдельного программиста собственно запись

операторов программы есть только часть всей работы. Обычно анализ всей

задачи, проектирование программы в целом, документация, тестирование,

сопровождение и управление всем этим затмевает задачу написания и

отладки отдельных частей программы. Конечно, можно все эти виды

деятельности обозначить как "программирование" и затем вполне

обоснованно утверждать: "Я не проектирую, я только программирую".

Но как бы не назывались отдельные виды деятельности, бывает иногда важно

сосредоточиться на них по отдельности, так же как иногда бывает важно

рассмотреть весь процесс в целом. Стремясь поскорее довести систему

до поставки, нельзя упускать из вида ни детали, ни картину в целом,

хотя довольно часто происходит именно это.

Эта глава сосредоточена на тех частях процесса развития программы,

которые не связаны с написанием и отладкой отдельных программных

фрагментов. Обсуждение здесь менее точное и детальное, чем во всех

остальных частях книги, где рассматриваются конкретные черты языка

или определенные приемы программирования. Это неизбежно, поскольку нет

готовых рецептов создания хороших программ. Детальные рецепты "как"

могут существовать только для определенных, хорошо разработанных областей

применения, но не для достаточно широких областей приложения. В

программировании не существует заменителей разума, опыта и вкуса.

Следовательно, в этой главе вы найдете только общие рекомендации,

альтернативные подходы и осторожные выводы.

Сложность данной тематики связана с абстрактной природой программ

и тем фактом, что приемы, применимые для небольших проектов (скажем,

программа в 10000 строк, созданная одним или двумя людьми), не

распространяются на средние или большие проекты. По этой причине иногда

мы приводим примеры из менее абстрактных инженерных дисциплин, а не

только из программирования. Не преминем напомнить, что "доказательство по

аналогии" является мошенничеством, и аналогии служат здесь только в

качестве примера. Понятия проектирования, формулируемые

с помощью определенных конструкций С++, и поясняемые примерами, мы

будем обсуждать в главах 12 и 13. Предложенные в этой главе рекомендации,

отражаются как в самом языке С++, так и в решении конкретных программных

задач по всей книге.

Снова напомним, что в силу чрезвычайного разнообразия областей

применения, программистов и среды, в которой развивается программная

система, нельзя ожидать, что каждый вывод, сделанный здесь, будет

прямо применим для вашей задачи. Эти выводы применимы

во многих самых разных случаях, но их нельзя считать универсальными

законами. Смотрите на них со здоровой долей скептицизма.

Язык С++ можно просто использовать как лучший вариант С. Однако,

поступая так, мы не используем наиболее мощные возможности С++ и

определенные приемы программирования на нем, так что реализуем лишь

малую долю потенциальных достоинств С++. В этой главе излагается такой

подход к проектированию, который позволяет полностью использовать

возможности абстрактных данных и средства объектного программирования С++.

Такой подход обычно называют объектно-ориентированным проектированием.

В главе 12 обсуждаются основные приемы программирования на С++, там же

содержится предостережение от сомнительных идей, что есть только один

"правильный" способ использования С++, и что для получения

максимального выигрыша следует всякое средство С++

применять в любой программе ($$12.1).

Укажем некоторые основные принципы, рассматриваемые в этой главе:

- из всех вопросов, связанных с процессом развития программного

обеспечения, самый важный - четко сознавать, что собственно вы

пытаетесь создать.

- Успешный процесс развития программного обеспечения - это дли-

тельный процесс.

- Системы, которые мы создаем, стремятся к пределу сложности

по отношению как к самим создателям, так и используемым средствам.

- Эксперимент является необходимой частью проекта для разработки всех

нетривиальных программных систем.

- Проектирование и программирование - это итеративные процессы.

- Различные стадии проекта программного обеспечения, такие как:

проектирование, программирование и тестирование - невозможно строго

разделить.

- Проектирование и программирование нельзя рассматривать в отрыве от

вопросов управления этими видами деятельности.

Недооценить любой из этих принципов очень легко, но обычно накладно.

В то же время трудно воплотить эти абстрактные идеи на практике.

Здесь необходим определенный опыт. Подобно построению лодки, езде на

велосипеде или программированию проектирование - это искусство, которым

нельзя овладеть только с помощью теоретических занятий.

Может быть все эти емкие принципы можно сжать в один:

проектирование и программирование - виды человеческой деятельности;

забудь про это - и все пропало.

Слишком часто мы забываем про это и рассматриваем процесс развития

программного обеспечения просто как "последовательность хорошо

определенных шагов, на каждом из которых по заданным правилам

производятся некоторые действия над входными данными, чтобы получить

требуемый результат". Сам стиль предыдущего предложения выдает

присутствие человеческой природы!

Эта глава относится к проектам, которые можно считать честолюбивыми,

если учитывать ресурсы и опыт людей, создающих систему. Похоже, это в

природе как индивидуума, так и организации - браться за проекты на

пределе своих возможностей. Если задача не содержит определенный вызов,

нет смысла уделять особое внимание ее проектированию. Такие задачи

решаются в рамках уже устоявшейся структуры, которую не следует разрушать.

Только если замахиваются на что-то амбициозное, появляется потребность

в новых, более мощных средствах и приемах. Кроме того, существует

тенденция у тех, кто "знает как делать", перепоручать проект новичкам,

которые не имеют таких знаний.

Не существует "единственного правильного способа" для

проектирования и создания всей системы. Я бы считал веру в "единственный

правильный способ" детской болезнью, если бы этой болезнью слишком

часто не заболевали и опытные программисты. Напомним еще раз: только

по той причине, что прием успешно использовался в течение года для

одного проекта, не следует, что он без всяких изменений окажется

столь же полезен для другого человека или другой задачи. Всегда важно

не иметь предубеждений.

Убеждение в том, что нет единственно верного решения, пронизывает

весь проект языка С++, и, в основном, по этой причине в первом издании

книги не было раздела, посвященного проектированию: я не хотел, чтобы

его рассматривали как "манифест" моих личных симпатий. По этой же

причине здесь, как и в главах 12 и 13, нет четко определенного взгляда на

процесс развития программного обеспечения, скорее здесь просто дается

обсуждение определенного круга, часто возникающих, вопросов и

предлагаются некоторые решения, оказавшиеся полезными в определенных