Всё для Учёбы — студенческий файлообменник
1 монета
doc

Студенческий документ № 081067 из СИЮ

Лабораторная работа 2

ВЫВОД В СИ/СИ++

Выводом называется процедура переноса данных из памяти компьютера в другое место. Данные можно вывести на экран, отпечатать на принтере или сохранить на диске в виде файла. Кроме того, данные можно сохранить на магнитной ленте или послать по телефонной линии через модем или по факсу.

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

Функции, используемые для вывода данных, зависят от типа данных и способа их представления. Наиболее прост вывод строк и символьных данных.

Функция puts()

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

* Строковый литерал:

puts("Всем привет!");

* Строковая константа:

#define MESSAGE "Всем привет"

main() { puts(MESSAGE);

} * Строковая переменная:

char greeting[]="Всем привет";

main() { puts(geering);

} Помните, литерал (или константное выражение) - это конкретный набор символов, который вводится непосредственно в инструкции Си или Си++ вместо имени константы или переменной. Использование любого другого типа констант, переменных или литералов приведет к ошибке компиляции. Строковый литерал, в отличие от имени константы или переменной, должен быть заключен в двойные кавычки.

Большинство компиляторов выполняют перевод строки после выполнения функции puts(). Это значит, что после того, как данные выведены на экран монитора, курсор автоматически переходит в начало следующей строки.

Однако некоторые компиляторы не выполняют перевод строки. При работе с такими компиляторами для перевода курсора вы должны вставить специальный управляющий код \n в конце строки, предназначенной для вывода на экран. Хотя это свойство компилятора выглядит как недостаток, на самом деле оно может оказаться довольно полезным. Если автоматический перевод строки отсутствует, можно использовать несколько инструкций puts() для вывода на экран одной строки, поставив код \n только в том месте, где вы хотите закончить ее и перейти на следующую.

Функция putchar()

Функция putchar() предназначена для вывода единичного символа на экран. Параметром функции может являться:

* символьный литерал:

putchar('H'); * символьная константа:

#define INITIAL 'H'

main() { putchar(INITIAL);

} * символьная переменная:

main() { char letter;

letter='G';

putchar(letter);

} С помощью функции putchar() можно отображать только один символ. Инструкция

putchar('Hi'); приведет к ошибке компиляции.

При выводе на экран символьного литерала или управляющего кода их следует заключать в одинарные кавычки.

Большинство компиляторов Си не имеет автоматического перевода строки после функции putchar(), и курсор остается сразу за выведенным символом, не переходя к началу следующей строки. Для перехода на новую строку вы должны ввести управляющий код \n.

Некоторые компиляторы имеют функцию putch(), которая аналогична функции putchar(). Двойственность символьных переменных

В некоторых системах при использовании функции putchar() вы должны включить в текст программы файл заголовков STDIO.H с помощью директивы #include. В этих системах функция putchar() является производной другой функции - putc(). Функция putc() может направлять вывод на специальные устройства, такие как диск или принтер. Файл заголовков STDIO.H содержит информацию о том, как использовать функцию putc() для выполнения функции putchar().

Так как функция putc() может направлять вывод в дисковый файл, то ее использование (а соответственно, и применение функции putchar()) требует соблюдения определенных правил. Часть кодов, которые должны быть записаны в дисковый файл, не могут быть помещены в элемент памяти, отводимый для символа. Для осуществления возможности использования этих кодов функции putc() и putchar() были сконструированы таким образом, чтобы они могли работать и с целочисленным типом данных. Компилятор самостоятельно преобразует данные типа int в буквы, так что, имея дело с компиляторами, которые поддерживают стандарт K&R языка Си, можно писать программу следующим образом:

main()

{ int letter;

letter='G'; putchar(letter);

} Даже при том, что переменная letter определена как целочисленная, в качестве начального значения ей может быть присвоен символ. Программа при этом будет компилироваться и выполняться без ошибок.

Некоторые программисты остаются верны стандарту K&R и всегда используют функцию putchar() с параметром типа int. Право выбора остается за вами.

Управляющие коды

Вы можете управлять перемещением курсора на экране и выполнять некоторые другие функции, используя специальные коды, называемые escape-последовательностями (escape sequences). Каждая последовательность начинается с символа обратной наклонной черты (\), который указывает на то, что символы, расположенные за ним, являются escape-символами (escape character). Обратная косая черта и escape-символы выражают операцию, которую вы хотите произвести. Когда компилятор встречает обратную косую черту, он не отображает следующие символы, а выполняет действие, на которое они указывают.

Код "новая строка"

Последовательность \n, называемая кодом "новая строка", перемещает курсор в начальную позицию следующей строки. Используйте код "новая строка" после вывода на экран символа с помощью функции putchar(). Если вы напишете следующие инструкции:

putchar('A');

putchar('\n');

то на экране отобразится символ A, а затем курсор перейдет в начало следующей строки. Отметим, что последовательность \n, как и другие символы, передаваемые функции putchar() в качестве параметра, заключена в одинарные кавычки (апострофы). Так как буква n следует за обратной косой чертой, компилятор обеспечит перевод строки, а не станет отображать этот символ на экране.

При вызове функции puts() вы можете комбинировать escape-последовательность с символами внутри кавычек.

Инструкция

puts("Уильям Уотсон\n");

отобразит имя Уильяма Уотсона на экране, а затем поместит курсор в начало следующей строки. Код "новая строка" должен находиться внутри кавычек.

Если ваш компилятор автоматически выполняет перевод строки после выполнения функции puts(), тогда курсор будет переведен на две строки вниз. Опишем, как это происходит:

1. Отображается имя Уильяма Уотсона.

2. Код \n обеспечивает выполнение escape-последовательности "новая строка", перемещая курсор в начальную позицию строки, расположенной под именем.

3. Выполнение функции puts() завершается. Если ваш компилятор добавляет перевод строки автоматически, то курсор будет перемещен вниз еще на одну строку.

До сих пор код \n использовался нами в конце сроки, но он может располагаться в любом месте внутри кавычек. Инструкция

puts("A\nB\nC");

отобразит на экране три строки текста:

A B C Почему? Последовательность действий такова: компилятор отобразит символ А, переместит курсор в начало новой строки, отобразит символ B, переместит курсор в начало следующей строки и отобразит символ C. Если ваш компилятор добавляет перевод строки автоматически, то курсор будет переведен еще на одну строку ниже символа C.

Код "табуляция"

Код "табуляция" \t перемещает курсор в следующую позицию табуляции экрана. Чтобы посмотреть, как работает код "табуляция", воспользуемся следующей программой:

main()

{ puts("123456789012345678921234567893123456789412345\n");

puts("0\t1\t2\t3\t4\t5\n");

} Она отображает строку цифр, чтобы вы могли рассчитать позиции табуляции, а затем отображает строку с цифрой 0 в крайней левой позиции экрана и цифры от 1 до 5, показывающие позиции табуляции экрана.

123456789012345678921234567893123456789412345

0 1 2 3 4 5 Код "табуляция" можно использовать для создания выровненных колонок текста или чисел, например, так:

main() { puts("Друзья, суммы долгов и сроки задолженностей:\n");

puts("Алан\t\tДжефф\t\tНэнси\t\tТом\n");

puts("$1.50\t\t$2.45\t\t$6.24\t\t$3.56\n");

puts("10 дней\t\t5 дней\t\t15 дней\t\t1 день\n");

} Результат работы этой программы представлен на рис.1. Заметьте, что мы использовали по два кода "табуляция" между колонками, чтобы отчетливо разделить их на экране. Также обратите внимание на отсутствие пробелов между кодом "табуляция" и следующим за ним текстом, так как любые дополнительные пробелы отобразятся на экране, и колонки не будут выровнены правильно.

Рис.1. Результаты работы программы, использующей коды "табуляция"

Код "возврат каретки"

Код "возврат каретки" \r выполняет "возврат каретки", перемещая курсор к началу той же строки без перехода на следующую. Если вы вывели на экран какую-то информацию, перевели курсор назад к началу этой строки и затем вывели на экран другую информацию, то старое сообщение стирается, а на его месте появляется новое.

Рис.2 иллюстрирует различия между escape-последовательностями "возврат каретки" и "новая строка". Когда вы работаете с клавиатурой, нажатие клавиши Enter производит действие, аналогичное тому, что в языке Си называется новой строкой. Некоторые программисты называют это комбинацией возврата каретки и перевода строки, сокращенно CR/LF (от английского carriage return/line feed). Использование кода "возврат каретки" в языке Си не приводит к переходу на новую строку.

Рис.2. Различия между кодами "возврат каретки" и "новая строка"

Действие кода \r можно видеть на примере следующей инструкции:

puts("Левый\rПравый");

В результате ее выполнения на экране появится только слово "Правый". И вот почему: после отображения на экране слова "Левый", код \r переводит курсор в начало этой строки, и при отображении слова "Правый" составляющие его символы замещают собой символы слова "Левый". Код \r сам по себе не уничтожает выведенные на экран символы, когда возвращает курсор, и только вывод новых символов после возврата курсора стирает уже существующий текст.

Код "возврат на шаг"

В отличие от кода \r, который возвращает курсор в начало строки, код "возврат на шаг" \b передвигает курсор только на одну позицию влево. При перемещении курсора существующие символы не уничтожаются, как и при возврате каретки.

Если вы используете коды "возврат каретки" или "возврат на шаг", а затем вводите код "новая строка", курсор переходит к следующей строке, не уничтожая существующий текст.

Код "перевод страницы"

Когда вы посылаете информацию на печатающее устройство, код "перевод страницы" \f вытягивает из него текущую страницу. Этот код распознается большинством принтеров.

После вывода сообщения на печать, большинство программистов использует код "перевод страницы", чтобы быть уверенными в том, что страница с последним сообщением готова и на нее не будет печататься другая информация. Если вывести изображение этого кода на экран при помощи функции puts() или putchar(), он появится в виде маленького графического символа, который никак не влияет на остальную информацию, отображаемую на дисплее.

Отображение специальных символов на экране монитора

Вы можете использовать escape-последовательности для вывода на дисплей специальных символов. Программисты часто используют их для вывода символов, изображение которых невозможно получить иным способом:

Escape-последо-вательность Функция \' отображает одинарную кавычку \" отображает двойную кавычку \\ отображает обратную косую черту

Например, вы желаете вывести на экран текст:

Мы зовем ее "Наташа"

который содержит кавычки с именем "Наташа". Если вы попробуете отобразить эту строку с помощью инструкции

puts("Мы зовем ее "Наташа"");

то получите от компилятора сообщение об ошибке. Вспомните, параметр, передаваемый функции puts(), должен начинаться и заканчиваться кавычками, чтобы компилятор Си знал, где начинается и где заканчивается строка. В приведенном выше ошибочном примере, компилятор будет интерпретировать параметр как "Мы зовем ее" с дополнительными символами "Наташа""", которые расположены снаружи по отношению к паре двойных кавычек, но внутри пары скобок, содержащих параметр для вызова функции puts(). Для компилятора в такой строке оказывается слишком много информации.

Приведем теперь правильную запись этой инструкции:

puts("Мы зовем ее \"Наташа\"");

Рис.3. Отображение символов "кавычки"

На рис.3 показано, каким образом компилятор интерпретирует эту строку.

Кроме кавычек и обратной косой черты, вы можете использовать управляющие коды для отображения различных графических символов. IBM PC и совместимые компьютеры могут отображать набор символов, известных как расширенный набор ASCII-символов. Он включает в себя все буквы, цифры и знаки препинания, которые можно ввести с клавиатуры, а также некоторые графические символы и буквы русского алфавита. Каждый символ в наборе имеет собственный номер, например, номер 3 соответствует символу "сердечко" (по карточной терминологии - "черви"). Чтобы отобразить символ на экране, надо поместить соответствующий ему номер (в виде трех цифр) после знака обратной косой черты:

putchar('\003');

В результате выполнения этой инструкции на дисплей выводится символ "сердечко". Для того чтобы отобразить символы всех карточных мастей, используйте следующую программу:

main() { puts("Черви \003\n");

puts("Бубны \004\n");

puts("Трефы \005\n");

puts("Пики \006\n");

} Функция puts() выведет на экран названия всех карточных мастей и соответствующие им графические символы (рис.4). В табл.1 приведены некоторые символы, которые могут быть изображены только путем использования их кодов.

Рис.4. Отображение графических символов по их кодам

Для отображения графических символов можно использовать и функцию putchar() за счет двойственности символьных переменных. Если вы определили переменную типа int, ей, понятное дело, можно присвоить числовое значение:

int count;

count=5; Если затем вы используете эту переменную как параметр, передаваемый функции putchar()

putchar(count); символ, ассоциированный со значением переменной, будет отображен на экране.

Таблица 1. Некоторые используемые коды символов.

Один из символов в наборе ASCII не появляется на экране, зато при попытке вывести его раздается звонок! Использование escape-последовательности \007 приводит к подаче звукового сигнала встроенным динамиком вашего компьютера. Приведенная ниже программа дважды подает звуковой сигнал, привлекая внимание к сообщению на экране:

#define BELL '\007' /* BELL легче запомнить, чем \007 */

main() { putchar(BELL); /*Подача звукового сигнала*/

putchar(BELL); /*Подача звукового сигнала*/

puts("Вниманию покупателей!\n");

puts("В отделе спортивных товаров \

проводится сезонная распродажа\n");

} Директива #define определяет константу BELL со значением \007. И хотя для определения константы вам пришлось ввести с клавиатуры четыре символа, компилятор воспримет ее как обычную символьную константу. Сигнал динамика слышится тогда, когда вы пытаетесь вывести константу BELL на дисплей с помощью функции putchar().

Многогранная функция printf()

Функции puts() и putchar() используются довольно часто, но, к сожалению, их возможности несколько ограничены. Ни одна из них не может обеспечить вывод числовых данных, и обе они имеют только один аргумент (параметр). Это означает, что обе функции могут отобразить только один объект.

Языки Си и Си++ имеют более многостороннюю функцию, называемую printf(). Она позволяет выводить на дисплей данные всех типов и работать со списком из нескольких аргументов. Кроме того, при вызове функции printf() можно определить способ форматирования данных.

В простейшем случае функцию printf() можно использовать вместо функции puts() для вывода строки:

#define MESSAGE "Привет!"

main() { printf(MESSAGE);

printf("Добро пожаловать в мой мир, а теперь ... пока!");

} Так же как и puts(), функция printf() будет выводить на экран строки, заключенные в кавычки, и значения строковых констант и переменных.

Вывод чисел

Для того чтобы отобразить числовые данные и иметь возможность форматировать данные всех типов, список параметров, передаваемый функции printf(), делится на две части (рис.5).

Рис.5. Две части списка параметров функции printf()

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

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

%d целое число %u беззнаковое целое число %f вещественное число типа float или double %e вещественное число в экспоненциальной форме %g вещественное число, отображаемое по формату %f или %e, в зависимости от того, какая форма записи является более короткой %c Символ %s Строка

Таким образом, первая часть инструкции printf() записывается так:

printf("%d")

Знак процента говорит компилятору, что за ним последует указатель формата (чтобы отобразить сам символ процента, напишите его дважды: printf("%%");).

Буква d указывает компилятору, что следует отобразить целое число, записанное в десятичной системе счисления (рис.6).

Рис.6. Составляющие указателя формата

Второй частью списка параметров является список данных, содержащий литералы, имена констант или имена переменных, значение которых необходимо отобразить на дисплее. Список данных отделяется от строки формата запятой. Между собой все элементы списка данных также разделяются запятыми. Когда компилятор создает объектные коды, он подставляет на место указателей формата значения из списка данных.

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

printf("%d", 12);

В процессе выполнения этой инструкции значение 12 будет подставлено на место указателя формата (рис.7). В нашем примере мы на самом деле передали

Рис.7. Значение подставляется на место указателя формата

библиотечной функции printf() два параметра: строку формата и числовой литерал12.

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

printf("Мне исполнилось %d лет", 12);

Рис.8. Использование указателя формата внутри строкового литерала

Строкой формата в этом примере является запись

"Мне исполнилось %d лет"

Указатель формата, %d, говорит о том, что мы хотим вставить число между словами "Мне исполнилось" и словом "лет" (рис.8). Когда компилятор подставит число12 на место указателя формата, мы увидим следующую фразу:

Мне исполнилось 12 лет

В этом примере функции передается одновременно и строковый литерал, и числовое значение.

В данном случае тот же результат можно получить, передавая всю фразу целиком, как параметр, одной из функций:

printf("Мне исполнилось 12 лет");

puts("Мне исполнилось 12 лет");

Но чтобы комбинировать текст с числовыми константами или переменными, следует использовать именно функцию printf() и указатели формата, как, например, в программе:

main() { int age;

age = 12; printf("Мне исполнилось %d лет", age);

} Эта программа отображает на экране строковый литерал и значение целочисленной переменной с помощью одной инструкции (рис.9).

Рис.9. Значение переменной подставляется на место указателя формата

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

main()

{ int lucky_1, lucky_2;

lucky_1 = 12; lucky_2 = 21;

printf("Моими счастливыми номерами являются \

%d и %d", lucky_1, lucky_2);

} Здесь мы определили две целочисленные переменные lucky_1 и lucky_2 и присвоили им начальные значения. Список данных функции printf() содержит два имени переменных (аргумента), которые мы хотим отобразить, так что строка формата тоже должна иметь два указателя формата. Так как обе переменные относятся к типу int, оба указателя формата одинаковы - %d, как показано на рис.10.

Рис.10. Использование двух указателей формата

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

Моими счастливыми номерами являются 12 и 21

Значение переменной lucky_1, первого пункта в списке данных, займет место первого указателя формата, а второй пункт списка данных (значение переменной lucky_2) будет подставлен на место второго указателя. Если пункты в списке данных поменять местами:

printf("Моими счастливыми номерами являются \

%d и %d", lucky_2, lucky_1);

то значения отобразятся в таком порядке:

Моими счастливыми номерами являются 21 и 12

Тип данных должен соответствовать типу указателя формата. Например, следующая программа отображает значения переменной типа float и переменной типа int с помощью одной функции printf():

main() { int count;

float amount;

count = 5; amount = 45.48;

printf("Стоимость составляет %f за %d штук", amount, count);

} Первое значение из списка данных - число с плавающей точкой - подставляется на место первого указателя формата %f. Второе значение - целое число - подставляется на место второго указателя формата %d. Программа компилируется и выполняется без ошибок, так как типы переменных и указателей формата совпадают. Как показано на рис.11, значение типа float замещает указатель %f, а значение типа int - указатель %d. В результате имеем:

Стоимость составляет 45.580000 за 5 штук

Рис.11. Тип данных должен соответствовать указателю формата

Количество нулей, которое будет проставлено в числе с плавающей точкой зависит от конкретного компилятора (вскоре вы узнаете, почему они появляются). Если поменять местами элементы в списке данных и записать инструкцию следующим образом:

printf("Стоимость составляет \

%f за %d штук", count, amount);

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

Стоимость составляет -2.002149Е37 за 16454 штук

К такому результату привело несоответствие типов числовых данных и указателей формата. При вызове функции printf() можно использовать несколько аргументов различных типов, но только при строгом соответствии типов данных и указателей формата.

Перевод строки

Функция printf() не переводит курсор автоматически на новую строку после отображения данных. После того как данные выведены на экран, курсор остается на той же строке, сразу за последним символом.

Если вы хотите перевести курсор на следующую строку, вы должны добавить в строку формата управляющий код "новая строка" \n:

printf("Стоимость составляет %f за %d штук\n", amount, count);

Управляющий код \n помещают там, где хотят начать новую строку (не обязательно в конце строки формата), например, в результате выполнения инструкции

printf("Стоимость составляет %f\n за %d штук\n", amount, count);

на экране появятся две строки:

Стоимость составляет 45.580000 за 5 штук

и Стоимость составляет 45.580000

за 5 штук

Можно использовать любые другие escape-последовательности для регулирования пробелов, подачи звукового сигнала или изображения специальных символов.

Преобразование типов данных

В Си существует два дополнительных указателя формата, с помощью которых можно переводить данные типа int из десятичной в восьмеричную и шестнадцатеричную системы счисления:

%o перевод в восьмеричную систему, используйте только маленькую букву о, не цифру 0 %x перевод в шестнадцатеричную систему Для того чтобы перевести число из десятичной в другую систему счисления, надо поместить код %o или код %x в строку формата, при этом в список данных вносится число, записанное в десятичной системе. В качестве примера приведена программа, отображающая число17 в шестнадцатеричной и восьмеричной системах счисления:

main()

{ printf("%d равно %x в шестнадцатеричной и %o в \

восьмеричной системах счисления\n", 17, 17, 17);

// так в Си и Си++ можно переносить

// длинные строки символов,

// заключенные в двойные кавычки (ред.)

} Результат работы программы выглядит следующим образом:

17 равно 11 в шестнадцатеричной и 21

в восьмеричной системах счисления

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

Двойственность символьных переменных

При описании функции putchar() уже говорилось, что символьные переменные могут быть заданы и как целочисленные. Следовательно, можно присвоить букву в качестве значения переменной типа int и вывести ее на дисплей при помощи функции putchar() или printf():

main()

{ int a; a = 'A';

putchar(a); putchar('\n');

printf("%c", a);

} При выполнении этой программы символ А появится дважды: один раз как символ, отображенный функцией putchar(), второй раз как символ, отображенный функцией printf() с использованием указателя формата %c. Независимо от того, определен тип переменной как char или int, можно преобразовать символ в его ASCII-код:

main()

{ char a; a = 'A';

printf("ASCII-код символа %c равен %d", a, a);

} В этом примере одно и то же значение переменной выводится на дисплей с использованием указателей формата %c и %d. В результате получаем следующее сообщение:

ASCII-код символа А равен 65

где присутствует символ А, отображенный с использованием указателя формата %c, и число 65, являющееся ASCII-кодом символа А, выведенное с помощью указателя формата %d.

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

Форматированный вывод

Функцию printf() можно использовать для управления форматом данных. Определять величину пробелов и количество выводимых символов можно с помощью указателей ширины поля*.

Без указателя ширины поля числа с плавающей точкой, например, будут выводиться с шестью знаками после точки. Поэтому в результате выполнения инструкции

printf("Стоимость составляет %f за %d штук", amount, count);

и появляется строка:

Стоимость составляет 45.580000 за 5 штук

В зависимости от особенностей системы и от того, как ведется расчет среднего значения, может появиться и что-нибудь в таком роде:

Стоимость составляет 45.579998 за 5 штук

Рис.12. Определение количества знаков после точки

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

Чтобы определить число знаков после точки, используется указатель %.nf, где число n определяет количество знаков (рис.12). Например, если написать:

printf("Стоимость составляет %.2f", amount);

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

Стоимость составляет 45.58

Сходным образом, если написать:

printf("Стоимость составляет %.3f", amount);

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

Стоимость составляет 45.580

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

Рис.13. Примеры определения количества знаков в десятичной части

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

%N.nf

где N - это общая ширина поля.

Если задать инструкцию

printf("Стоимость составляет %8.2f", amount);

появится строка

Стоимость составляет 45.58

с тремя дополнительными пробелами перед числом. Чтобы понять, почему это произошло, взгляните на рис.14: указатель ширины поля сообщает компилятору, что числовое значение должно быть как бы втиснуто в "коробочку" размером восемь символов. Само по себе число занимает пять из них, включая точку, а неиспользованные символы отображаются на экран в виде пробелов, создавая перед числом пустое пространство.

Рис.14. Указатель ширины поля определяет количество пробелов на экране

Если ширина поля, заданного указателем, оказывается меньше количества символов, составляющих число, Си, тем не менее, выведет число целиком, просто игнорируя в данном случае указатель ширины поля. Выполнение инструкции

printf("Стоимость составляет %2.2f", amount);

приведет к появлению сообщения

Стоимость составляет 45.58

Можно также добавить лишнее пространство перед числом, но заполнить его нулями вместо пробелов, как на рис.15. Для этого перед числом, определяющим ширину поля, надо поставить символ 0:

Рис.15. Вывод нулей перед числом

printf("Стоимость составляет %08.2f", amount);

в результате мы увидим сообщение

Стоимость составляет 00045.58

Для того чтобы выровнять значение по левому краю (как бы поместить его слева в нашей воображаемой "коробочке"), в указатель ширины поля после % вводится знак "минус"

%-8.2f

Лишние пробелы в этом случае появятся после выведенного значения. Инструкция

printf("Стоимость составляет %-8.2f в долларах США", amount);

выводит на экран сообщение

Стоимость составляет 45.58 в долларах США

Как показано на рис.16, число 45.58 опять как бы помещается в "коробочку" из восьми символов, но теперь уже сдвигается к левому краю, а пустое пространство появляется за числом.

Указатель ширины поля может работать как с символьными, так и со строковыми данными. Дополнительные пробелы помещаются перед текстом, сдвигая строку к правому краю воображаемой "коробочки". Например, если строковая переменная, называемая message, имеет значение "Привет", то инструкция

Рис.16. Выравнивание по левому краю

printf("Я позвонил, чтобы сказать %8s", message);

отобразит на экране следующую строку

Я позвонил, чтобы сказать Привет

Как показано на рис.17, при выводе значения строковой переменной message

Рис.17. Использование указателя ширины поля при выводе строки

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

Выбор правильных средств вывода информации

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

Чтобы вывести на экран обычный текст или символы, можно использовать функции puts() или putchar(). Так как эти функции не имеют никаких возможностей форматирования данных, они работают быстрее, и их коды занимают меньший объем на диске, чем коды функции printf(). Имея дело с функцией puts(), прежде всего проверьте, добавляет ли компилятор код "новая строка" автоматически. Если он не делает этого, а вы не проверите сразу, потом вам придется потратить довольно много времени на редактирование программы.

Рис.18. Правила использования функции printf()

Кстати, при работе с функцией printf(), пропуск кода "новая строка" тоже является распространенной оплошностью среди начинающих программистов.

Функция printf() работает медленнее и требует большего объема памяти, но она идеально подходит в тех случаях, когда вам требуется выводить числовые данные, форматировать строки или комбинировать текст и числовые переменные в одной строке. Работая с функцией printf(), следует тщательно следить за тем, чтобы указатели формата соответствовали литералам, константам и переменным в списке данных. Рис.18 иллюстрирует наиболее важные моменты, необходимые, чтобы правильно написать инструкцию, использующую функцию printf().

Вывод в Си++

Все обсуждавшиеся ранее приемы программирования относятся к выводу данных как в языке Си, так и Си++. Однако язык Си++ имеет дополнительный способ вывода данных всех типов.

В Си++ существует стандартный поток вывода cout, позволяющий в сочетании с двумя символами "меньше"

(<<),

которые называются оператором вставки*, отображать литералы или значения констант и переменных без использования указателей формата.

Если у вас есть компилятор Си++, посмотрите документацию к нему. Не исключено, что необходим специальный файл заголовков для того, чтобы иметь возможность использовать преимущества стандартного потока вывода cout и стандартного потока ввода cin. Для некоторых компиляторов, например, необходимо включить файл STREAM.H с помощью директивы #include в начале программы.

___________________________

Рис.19. Стандартный поток вывода cout

Структура инструкции, использующей cout, показана на рис.19. После cout надо поставить два знака

< . Они указывают cout отобразить помещенную после них информацию. Информация может быть представлена в виде литерала (тогда ее заключают в кавычки) либо имени константы или переменной.

Рассмотрим инструкцию cout << "Привет, меня зовут Сэм. Мы с вами уже встречались";

При ее выполнении произойдет вывод на дисплей строки, заключенной в кавычки. Инструкция

int count;

count = 4509; cout << count

отобразит значение переменной с именем count - число 4509.

Рис.20. Вывод нескольких аргументов с помощью cout

Используя один стандартный поток вывода cout, можно отобразить несколько аргументов. Между собой аргументы разделяются операторами вставки, как это продемонстрировано на рис.20. Например, инструкция

int age;

age = 43; cout << "Вам исполнилось " << age << " года.";

отображает текст

Вам исполнилось 43 года.

Стандартный поток вывода cout отображает каждый пункт, указанный с помощью оператора вставки, в том порядке, в каком они записаны в инструкции.

Так же, как и функция printf(), cout не добавляет никаких команд новой строки после отображения данных. Чтобы перейти к новой строке, там, где вы хотите ее начать, надо добавить управляющий код \n, как это показано на рис.20.

Замечания по Си++ Одна из особенностей языка Си++ - так называемая перегрузка - делает необязательным использование указателей формата. В отличие от функции printf(), которая требует обязательного указания формата данных, cout при передаче параметров сам определяет формат на основании типа получаемых данных. Этот процесс и называется перегрузкой.

Проектирование программы

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

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

puts("Добро пожаловать\n");

puts("Эта программа рассчитывает платежи \n");

puts("Введите сумму займа,\n");

puts("проценты по закладным и срок выплаты в годах.\n");

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

printf("Основные месячные выплаты: %7.2f\n", princ);

printf("Проценты: %7.2f\n", interest);

printf("Общие месячные выплаты: %7.2f\n", total);

Дополнительные пробелы между двоеточиями и указателями формата, выравнивание указателей и указатели сами по себе приводят к тому, что числовые значения выравниваются следующим образом:

Основные месячные выплаты: 256.25

Проценты: 92.12

Общие месячные выплаты: 34.37

Такой способ представления информации кажется более удобным, чем, например, следующий:

printf("%f %f %f", prins, inter, total);

в результате чего имеем:

256.25 92.12 34.37

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

В табл.2 подведен краткий итог всем способам вывода данных, которые обсуждались выше.

Таблица 2. Средства вывода информации в языке Си/Си++.

Вопросы 1. Что такое вывод?

2. Какие три типа аргументов можно использовать с функцией puts()?

3. Какие три типа аргументов можно использовать с функцией putchar()?

4. Что такое escape-последовательности?

5. В чем заключаются различия между escape-последовательностями \n и \r?

6. Как вывести на экран символ "кавычка"?

7. Из каких двух частей состоит список параметров функции printf()?

8. Какие преимущества имеет функция printf() по сравнению с puts()?

9. Что такое указатель формата?

10. Как вывести на экран значение числовой переменной?

Упражнения 1. Напишите программу вывода вашего имени и адреса на экран с использованием функции puts().

2. Напишите программу вывода вашего имени и адреса на экран с использованием функции printf().

3. Напишите функцию puts(), которая выводит слово "Заглавие" в середине экрана. Ширина экрана 80 символов.

4. Напишите функцию printf(), которая выводит слово "Страница" с правой стороны экрана.

5. Напишите функцию printf(), которая выводит значения следующих переменных:

float length, width, height, volume;

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

char name[12]; int age;

7. Программа содержит следующие переменные:

сhar item[] = "Дискеты";

float cost = 3.55;

float markup = 0.75;

Напишите функцию printf(), которая выводит на экран следующие сообщения:

Наименование товара: Гибкий диск

Цена за 1 упаковку: 3.55

Наценка: 0.75

Обратите внимание на выравнивание.

8. Программа содержит следующую переменную:

int count = 30;

Используя значение переменной count для вывода числа в последней строке, напишите программу, которая подает звуковой сигнал и выводит на экран следующее сообщение:

Внимание! Внимание! Внимание! Внимание!

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

У вас есть 30 секунд, чтобы покинуть помещение.

Показать полностью… https://vk.com/doc67696464_441907346
326 Кб, 7 февраля 2017 в 10:00 - Россия, Москва, СИЮ, 2017 г., doc
Рекомендуемые документы в приложении