Глава 3. Справочная информация по программированию

Справочная информация по программированию

Примечание: настоящий раздел представляет собой сводный обзор основных правил, обычно, используемых для написания программы, и обзор некоторых тем, часто необходимых в качестве справочного материала. Более строгую информацию можно найти в руководстве по Borland C++ 4.0 или в быстрой интерактивной помощи Help. В основном информация этого раздела применима и для Турбо С++ и Borland C++ 4.0.

Версия 4.0 Borland C++ поможет вам создавать 16- и 32-битовые приложения для операционных систем Chicago и Windows NT. Это очень гибкая и открытая среда разработчика, обеспечивающая простое взаимодействие с ней. Интегрированная среда Borland C++ обладает по-настоящему открытой архитектурой и имеет большой набор инструментов визуального программирования.

Такие новые возможности, как обработка исключительных ситуаций, интегрированный отладчик графического пользовательского интерфейса (GUI), клавиатурная эмуляция и собственный текстовый редактор Borland (Brief) делают версию более гибкой. В Borland C++ реализован очень гибкий доступ к утилитам. В частности, эта среда позволяет программистам приспособить под свои нужды панель инструментальных средств.

В Borland C++ 4.0 предлагаются графические меню, подобные используемым в Quattro Pro и Paradox. При нажатии правой кнопки "мыши" появляется панель с другим набором инструментальных средств программирования.

В исключительных ситуациях версия 4.0 перехватывает и распознает ошибки, позволяя программистам аккуратно выходить из любого затруднения. Новая версия включает в себя Object Windows 2.0 - объектно-ориентированную библиотеку, поддерживающую 32-разрядное программирование и перенос приложений между 16- и 32-разрядным режимом Windows.

Работа компилятора Borland C++ начинается с просмотра текста программы препроцессором, который ищет в нем специальные директивы. Например, директива #include <включаемый_файл> добавляет (или включает) в программу перед фазой компиляции содержимое файла <включаемый_файл>. Препроцессор также выполняет расширение любых обнаруженных в программах или файлах включений макрокоманд.

Ниже, в справочных таблицах, даются наиболее важные сведения по конкретной реализации С++ фирмы Borland. Начинаются они с перечня ключевых слов, которые не должны использоваться в качестве обычных имен идентификаторов.

Ключевые слова Borland C++

__asm	__es	__interrupt	short
_asm	_es	_interrupt	signed
asm	__export	interrupt	sizeof
auto	_export	__loadds	__ss
break	extern	_loadds	_ss
case	__far	long	static
catch	_far	__near	__stdcall
__cdecl	far	_near	_stdcall
_cdecl	__fastcall	near	struct
cdecl	_fastcall	new	switch
char	__finally	operator	template
class	float	__pascal	this
const	for	_pascal	__thread
continue	friend	pascal	throw
__cs	goto	private	__try
_cs	__huge	protected	try
default	_huge	public	typedef
delete	huge	register	union
do	if	return	unsigned
double	__import	__rtti	virtual
__ds	_import	__saveregs	void
_ds	import	_saveregs	volatile
else	inline	__seg	while
enum	int	_seg

Расширения Borland C++ по сравнению с Си стандарта ANSI

__asm	__except	__import (2)	pascal
_asm	__export	_import (2)	__saveregs (1)
__cdecl	__far (1)	_interrupt (1)	_saveregs (1)
_cdecl	_far (1)	interrupt (1)	__seg (1)
cdecl	far (1)	__loadds (1)	_seg (1)
__cs (1)	__fastcall	_loadds (1)	___ss (1)
_cs (1)	_fastcall	__near (1)	__ss (1)
__ds (1)	__finally	_near (1)	__rtti
_ds (1)	__huge (1)	near (1)	__thread (2)
__es (1)	_huge (1)	__pascal	__try
_es (1)	huge (1)	_pascal

(1) - доступны только для 16-разрядных компиляторов
(2) - доступны только для 32-разрядных компиляторов

Ключевые слова, специфические для C++

asm	friend	protected	try
catch	inline	public	virtual
class	new	template	__rtti
delete	operator	this
private	throw

Регистровые псевдопеременные Borland C++

_AH	_CL	_EAX (*)	_ESP
_AL	_CS	_EBP (*)	_FLAGS
_AX	_CX	_EBX (*)	_FS
_BH	_DH	_ECX (*)	_GS (*)
_BL	_DI	_EDI (*)	_SI
_BP	_DL	_EDX (*)	_SP
_BX	_DS	_ES	_SS
_CH	_DX	_ESI (*)

(*) - для 32-разрядного компилятора эти псевдопеременные всегда доступны. 16-разрядный компилятор может их использовать только при указании параметра генерации инструкций 80386.

Идентификаторы

Характерным для Borland C++ и для других реализаций языка является учет регистра букв в идентификаторах. Последние могут содержать буквы от A до Z и от a до z, символ подчеркивания (_) и цифры от 0 до 9 и должны начинаться с буквы. Константы

Константами называются лексемы, представляющие собой фиксированные числовые или символьные значения. Borland C++ поддерживает четыре класса констант: константы с плавающей точкой, целочисленные константы, константы перечислимого типа и символьные константы (включая строковые).

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

Символьные константы записываются одним или более символами, заключенными в одинарные кавычки, например 'F', '=', '\n'.

Описание операций

Операциями называются лексемы, вызывающие некоторые вычисления с переменными и прочими объектами, указанными в выражении. Borland C++ имеет особенно богатый набор операций, включающий в себя помимо обычных арифметических и логических операций средства манипуляции с данными на битовом уровне, доступа к элементам структур и объединений, а также операции с указателями (ссылка и разыменование).

Унарные операции

Операция	Смысл
&	Операция адресации
*	Операция обращения по ссылке
+	Унарный плюс
-	Унарный минус
~	Поразрядное дополнение (дополнение до единицы)
!	Логическое отрицание
++	Префикс: прединкрементация; Постфикс: постинкрементация
--	Префикс: преддекрементация; Постфикс: постдекрементация

Бинарные операции

Операция		Смысл
Операции типа сложения	+	Бинарный плюс (сложение)
Операции типа сложения	-	Бинарный минус (вычитание)
Операции типа умножения	*	Умножение
	/	Деление
	%	Остаток от деления
Операции сдвига	<<	Сдвиг влево
Операции сдвига	>>	Сдвиг вправо
Поразрядные операции	&	Поразрядное И
	^	Поразрядное исключающее ИЛИ
	\|	Поразрядное включающее ИЛИ
Логические операции	&&	Логическое И
Логические операции	\|\|	Логическое ИЛИ
Операции присваивания	=	Присваивание
	*=	Присвоить произведение
	/=	Присвоить частное
	%=	Присвоить остаток
	+=	Присвоить сумму
	-=	Присвоить разность
	<<=	Присвоить сдвиг влево
	>>=	Присвоить сдвиг вправо
	&=	Присвоить поразрядное И
	^=	Присвоить поразрядное исключающее ИЛИ
	\|=	Присвоить поразрядное ИЛИ
Операции отношения	<	Меньше
	>	Больше
	<=	Меньше или равно
	>=	Больше или равно
Операции равенства	==	Равно
Операции равенства	!=	Не равно
Операции выбора элемента	.	Непосредственный выбор элемента
Операции выбора элемента	->	Косвенный выбор элемента
Операции с элементами класса	::	Доступ/определение области действия
	.*	Обращение через указатель к элементу класса
	->*	Обращение через указатель к элементу класса
Условные операции	a ? x : y	"Если a, то x, иначе - y"
Операция запятой	,	Вычислить, например, a, b, c слева - направо

Пунктуаторы

В Borland C++ пунктуаторы, также называемые разделителями, определяются следующим образом:


            пунктуатор: одно из



               [ ] ( ) { } , ; : ... * = #

Ассоциативность и приоритеты операций Borland C++

Операции	Ассоциативность
() [] -> :: . ! ~ - ++ -- & * (приведение типа)	Слева-направо
sizeof new delete	Справа-налево
.* ->*	Слева-направо
* / %	Слева-направо
+ -	Слева-направо
<< >>	Слева-направо
< <= > >=	Слева-направо
== !=	Слева-направо
&	Слева-направо
^	Слева-направо
\|	Слева-направо
&&	Слева-направо
\|\|	Слева-направо
?:(условное выражение)	Справа-налево
= *= /= := += -= &= ^= \|= <<= >>=	Справа-налево
,	Слева-направо

Ссылки

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

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

Простые ссылки

Для объявления ссылок вне функции может использоваться описатель ссылки:


            int i = 0;



            int &ir = i;   // ir является псевдонимом i



            ir = 2;        // то же, что i = 2

В данном примере создается именующее значение ir, являющееся псевдонимом i, при условии, что инициализатор имеет тот же тип, что и ссылка. Выполнение операций с ir имеет тот же результат, что и выполнение их с i. Например, ir = 2 присваивает значение 2 переменной i, а &ir возвращает адрес i.

Отметим, что type& var, type &var и type & var эквивалентны.

Аргументы типа ссылки

Описатель ссылки может также использоваться для объявления в функции параметров типа ссылки:


            void func1 (int i);



            void func2 (int &ir);   // ir имеет тип "ссылка на int"



              ...



            int sum=3;



            func1(sum);             // sum передается по значению



            func2(sum);             // sum передается по ссылке

Переданный по ссылке аргумент sum может изменяться прямо в func2. Напротив, func1 получает только копию аргумента sum (переданного по значению), поэтому сама переменная sum функцией func1 изменяться не может.

При передаче фактического аргумента x по значению соответствующий формальный аргумент в функции принимает копию x. Любые изменения этой копии в теле функции не отражаются на самом значении x. Разумеется, функция может возвратить значение, которое затем может использоваться для изменения x, но самостоятельно изменить напрямую параметр, переданный ей по значению, функция не может.

Традиционный метод Си для изменения x заключается в использовании в качестве фактического аргумента &x, то есть адреса x, а не самого значения x. Хотя &x передается по значению, функция получает доступ к x благодаря тому, что ей доступна полученная копия &x. Даже если функции не требуется изменять значения x, тем не менее полезно (хотя это чревато возможностью нежелательных побочных эффектов) передавать &x, особенно если x представляет собой большую по размерам структуру данных. Передача x непосредственно по значению ведет к бесполезным затратам памяти на копирование такой структуры данных.

Сравним три различных реализации функции treble:

Реализация 1:


            int treble_1(n)



            {



               return 3*n;



            }



            ...



            int x, i = 4;



            x = treble_1(i);       // теперь x = 12, i = 4



            ...

Реализация 2:


            void treble_2(int* np)



            {



               *np = (*np)*3;



            }



            ...



            treble_2(int &i);      // теперь i = 12

Реализация 3:


            void treble_3(int& n)  // n имеет тип ссылки



            {



               n = 3*n;



            }



            ...



            treble_3(i);           // теперь i = 36

Объявление формального аргумента type& t (или, что эквивалентно, type &t) устанавливает t как имеющую тип "ссылки на тип type". Поэтому при вызове treble_3 с действительным аргументом i, i используется для инициализации формального аргумента ссылки n. Следовательно, n играет роль псевдонима i, и n = 3*n также присваивает i значение 3*i.

Если инициализатор представляет собой константу или объект нессылочного типа, то Borland C++ создаст временный объект, для которого ссылка действует как псевдоним:


            int& ir = 16;   /* создается  временный объект int, с именем



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



                               16 */



            float f;



            int& ir2 = f;   /* создается временный объект int,  с именем



                               псевдонима ir2,  f  перед   присваиванием



                               преобразуется */



            ir2 = 2.0       /* теперь ir2 = 2, но f остается без измене-



                               ний */

Если формальные и фактические аргументы имеют различные (но совместимые по присваиванию) типы, то автоматическое создание временных объектов позволяет выполнять преобразования ссылочных типов. При передаче по значению, разумеется, проблем с преобразованием типов меньше, поскольку перед присваиванием формальному аргументу копия фактического аргумента может быть физически изменена.

Предопределенные макрокоманды

Borland C++ имеет следующие предопределенные глобальные идентификаторы. За исключением __cplusplus и _WINDOWS, каждый из них и начинается, и заканчивается двумя символами подчеркивания (__). Эти макрокоманды также называют именованными константами.

__BCOPT__ Эта макрокоманда определена (как строка "1") в любом компиляторе, имеющем оптимизатор.
__BCPLUSPLUS__ Эта макрокоманда специфична для семейства компиляторов Borland Си и C++. Она определена только для компиляции с помощью C++. Если вы выбрали компиляцию С++, то данная макрокоманда определена как шестнадцатиричная константа 0x0320. Это численное значение в последующих версиях будет увеличено.
__BORLANDC__ Эта макрокоманда специфична для семейства компиляторов Borland Си и C++. Она определена как шестнадцатиричная константа 0x0400. Это численное значение в последующих версиях будет увеличено.
__CDECL__ Данная макрокоманда специфична для компилятоpов Borland Си и C++. Она сообщает о том, что флаг соглашения по вызову языка Паскаль не использовались. Она устанавливается равной целочисленной константе 1, если вызов не использовался; в противном случае она не определена.
Следующие символические имена определяются согласно выбранной во время компиляции модели памяти:
__COMPACT__
__MEDIUM__
__HUGE__
__SMALL__
__LARGE__
__TINY__ Для конкретной компиляции определенным является только одна из этих макрокоманд. Прочие по определению не определены. Например, если при компиляции выбрана малая модель памяти (small), то макрокоманда __SMALL__ определена, а остальные не определены, поэтому директива:
#if defined(__SMALL__)
даст значение True (истина), а:
#if defined(__HUGE__)
(либо любая другая из оставшихся) даст значение False (ложь). Фактическое значение любой из этих макрокоманд, когда она определена, равно 1.
__cplusplus Данная макрокоманда в pежиме C++ имеет значение 1; в пpотивном случае, она не опpеделена. Она позволяет написать модуль, который в некоторых случаях будет компилироваться в Си, а в некоторых - в С++. Использование условных директив компиляции позволяет управлять тем, какие части программы для Си и С++ будут включаться в компиляцию.
__DATE__ Данная макрокоманда дает дату начала обработки препроцессором данного исходного файла (в виде строкового литерала). Каждое включение __DATE__ в данный файл дает одно и то же значение, независимо от того, сколько времени продолжается обработка файла препроцессором. Дата имеет форму mmmddyyyy, где mmm это месяц (Jan, Feb и т.д.), dd равно числу месяца (от 1 до 31, причем если это число меньше 10, то первый символ d равен пробелу), а yyyy это год (1990, 1991 и т.д.)
__DLL__ Эта макрокоманда специфична для семейства компиляторов Borland Си и С++. Она определена как 1, если компилятоp командной стpоки выполняет компиляцию модуля с параметром -WD или в меню O|C|Entry/Exit Code выбиpается селективная кнопка Windows DDL All Functions Exportable для генерации кода библиотек DLL Windows. В противном случае макрокоманда не определена.
__FILE__ Данная макрокоманда дает имя текущего обрабатываемого препроцессором исходного файла (в виде строкового литерала). Когда препроцессор обрабатывает директиву #include или #line, либо при завершении обработки включаемого файла, данная макрокоманда соответствующим образом меняет свое значение.
__LINE__ Данная макрокоманда дает количество обработанных препроцессором к данному моменту строк текущего исходного файла. Обычно первая строка исходного файла определяется с номером 1, хотя на это может повлиять директива #line. Информацию о директиве #line см. выше.
__MSDOS__ Данная макрокоманда специфична для Borland Си и C++. Он дает целочисленную константу 1 для всех случаев компиляции.
__MT__ Эта макрокоманда может использоваться только 32-разрядными компиляторами. Если используется параметр -WM (он задает компоновку мультинитевой библиотеки), эта макрокоманда определена как 1.
__OVERLAY__ Данная макрокоманда специфична для Borland Cи и С++. Она предопределена как 1, если модуль компилируется с параметром -Y (включена поддержка оверлейных структур). Если оверлейные структуры не поддерживаются, то данная макрокоманда не определена.
__PASCAL__ Данная макрокоманда специфична для Borland Cи и С++. Она сообщает о том, что был использован флаг -p или из меню O|C|C|Exit/Entry была выбpана команда Pascal calling conventions. В этом случае макрокоманда установлена равной целочисленной константе 1; в противном случае она не определена.
__STDC__ Данная макрокоманда определена равной константе 1, если компиляция выполняется при установленном флаге совместимости со стандаpтом ANSI (-A) или выбpанной из меню Source Options селективной кнопке ANSI. В противном случае макрокоманда не определена.
__TCPLUSPLUS__ Данная макрокоманда специфична для Borland Cи и С++. Она определена только для компиляции С++. Если вы выбрали компиляцию С++, она определена как шестнадцатиричная константа 0x0320.
__TEMPLATES__ Данная макрокоманда специфична для Borland Cи и С++. Она определена как 1 для файлов С++ (это означает, что C++ поддеpживает шаблоны); в пpотивном случае, она не опpеделена.
__TIME__ Данная макрокоманда дает время начала обработки препроцессором текущего исходного файла (в виде строкового литерала).
Как и в случае макрокоманды __DATE__, каждое включение __TIME__ будет содержать одно и то же значение, независимо от того, сколько времени продолжалась обработка файла. Он имеет формат hh:vv:ss, где hh - это часы (от 00 до 23), mm - это минуты (от 00 до 59), а ss - это секунды (от 00 до 59).
__TLC__ Эта макрокоманда всегда имеет значение True при использовании 32-битового компилятора. См. описание ключевого слова __thread.
__TURBOC__ Данная макрокоманда специфична для Borland Cи и С++. Она опpеделена как шестнадцатиричная константа 0x0410. Это числовое значение в последующих версиях будет увеличено.
__WIN32__ Для 32-разрядного компилятора эта макрокоманда всегда определена. Она определена для консольных приложений и приложений GUI.
_Windows Указывает на то, что генеpиpуется код, специфичный для Windows. Данная макрокоманда определена, если вы компилируете модуль с любым включенным параметром -W (генерация прикладной программы для Windows). Если ни один из этих параметров не включен, то данная макрокоманда не определена.

Что такое поток?

Потоком называется абстрактное понятие, относящееся к любому переносу данных от источника (или поставщика данных) к приемнику (или потребителю) данных. Когда речь идет о вводе символов от источника, используются также синонимы извлечение, прием и получение, и вставка, помещение или запоминание, когда речь идет о выводе символов в приемник. В качестве источников и приемников данных (или и того и другого) существуют классы для поддержки буферов памяти (iostream.h), файлов (fstream.h) и строк (strstream.h).

Библиотека iostream

Библиотека iostream (определенная в файле iostream.h) содержит два параллельных семейства классов: классы, которые являются производными (порожденными) из streambuf, и классы, производные из ios. Оба эти классы являются классами нижнего уровня, и каждый из них выполняет различный набор задач. Один из этих двух классов является базовым классом для всех классов потоков.

Класс iostream

Класс iostream обеспечивает общие методы буферизации и обработки потоков при небольшом объеме или отсутствии форматирования. streambuf это полезный базовый класс, используемый другими частями библиотеки iostream, хотя также вы можете создавать производные от него классы для собственных функций и библиотек. Классы strstreambuf и filebuf являются производными от streambuf.


                                     streambuf



                                      ^  ^   ^



                                 filebuf    strstreambuf



                                       conbuf

Класс streambuf обеспечивает интерфейс с памятью и физическими устройствами. Семейство функций-элементов streambuf используется классами, основанными на ios.

Класс ios

Класс ios (и следовательно, производные от него классы) содержит указатель на streambuf. Он выполняет форматированный вводвывод с контролем ошибок, используя streambuf.

На следующем рисунке показана схема наследования для всего семейства классов ios. Например, класс ifstream является производным от istream и fstreambase, а класс istrstream является производным от istream и strstreambase. Поскольку имеет место множественное наследование, данная схема показывает не просто иерархию классов. При множественном наследовании один класс может наследовать от нескольких базовых классов. Это означает, например, что все элементы (данные и функции) iostream, istream, ostream, fstreambase и ios являются частью объектов класса fstream. Все классы в сети ios используют streambuf (либо filebuf или strstreambuf, которые представляют собой специальные случаи streambuf) в качестве источника и/или приемника.




                                        ios     



                                    ^  ^   ^  ^



        istream      fstreambase             strstreambase    ostream  



                                                                       



       ^ ^ ^ ^  ^    ^   ^ ^                 ^     ^  ^     ^ ^ ^ ^ ^ ^





                 ifstream    istrstream   ofstream   ostrstream        



         istream_withassign   istream  strstream   ostream_withassign   



                                                        confstream      



                                 v          v                           



                                   iostream                             



                                      ^                                 



                              iostream_withassign        



            istream_withassign                  ostream_withassign

Потоковый вывод

Потоковый вывод выполняется с помощью операции включения <<. Стандартная операция сдвига влево << для операций вывода переопределяется. Ее левый операнд - это объект типа ostream, а правый операция может иметь любой тип, для которого определен потоковый вывод (то есть основной тип или любой из переопределенных для него типа). Операция << ассоциируется слева направо и возвращает ссылку на объект ostream, для которого она вызывается. Это позволяет выполнять каскад операций.

Основные типы

Непосредственно поддерживаются основные типы char, short, int, long, char* (интерпретируется как строка), float, double, long double и void*. Интегральные типы форматируются в соответствии заданными по умолчанию типами для printf (если вы не изменили эти правила установками флагов ios).

Форматирование ввода-вывода

Форматирование ввода и вывода определяется различными флагами состояний формата, перечисленными в классе ios. Эти состояния определяются битами числа типа long int следующим образом:


            public:



               enum {



                skipws   = 0x0001, // пропуск пробельного символа на



                                   // вводе



                left     = 0x0002, // вывод с левым выравниванием



                right    = 0x0004, // вывод с правым выравниванием



                internal = 0x0008, // заполнитель после знака или



                                   // указателя системы счисления



                dec      = 0x0010, // десятичное преобразование



                oct      = 0x0020, // восьмиричное преобразование



                hex      = 0x0040, // шестнадцатиричное преобразование



                showbase = 0x0080, // показать на выходе указатель



                                   // системы счисления



               showpoint = 0x0100, // показать позицию десятичной точки



                                   // (на выходе)



               uppercase = 0x0200, // вывод шестнадцатиричных значений



                                   // буквами верхнего регистра



                showpos  = 0x0400, // показать знак "+" для



                                   // положительных чисел



              scientific = 0x0800, // использовать запись чисел с плава-



                                   // ющей точкой с выводом экспоненты Е



                                   // например, 12345E2



                fixed    = 0x1000, // использовать запись чисел с плава-



                                   // ющей точкой типа 123.45



                unitbuf  = 0x2000, // сброс на диск всех потоков



                                   // после вставки



                stdio = 0x4000,    // сброс на диск stdout и stderr после



                                   // вставки



            };

Эти флаги читаются и устанавливаются функциями-элементами flags, setf и unsetf.

Манипуляторы

Простой способ изменения некоторых форматных переменных состоит в использовании специальной функциональной операции, которая называется манипулятором. Манипуляторы воспринимают в качестве аргументов ссылку на поток и возвращают ссылку на тот же поток, поэтому манипуляторы могут объединяться в цепочку занесений в поток (или извлечений из потока) для того, чтобы изменять состояния потока в виде побочного эффекта, без фактического выполнения каких-либо занесений (или извлечений). Например:


            #include <iostream.h>



            #include <iomanip.h> // Тpебуется для паpаметpизованных



                                 // манипулятоpов







            int main(void) {



            int i = 6789, j = 1234, k = 10;







            cout << setw(4) << i << setw(6) << j;



            cout << "\n";



            cout << setw(6) << i << setw(6) << j << setw(6) << k;



            return(0);



            }

дает на выходе:


            678912346789101234



            6789  1234    10

Манипуляторы потока

Манипулятор	Действие
dec	Установка флага форматирования с десятичными преобразованиями.
hex	Установка флага форматирования с шестнадцати- ричными преобразованиями.
oct	Установка флага форматирования с восьмиричными преобразованиями.
ws	Извлечение пробельных символов.
endl	Вставка символа новой строки и очистка потока.
ends	Вставка оконечного пустого символа в строку.
flush	Сброс на диск и очистка ostream
setbase(int n)	Установка системы счисления при преобразованиях с основанием n (0, 8, 10 или 16). Нуль означает по умолчанию десятичную систему при выводе и правила Си для литералов целых чисел при вводе.
resetiosflags(long f)	Очистка форматных бит в ins или outs, заданных аргументом f.
setiosflags(long f)	Установка бит форматирования в ins или outs, заданных аргументом f.
setfill(int c)	Установка символа-заполнителя в c.
setprecision(int n)	Установка точности представления чисел с плавающей точкой равной n разрядам
setw(int n)	Установка ширины поля в значение n

Потоковый ввод

Потоковый ввод аналогичен выводу, но использует переопределенную операцию сдвига вправо, >>, и называется операцией извлечения, или извлечением. Левый операнд операции >> представляет собой объект типа класса istream. Как и для вывода, правый операнд может быть любого типа, для которого определен вывод потоком.

По умолчанию операция >> опускает пробельные символы (как определено функцией isspace в ctype.h), а затем считывает символы, соответствующие типу объекта ввода. Пропуск пробельных символов управляется флагом ios::skipws в перечислимой переменной состояния. Флаг skipws обычно устанавливает пропуск пробельных символов. Очистка этого флага (например, при помощи setf) выключает пропуск пробельных символов. Отметим также специальный манипулятор "приемника", ws, который позволяет игнорировать пробельные символы.

Рассмотрим следующий пример:


            int i;



            double d;



            cin >> i >> d;

Последняя строка вызывает пропуск пробельных символов. Цифры, считываемые со стандартного устройства ввода (по умолчанию это клавиатура), преобразуются затем во внутренний двоичный формат и записываются в переменную i. Затем снова пропускаются пробельные символы, и наконец считывается число с плавающей точкой, которое преобразуется и записывается в переменную d.

Для типа char (signed или unsigned) действие операции >> состоит в пропуске пробельных символов и записи следующего (непробельного) символа. Если вам требуется прочесть следующий символ, неважно, является ли он пробельным или нет, то можно использовать одну из функций-элементов get.

Для типа char* (рассматриваемого как строка) действие операции >> состоит в пропуске пробельных символов и записи следующих (непробельных) символов до тех пор, пока не встретится следующий пробельный символ. Затем добавляется завершающий нулевой (0) символ.

Назад | Содержание | Вперед