Как вывести char c

Отслеживать
ответ дан 27 фев 2019 в 10:10
12.5k 2 2 золотых знака 19 19 серебряных знаков 44 44 бронзовых знака

• c++
• массивы
• строки
• visual-studio-2017

Важное на Мете

Похожие

Подписаться на ленту

Лента вопроса

Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.

Дизайн сайта / логотип © 2024 Stack Exchange Inc; пользовательские материалы лицензированы в соответствии с CC BY-SA . rev 2024.1.8.3130

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Посимвольный ввод и вывод в языке Си. Понятие буфера

В заголовочном файле stdio.h содержится объявление не только функции printf , но и многих других, связанных с вводом-выводом. Среди них есть функции, которые обрабатывают по одному символу за вызов — putchar и getchar .

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

char ch = 'c'; putchar('a'); putchar(98); putchar('\n'); putchar(ch);

ab c

Функции putchar() и printf() в определенном смысле взаимозаменяемы, так как, используя ту или другую, можно получить один и тот же результат. Хотя программный код будет выглядеть по-разному:

char str[] = "Hello"; int i; // первое Hello printf("%s\n", str); // второе Hello for (i = 0; str[i] != '\0'; i++) putchar(str[i]); printf("\n");

В результате выполнения этого кода на экране будут напечатаны два слова "Hello", разделенные переходом на новую строку. С putchar() это выглядит несколько сложнее. Как мы знаем, любая строка оканчивается нулевым по таблице ASCII символом, в данном случае этот символ служит сигналом для прекращения вывода на экран. Но если бы понадобилось вывести на экран строку, разделяя ее символы каким-нибудь другим символом (например, тире), то и в случае с printf() было бы не так все просто:

#include int main() { char str[] = "Hello"; int i; for (i = 0; str[i] != '\0'; i++) printf("%c-", str[i]); printf("%c%c %c", '\b', '\0', '\n'); for (i = 0; str[i] != '\0'; i++) { putchar(str[i]); putchar('-'); } printf("%c%c %c", '\b', '\0', '\n'); }

H-e-l-l-o H-e-l-l-o

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

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

int a; a = getchar(); printf("%c ", a); putchar(a); putchar('\n');

Если при выполнении этого кода ввести символ, то после нажатия Enter вы увидите два таких же символа на экране:

u u u

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

char a, b, c; a = getchar(); putchar(a); b = getchar(); putchar(b); c = getchar(); putchar(c); printf("\n");

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

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

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

Теперь, зная это, давайте посмотрим, что происходило в нашей программе, и сначала разберем второй случай с "некорректным пользователем", т.к. для понимания этот случай проще. Когда пользователь ввел первый символ, он попал в переменную a , далее сработала функция putchar(a) и символ попал в буфер. Так как Enter не был нажат, содержимое буфера на экране не отобразилось. Пользователь ввел второй символ, переменная b получила свое значение, а putchar(b) отправила это значение в буфер. Аналогично с третьим символом. Как только пользователь нажал Enter , содержимое буфера было выведено на экран. Но символы, которые были выведены на экран, были выведены не программой, а операционной системой. Программа же выводила символы еще до того, как мы нажали Enter .

Почему же в первом случае при выполнении программы мы смогли ввести и увидеть на экране только два символа? Когда был введен первый символ, то он был присвоен переменной a и далее выведен в буфер. Затем был нажат Enter . Это сигнал для выброса данных их буфера, но это еще и символ перехода на новую строку. Этот символ '\n' , наверное, и был благополучно записан в переменную b . Тогда в буфере должен оказаться переход на новую строку, после этого введенный символ (уже помещенный в переменную c ). После нажатия Enter мы должны были бы увидеть переход на новую строку от символа b = '\n' и букву. Однако печатается только буква. Причина этого вероятно в том, что переход на новую строку не хранится в буфере.

Во многих учебниках по языку C приводится пример считывания символов, вводимых пользователем, и их вывод на экран:

int a; a = getchar(); while (a != '\n') { putchar(a); a = getchar(); } putchar('\n');

В переменной a всегда хранится последний введенный символ, но перед тем как присвоить ей новое значение, с помощью функции putchar() старое сбрасывается в буфер. Как только поступает символ новой строки, работа цикла прекращается, а также, поскольку была нажата клавиша Enter , происходит вывод содержимого буфер на экран. Если в условии цикла while будет не символ '\n', а какой-нибудь другой, то программа продолжит обрабатывать символы, даже после нажатия Enter . В результате чего мы можем вводить и выводить множество строк текста.

При совместном использовании функций putchar() и getchar() обычно пользуются более коротким способом записи. Например:

while ((a = getchar()) != '~') putchar(a);

Здесь в условии цикла сначала вызывается функция getchar() . Возвращенное ей значение присваивается переменной a . После этого значение a проверяется на неравенство символу тильды.

EOF

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

В операционных системах и языках программирования вводят специальное значение, которое служит признаком окончания потока ввода или признаком конца файла. Называется это значение EOF (end of file), а его конкретное значение может быть разным, но чаще всего это число -1. EOF представляет собой константу, в программном коде обычно используется именно имя (идентификатор) константы, а не число -1. EOF определена в файле stdio.h .

#include int main() { int a; while ((a = getchar()) != EOF) { putchar(a); } putchar('\n'); }

В операционных системах GNU/Linux можно передать функции getchar() значение EOF , если нажать комбинацию клавиш Ctrl + D , в Windows – Ctrl + Z .

Решение задач

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

#include #define N 100 int main () { char ch; char nums[N]; int i; i = 0; while ((ch = getchar()) != EOF && i  N-1) if (ch >= 48 && ch  57) { nums[i] = ch; i++; } nums[i] = '\0'; printf("%s\n", nums); }

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

Курс с решением задач:
pdf-версия

Как вывести char c

Чтение символов с клавиатуры может использоваться даже в самых простых программах. Оно может быть связано с выбором варианта в меню, ответа типа ДА/НЕТ или даже с вводом отдельной буквы какого-нибудь имени. Самым распространенным способом чтения символа, введенного с клавиатуры, является макрокоманда getchar, формат которой имеет вид:

#include int getchar(void);

При успешном завершении макрокоманда getchar возвращает считанный символ в коде ASCII. В случае ошибки или обнаружения конца файла (обычно при переназначенном вводе) getchar возвращает EOF. В следующей программе GETCHAR.C макрокоманда getchar используется для получения вводимого с клавиатуры ответа Y, означающего "да", или N, означающего "нет":

#include #include void main(void) < int letter; рrintf ("Для продолжения введите Y или N и нажмите" "Enter\n "); do < letter = toupper(getchar( )); >while ((letter != 'Y') && (letter != 'N')); printf("Введено %c\n", ((letter == 'Y') ? 'Y': 'N')); >

Как видно, в программе организуется циклический вызов geichar оператором do while до тех пор, пока пользователь не введет Y или N.

Примечание. Для обеспечения поддержки переназначенного ввода в определении макрокоманды geichar в действительности используется ввод с slain - стандартный ввод (по умолчанию соответствует вводу с клавиатуры).

287. Вывод символа на экран

В С286 рассматривалось использование макрокоманды getchar для чтения символа, введенного с клавиатуры. Подобным образом, используя в Си макрокоманду putchar, можно выводить символ на экран (stdout - стандартный вывод). Формат макрокоманды putchar.

#include int putchar(int letter);

При успешном завершении макрокоманда putchar возвращает выведенный символ. В случае ошибки putchar возвращает EOF. В следующей программе PUTCHAR.С макрокоманда putchar используется для вывода букв алфавита:

#include void main(void)

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

288. Буферизованный ввод

При вводе с клавиатуры чтение вводимых символов в программе обеспечивается как операциями прямого, или непосредственного ввода, так и посредством буферизации. При использовании буферизованного ввода набранные символы не передаются в программу до тех пор, пока пользователь не нажмет клавишу Enter. Таким образом, пользователь может изменять введенные символы, используя при необходимости клавиши Backspace или Rubout. После нажатия Enter все введенные символы могут обрабатываться программой. Макрокоманда getchar использует буферизованный ввод. При использовании getchar для чтения ответа пользователя (например, Y или N) макрокоманда не считывает введенный символ, пока пользователь не закончит ввод нажатием Enter. Если пользователь ввел несколько символов, то все они накапливаются в буфере, и каждый из них доступен для getchar. В следующей программе BUFFERIO.С демонстрируется работа с буферизованным вводом. Запустите программу и затем введите строку текста. Введенные символы не обрабатываются программой, пока не будет нажата клавиша Enter. После нажатия Enter программа считает и выведет на экран символы, включая символ перевода строки (возникающий именно в результате нажатия клавиши Enter):

#include void main(void) < int letter; do < letter = getchar(); putchar(letter); >while (letter != '\n'); >

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

289. Ввод символов с клавиатуры в строковую переменную

В разделе "Строки" этой книги дается несколько различных способов обработки строковых переменных. При вводе-последовательности символов с клавиатуры самой необходимой является операция присваивания введенных символов строковой переменной. В следующей программе FILLSTR.C для присваивания символов элементам строковой переменной string (массив символов) используется макрокоманда getchar. Для этого в программе просто организуется цикл, в котором элементам строки присваиваются символы до тех пор, пока не встретится символ "конец строки". По окончании цикла текущему элементу массива присваивается NULL-СИМВОЛ (маркер конца строки):

#include void main(void)

290. Комбинирование getchar и putchar

Известно, что getchar дает возможность прочитать символ с клавиатуры (стандартный ввод stdin), в то время как putchar выводит символ на экран (стандартный вывод stdout). В программах часто бывает нужно вводить и одновременно выводить символы. Здесь показан цикл while, в котором вводятся и выводятся символы, включая символ конца строки:

do < letter = getchar( ); putchar(letter); >while (letter != '\n');

Поскольку getchar и putchar работают с целыми значениями, операторы в предыдущем примере можно комбинировать следующим образом:

do putchar (letter = getchar( )); while (letter != '\n');

Здесь символ, полученный от getchar, присваивается переменной letter, в результате чего putchar выведет значение переменной letter.

291. getchar и putchar - макрокоманды

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

letter = getchar(); putchar(letter);

Если вы просмотрите заголовочный файл stdio.h, то вы найдете описания макрокоманд getchar и putchar. В разделе "Переназначение ввода-вывода и обработка командной строки" эти два макроопределения описаны более подробно.

292. Чтение символа с использованием прямого ввода-вывода

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

#include int getche(void);

В следующей программе GETCHE.С используется функция getche для ввода ответа Y (Да) или N (Нет) с клавиатуры:

#include #include #include void main(void) < int letter; printf("Продолжить? (Y/N): "); do < letter = getche ( ); letter = toupper (letter); >while ((letter != 'Y') && (letter != 'N') ); if (letter == 'Y' ) printf("\nВы ответили ДА (Y) \n "); else printf("\nВы ответили НЕТ (N) \n "); >

В отличие от программы GETCHAR.C, требующей от пользователя нажать Enter для ввода ответа, программе GETCHE.C ввод символа Y или N обрабатывается немедленно.

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

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

#include int getch(void);

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

#include #include #include void main(void) < int letter; printf("Введите строку символов и нажмите Enter\n "); do < letter = getch ( ); letter = toupper(letter); putch(letter); >while (letter != '\r'); >

294. Правильное использование управляющих символов '\r' и '\n'

Как известно, в языке Си употребляется специальный символ '\r' для задания действия "возврат каретки". Вместе с тем употребляется также и символ '\n', обозначающий "возврат каретки и перевод строки" и задающий переход на новую строку. При использовании в программе буферизованного ввода (например, с помощью макрокоманды getchar) нажатие клавиши Enter преобразуется в последовательность действий ВОЗВРАТ КАРЕТКИ и ПЕРЕВОД СТРОКИ. Если же используется прямой ввод-вывод с применением функций getch и getche, то ввод Enter воспринимается просто как возврат каретки ('\r').Для проверки правильного использования специального символа в программе предлагается следующий тест:

do < letter = getcharO; putchar(letter); >while (letter != '\n'); do < letter = getch(); putchar(letter); >while (letter != '\r');

295. Реализация прямого вывода

Как уже известно, функции getch и getche дают возможность осуществить в программе ввод с клавиатуры непосредственно, игнорируя буферизацию потоков ввода (основанную на файловой системе). Подобным образом программа может выполнить быстрый экранный вывод, используя функцию putch:

#include int putch(int letter);

При успешном завершении putch возвращает выведенный на экран символ, в случае ошибки - EOF. Для выполнения быстрого вывода putch либо связывается с видеосервисом BIOS, либо обращается к видеопамяти компьютера непосредственно. С другой стороны, такие функции как putchar реализуются с помощью функций файловой системы, которые, в свою очередь, уже обращаются к функциям BIOS. Функция putch делает преобразования символа "перевод строки" в последовательность "возврат каретки" и "перевод строки". В следующей программе PUTCH.C для 1001-кратного вывода букв английского алфавита используются функции putch и putchar. После этого программа показывает время, затраченное на выполнение каждой из этих двух функций.

#include #include #include void main(void)

296. Возврат символа в буфер клавиатуры

Как известно, чтение символа, введенного с клавиатуры, может быть выполнено функцией getch. Иногда возникает необходимость чтения и запоминания подряд всех нажимаемых клавиш до тех пор, пока не встретится заданный символ, а затем - обработки всей совокупности. После завершения обработки считываются остальные символы. При таком сценарии программы может понадобиться "прочитать назад" какой-нибудь символ, т.е. перейти к предыдущему. Для этого используется функция ungetch:

#include int ungetch(int character);

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

#include #include #include void main(void) < int letter; int done = 0; int uppercase_found = 0; do < letter = getch(); if (islower(letter)) putchar(letter); else < if (isupper(letter)) < ungetch(letter); uppercase found = 1; putchar('\n'); >done = 1; > > while (! done); if (uppercase_found) do < letter = getch(); putchar(letter); >while (letter != '\r'); >

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

ungetc(letter, stdin );

297. Быстрый форматированный вывод с использованием функции cprintf

Как известно, функция printf дает возможность организовать в программе форматированный вывод. В определении функции printf устройство вывода задается ссылкой на файловый поток stdout - стандартны и вывод. Поэтому вывод результата работы printf можно переназначать с экрана дисплея в файл или на другое устройство. Такое использование stdout в функции printf предопределяет использование файловой системы языка Си, внутри которой используются функции DOS, которые, в свою очередь, вызывают служебные функции BIOS. Для более быстрого форматированного вывода можно использовать функцию cprintf, которая работает непосредственно с BIOS или с видеопамятью компьютера:

#include int cprintf(const char *format[,arguments. ]);

Следующая программа CPRINTF. С выводит строку "1001 совет по С/С++" 1001 раз, используя сначала printf и затем cprintf. После этого программа показывает время, затраченное на выполнение каждой из этих функций:

#include #include #include void main(void) < int count; time_t start_time, stop_time; time(&start_time); for (count = 0; count < 1001; count++) printf("1001 совет по C/C++\r\n "); time(&stop_time); printf("\n\nHa вывод функцией printf требуется %d секунд\n ", stop_time-start_time); printf("Нажмите любую клавишу. \n "); getch(); time(&start_time); for (count = 0; count < 1001; count++) cprintf("1001 совет по C/C++\r\n "); time(&stop time); printf("\n\nHa вывод функцией cprintf требуется %d секунд\n ", stop time-start time); >

Примечание. Функция cprintf не выполняет преобразование символа "переход на новую строку " и последовательность "ВОЗВРАТ КАРЕТКИ/ПЕРЕВОД СТРОКИ".

298. Быстрый форматированный ввод с клавиатуры

Для выполнения быстрого вывода данных на экран дисплея без привлечения файловой системы используется функция cprintf (C297). Похожим образом функция cscanf дает возможность выполнить в программе быстрый форматированный ввод с клавиатуры:

#include int cscanf(char *format[,arguments]);

В следующей nporpaммe CSCANF.C выдается подсказка на ввод трех целых чисел, после чего выполняется считывание значений с использованием cscanf:

#include void main(void)

299. Вывод на экран символьной строки

Форматированный вывод на экран дисплея выполняется в программе с помощью функции printf. Используя printf, можно вывести строку, целое число, число с плавающей точкой или произвольную комбинацию перечисленных типов значений. Если в программе необходимо вывести только символьную строку, то эффективнее использовать функцию puts вместо printf:

#include int puts(const char *string);

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

#include #include #include void main(void) < int count; time_t start_time, stop_time; time(&start_time); for (count =0; count < 1001; count++) printf("1001 совет по C/C++\n"); time(&stop_time); printf("\n\nHa вывод функцией printf требуется %d секунд\n", stop_time-start_time); printf("Нажмите любую клавишу. \n"); getch( ); time(&start_time); for (count = 0; count < 1001; count++) puts("1001 совет по С/С++\n"); time(&stop_time); printf("\n\nHa вывод функцией puts требуется %d секунд\n", stop time-start time); >

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

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

Мы уже видели (С299), как с помощью функции puts выполнить вывод символьной строки. Однако, функция puts использует файловую систему и осуществляет вывод на stdout, стандартное устройство вывода (благодаря чему допускает возможность переназначения). Используя функцию cputs, вывод строки можно выполнить быстрее:

#include int cputs(const char string);

Как uputs, функция cputs выводит строки, оканчивающиеся двоичным нулем. В отличие от puts, функция cputs невыполняет автоматическое добавление символа перевода строки. В следующей программе CPUTS.C функции puts и cputs используются для 1001-кратного вывода строки "1001 совет по C/C++". После этого программа показывает время, затраченное на выполнение каждой из этих функций:

#include #include #include void main(void) < int count; time_t start_time, stop_time; time(&start_time); for (count =0; count < 1001; count++) puts("1001 совет по C/C++"); time(&stop_time); рrintf ("\n\nВывод с использованием puts требует %d секунд\n", stop_time-start_time); printf("Нажмите любую клавишу. \n"); getch( ); time(&start_time); for (count =0; count < 1001; count++) cputs ("1001 совет по C/C++\r\n"); time(&stop_time); printf("\n\nВывод с использованием cputs требует %d секунд\n", stop_time-start_time); >

301. Считывание символьной строки с клавиатуры

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

#include char *gets(char *string);

При успешном выполнении функция gets возвращает указатель на символьную строку. В случае ошибки или обнаружения конца файла gets возвращает значение NULL. Функция gets считывает все символы строки сразу, включая символ перевода строки. При этом gets заменяет символ перевода строки на двоичный нуль. В следующей программе GETS.C функция gets используется для чтения строки символов, введенной с клавиатуры:

#include void main(void)

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

302. Быстрый ввод строки с клавиатуры

Функция gets (C301) дает возможность выполнить в программе считывание символьной строки, введенной с клавиатуры. Функция gets на самом-то деле осуществляет ввод со стандартного устройства stdin и использует для этого файловую систему, что обеспечивает возможность переназначения ввода. Если переназначение ввода при выполнении программы не планируется использовать, то для ввода строки символов с клавиатуры эффективнее использовать функцию cgets:

#include char *cgets(char *string);

При успешном завершении cgets возвращает указатель на string[2]. В случае ошибки возвращается NULL-значение. Поведение функции cgets отличается от поведения функции gets. Поскольку при вызове cgets создается как параметр символьная строка, то перед вызовом необходимо присвоить элементу siring [О] максимально возможное количество считываемых символов. После выполнения string[1] будет содержать количество фактически считанных символов. Реальная строка символов, оканчивающаяся двоичным нулем, фактически начинается с элемента string[2]. В следующей программе CGETS.C демонстрируется использование функции cgets:

#include #include void main(void) < char buffer[256]; buffer[0] = 253; // Максимальное количество считываемых символов printf("Введите строку и нажмите Enter\n"); cgets(buffer); printf("\n\nСчитано %d символов\n", buffer[l]); printf("Введена строка: %s\n", &buffer[2]); >

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

303. Вывод на экран в цветном режиме

Вывод на экран в цветном режиме можно осуществить, используя управляющие последовательности драйвера ANSI.SYS. Кроме того, многие Си-компиляторы предоставляют специальные функции вывода, которые могут выводить текст в различных цветах. В Borland C++ и Microsoft С ++ такой функцией является функция outtext (называемая _outtext в Microsoft C++). В Borland C++ функция outtext может использоваться только в графическом режиме, тогда как функция _outtext в Microsoft C++ работает как в графическом, так и в текстовом режиме. При необходимости вывода в цветном режиме за информацией об использовании этих функций следует обращаться к документации по компилятору. Компилятор обеспечивает функции по установке курсора в определенную позицию выводимого текста, выбору цвета и графического режима. Поскольку эти функции обычно привязываются к конкретному компилятору, они не описаны в этой книге.

304. Очистка экрана дисплея

Как правило. Си-компиляторы не предоставляют функцию, очищающую экран дисплея. Однако, в компиляторах Borland и Microsoft имеется функция clrscr для очистки содержимого окна в текстовом режиме:

#include void clrscr(void);

В следующей программе CLRSCR.C функция clrscr используется для очистки экрана дисплея:

#include void main(void)

305. Очистка текущей строки до ее конца

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

#include void clreol(void);

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

306. Удаление текущей строки с экрана

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

#include void delline(void);

В следующей программе DELLINE.C экран заполняется 24 строками текста. После нажатия Enter программа, используя delline, уничтожит строки 12, 13 и 14.

#include void main(void)

307. Позиционирование курсора на экране

Для позиционирования курсора в операциях вывода на экран может быть использован 1 драйвер ANSI.SYS. Многие Си-компиляторы, работающие в среде DOS, предоставляют функцию gotoxy, которая дает возможность перемещать курсор по заданным значениям столбца и строки:

#include void gotoxy(int column, int row);

Параметр column указывает номер столбца (х-координата) от 1 до 80. Параметр row указывает номер строки (у-координата) от 1 до 25. Если эти ограничения нарушены, вызов функции gotoxy игнорируется. В следующей программе GOTOXY.C функция gotoxy используется для последующего вывода в указанной позиции:

#include void main(void)

308. Определение позиции строки и столбца

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

#include int wherex(void); int wherey(void);

В следующей программе WHEREXY.C сначала очищается экран и выводятся три строки. Затем функции wherex и wherey используются для определения текущей позиции курсора:

#include void main(void)

309. Вставка пустой строки

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

#include void insline(void);

В результате вызова функции insline текст, следующий за курсором, опускается на одну строку. Нижняя строка исчезает с экрана. В следующей программе INSLINE.C сначала выводится информация, заполняющая весь экран. После этого программа использует функцию insline для вставки текста в строке 12:

#include void main(void)

310. Копирование текста с экрана в буфер

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

#include int gettext(int left, int top, int right, int bottom, void *buffer);

В параметрах left и top указываются, соответственно, номер столбца и номер строки, верхнего левого угла прямоугольной области экрана, текст которой должен быть скопирован в буфер. В параметрах right и bottom указываются номер столбца и номер строки нижнего правого угла этой области. Параметр buffer -область памяти, в которую копируются текст и его атрибуты. Для хранения атрибутов одного символа текста используется один байт. Например, если копируется 10 символов, то для буфера хранения выделяется 20 байтов, 10 символов ASCII и 10 атрибутных байтов. В следующей программе SAVESCR.C текущее содержимое экрана в текстовом режиме сохраняется в файле SAVESCR.DAT.

#include #include #include #include void main(void) < char buffer[8000]; int handle; if ((handle = creat("SAVESCR.DAT", S_IWRITE)) == -1) cprintf("Ошибка при открытии файла SAVESCRN.DAT\r\n"); else < gettext(1, 1, 80, 25, buffer); write(handle, buffer, sizeof(buffer)); close(handle); >>

Примечание: В большинстве случаев текущий атрибут текста равен 7. Если попробовать вывести содержимое файла SAVESCR.DAТ c помощью команды TYPE, то система будет издавать звук на каждом атрибутном символе.

311. Вывод текстового буфера в указанное место экрана

Как уже упоминалось, многие Си-компиляторы, работающие в среде DOS, предоставляют функции, которые могут использоваться в программах для управления выводом на экран. Например, в С310 для копирования заданной области экрана в буфер (вместе с атрибутными символами) была использована функция gettexl. Копию содержимого экрана, сохраненную в буфере, можно вывести обратно на экран, используя функцию puttext:

#include int puttext(int left, int top, int right, int bottom, void *buffer);

В параметрах left, top, right и bottom указывается прямоугольная область экрана, в которую выводится содержимое буфера. Параметр buffer содержит символы и их атрибуты, сохраненные ранее функцией getlext. В следующей программе PUTTEXT.C организуется передвижение текста "Ямса. 1001 Совет по С/ C++" по экрану до тех пор, пока не будет нажата клавиша:

#include #include #include #include #include #include void main(void) < char buffer[128]; int row, column; clrscr( ); cprintf("1001 совет по C/C++\r\n"); gettext(1, 1, 23, 1, buffer); while (! kbhit( )) < clrscr( ); row =1 + random(24); column = 1 + random(58); puttext(column, row, column+22, row, buffer); delay(2000); >>

312. Определение параметров текстового режима экрана

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

#include void gettextinfo(struct text_info *data);

Параметр data задает указатель на структуру типа text_info, имеющую вид:

struct text_info < unsigned char winleft; // Левая граница окна unsigned char wintop; // Верхняя граница окна unsigned char winright; // Правая граница окна unsigned char winbottom; // Нижняя граница окна unsigned char attribute; // Текущий атрибут текста unsigned char normattr; // Нормальный атрибут текста unsigned char currmode; // Текущий текстовый режим unsigned char screenheight; // Количество строк unsigned char screenwidth; // Количество столбцов unsigned char curx; // Текущая позиция курсора, столбец unsigned char cury; // Текущая позиция курсора, строка >;

В программе TEXTINFO.C функция gettextinfo используется для вывода текущих параметров экрана:

#include void main(void)

313. Управление цветом на экране

Вывод в цвете в программе может быть организован с использованием управляющих последовательностей драйвера ANSI.SYS. Однако, многие Си-компиляторы в среде DOS предоставляют функцию textattr, в которой можно указать цвет текста и цвет фона:

#include void textattr(int attribute);

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

Таблица 313. Параметры кодов цветов

В следующей программе TEXTATTR.C демонстрируются допустимые цвета текста:

#include void main(void) < int color; for (color =1; color < 16; color++) < textattr (color); cprintf("Текущий цвет - %d\r\n", color); >textattr(128 + 15); cprintf("Мерцание включено\r\n"); >

314. Цвет фона

Функция textattr в программе выбирает цвет для текста и фона (С313). Для установки цвета фона функцией textattr программа должна присвоить соответствующие значения цвета битам с 4-го по 6-й. Для этого можно либо использовать битовую операцию СДВИГ ВЛЕВО (

В программе TXTCOLOR.C приводится использование функции textcolor для установки цвета текста:

#include void main(void) < int color; for (color = 1; color < 16; color++) < textcolor(color); cprintf("Текущий цвет - %d\r\n", color); >textcolor(128 + 15); cprintf("Мерцание разрешено\r\n"); >

316. Установка цвета фона с помощью функции textbackground

Как уже известно, Си-компиляторы в среде DOS предоставляют функцию textattr, которая дает возможность выбрать необходимые цвета для текста и фона при выводе текста. Для упрощения процесса установки цвета для фона можно использовать функцию textbackground:

#include void textbackground (int backgroundcolor);

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

Таблица 316. Допустимые значения цветов фона

В программе BACKGRND.C используется функция lextbackground для установки цвета фона:

#include void main(void) < int color; for (color = 0; color < 8; color++) < textbackground(color); cprintf("Текущий цвет - %d\r\n", color); cprintf("Для продолжения нажмите любую клавишу \r\n"); getch( ); >>

317. Управление яркостью при выводе текстов

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

#include void highvideo(void); void lowvideo(void); void normvideo(void);

Эти функции управляют яркостью вывода текста на экран. В следующей программе NTENSITY.C демонстрируется использование этих функций.

#include void main(void)

318. Определение текущего текстового режима

Многие Си-компиляторы в среде DOS предоставляют функции для управления экранныи выводом. При их использовании в программе может возникнуть необходимость определять и, возможно, изменять параметры текущего текстового режима экрана. Например, программа, рассчитанна на вывод 80 колонок текста, может выводить неверные результаты в текстовом режиме на 40 колонок. Для изменения параметров текущего текстового режима используется функция textmode:

#include void textmode(int desired mode);

Параметр desired_mode указывает требуемый текстовый режим. В табл. 318 даны допустимые текстовые режимы.

Таблица 318. Допустимые текстовые режимы

Следующий оператор, например, устанавливает 80 столбцов и 43 строки текста в EGA или режим 80Х50 в VGA:

textmode(C4350);

Примечание: Если в программе использована функция textmode для изменения текущего текстового режима, то это изменение остается в силе и после выхода из программы.

319. Перемещение текста на экране

Как известно, многие Си-компиляторы в среде DOS предоставляют множество функций для управления экранным выводом. При этом может возникнуть необходимость копирования или перемещения текста с одной части экрана на другую. Для копирования текста на экране программа может использовать функцию movetext:

#include int movetext(int left, int top, int right, int bottom, int destination_left, int destination_top);

Параметры left, top, right и bottom задают прямоугольную область текста, подлежащего копиро-ванию.Параметры destination_left и destination_top задают позицию левого верхнего угла, куда надлежит копировать текст. В следующей программе MOVETEXT.C сначала на экран выводится пять строк текста, азатем ожидается нажатие клавиши. После этого программа выполняет копирование текста на новое место.

#include void main(void)

Для перемещения текста без сохранения его на старом месте (в отличие от копирования) необходимо удалить скопированный текст после завершения movetext.

320. Установка размеров текстового окна

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

#include void window(int left, int top, int right, int bottom);

В параметрах left, top, right и bottom задаются левый верхний и правый нижний углы области экрана, в которую направляется вывод. В следующей программе WINDOW.C вывод ограничен верхней левой четвертью экрана:

#include void main(void) < int i, j; window(1, 1, 40, 12); for (i = 0; i < 15; i++) < for (j = 0; j < 50; j++) cprintf("%d", j); cprintf("\r\n"); >>

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

Как вывести char c

Друзья, подскажите. Нужно занести в массив mas x символов, а потом вывести этот массив.

#include #include int main()

Выводит **********@. то есть массив и за ним еще несколько лишних символов. в чем может быть проблема?

The First Person!
Форумчанин
Регистрация: 07.08.2007
Сообщений: 228

Вот в чем проблема! Поставь mas[x]='\0';

К тому же у тебя помимо этого много ошибок.

%s используется для вывода строки! Для вывода символа, ну и для ввода символа используется %c

Ну я так понял тебе весь массив надо заполнить символом '*'

И наконец для вывода всего массива используй puts(mas);

#include #include int main() < int i; char mas[10], g='*'; for(i=0;i<10;i=i+1)< mas[i]=g; >mas[10]='\0'; puts(mas); getch(); >

Программа обычно делает то что вы ей сказали сделать, а не то что бы вы хотели, чтобы она сделала.
Последний раз редактировалось MAKEDON; 15.04.2009 в 19:13 .