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

#include <stdio.h> 

int getchar(void);

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

#include <stdio.h> 
#include <ctype.h>

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 - стандартный ввод (по умолчанию соответствует вводу с клавиатуры).

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

#include <stdio.h>

int putchar(int letter);

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

#include <stdio.h>

void main(void)
{
    int letter;

    for (letter = 'A'; letter <= 'Z'; letter++) 
	putchar(letter);
}

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

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

#include <stdio.h>

void main(void) 
{
    int letter;

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

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

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

#include <stdio.h>

void main(void)
{
    char string[128];

    int index = 0;
    int letter;

    printf("Введите строку и нажмите Enter\n");
    while ((letter = getchar ( )) != '\n') 
	string [index++] = letter;

    string[index] = NULL;
 
    printf("Введенная строка : %s\n ", string);
}

Известно, что 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.

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

letter = getchar();

putchar(letter);

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

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

#include <conio.h> 

int getche(void);

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

#include <stdio.h> 
#include <ctype.h> 
#include <conio.h>

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 обрабатывается немедленно.

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

#include <conio.h>

int getch(void);

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

#include <stdio.h> 
#include <conio.h> 
#include <ctype.h>

void main(void) 
{
    int letter;

    printf("Введите строку символов и нажмите Enter\n ");

    do {
letter = getch ( );
letter = toupper(letter);
putch(letter);
      }	while (letter != '\r');
}

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

do {
    letter = getcharO;
    putchar(letter);
 }  while (letter != '\n');

do {
    letter = getch();
    putchar(letter);
}  while (letter != '\r');

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

#include <conio.h> 

int putch(int letter);

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

#include <stdio.h>
#include <conio.h>
#include <time.h>

void main(void)
{
    int letter;
    int count;

    time_t start_time, stop_time;

    time(&start_time);
    for (count = 0; count < 1000; count++) 
	for (letter = 'A'; letter <= 'Z'; letter++) 
    putchar(letter);
    time(&stop_time);

    printf("\n\nВывод с использованием putchar требует %d секунд\n ",
	 stop time-start time);
    printf("Нажните любую клавишу...\n ");
    getch();

    time(&start_time);
    for (count = 0; count < 1000; count++) 
	for (letter = 'A'; letter <= 'Z'; letter++) 
    putch(letter);
    time(&stop_time);

    printf("\n\nВывод с использованием putch требует %d секунд\n ", 
	stop time-start time);
}

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

#include <conio.h> 

int ungetch(int character);

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

#include <stdio.h> 
#include <ctype.h>
#include <conio.h>

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 );

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

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

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

#include <stdio.h> 
#include <conio.h> 
#include <time.h>

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 не выполняет преобразование символа "переход на новую строку " и последовательность "ВОЗВРАТ КАРЕТКИ/ПЕРЕВОД СТРОКИ".

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

#include <conio.h> 

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

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

#include <conio.h>

void main(void) 
{
    int a, b, c;

    cprintf("Введите З целых числа и нажмите Enter\r\n");
    cscanf("%d %d %d", &а, &b, &c);
    cprintf("Введенные значения: %d %d %d\r\n", а, b, с);
}

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

#include <stdio.h> 

int puts(const char *string);

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

#include <stdio.h> 
#include <conio.h>
#include <time.h>

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 сама автоматически добавляет символ перевода строки, символьная строка, задаваемая в этой функции в качестве параметра, не содержит этого символа.

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

#include <conio.h> 

int cputs(const char string);

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

#include <stdio.h> 
#include <conio.h> 
#include <time.h>

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);
}

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

#include <stdio.h>

char *gets(char *string);

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

#include <stdio.h>

void main(void)
{
    char string[256];

    printf("Введите строку символов и нажмите Enter\n");
    	gets(string);

    printf("Введенная строка: %s\n", string);
}

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

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

#include <conio.h>

char *cgets(char *string);

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

#include <stdio.h> 
#include <conio.h>

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]);
}

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

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

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

#include <conio.h>

void clrscr(void);

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

#include <conio.h>

void main(void)
{
    clrscr( );
}

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

#include <conio.h> 

void clreol(void);

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

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

#include <conio.h>

void delline(void);

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

#include <conio.h>

void main(void)
{
    int line;

    clrscr( );

    for (line = 1; line < 25; line++) 
	cprintf("Это - строка номер %d\r\n", line);
    cprintf("Для продолжения нажмите любую клавишу: ") 
    getch( );

    gotoxy(1, 12);

    for (line = 12; line < 15; line++) 
	delline();

    gotoxy(1, 25);
}

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

#include <conio.h> 

void gotoxy(int column, int row);

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

#include <conio.h>

void main(void) 
{
    clrscr();

    gotoxy(1, 5);
    	cprintf("Вывод со строки номер 5 , столбца номер 1\n");

    gotoxy (20, 10);
    	cprintf("Вывод со строки номер 10 , столбца номер 20\n");
}

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

#include <conio.h>

int wherex(void);
int wherey(void);

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

#include <conio.h>

void main(void) 
{
    int row, column;

    clrscr();

    cprintf("Это - строка номер 1\r\n");
    cprintf("Строка 2 немного длиннее\r\n");
    cprintf("Это - последняя строка");

    row = wherey();
    column = wherex();

    cprintf("\r\nТекущая позиция курсора - на строке номер %d 
"и столбце номер %d", row, column);
}

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

#include <conio.h> 

void insline(void);

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

#include <conio.h>

void main(void) 
{
    int line;

    clrscr();

    for (line = 1; line < 25; line++) 
	cprintf("Это - строка номер %d\r\n", line);

    cprintf("Для продолжения нажмите любую клавишу: ") 
    	getch( );

    gotoxy(1, 12);

    insline ( );
    cprintf("Это - текст на новой строке !!!");
    gotoxy(1, 25);
}

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

#include <conio.h>

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 <conio.h> 
#include <io.h> 
#include <fcntl.h> 
#include <sys\stat.h>

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, то система будет издавать звук на каждом атрибутном символе.

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

#include <conio.h>

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

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

#include <conio.h> 
#include <io.h>
#include <fcntl.h> 
#include <sys\stat.h> 
#include <stdlib.h> 
#include <dos.h>

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);
       }
}

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

#include <conio.h> 

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 <conio.h>

void main(void)
{
    struct text_info text;

    gettextinfo(&text);

    cprintf("Границы экрана от %d,%d до %d,%d\r\n",
	text.wintop, text.winleft, text.winbottom, text.winright);

    cprintf("Текущий атрибут текста - %d "
      "Нормальный атрибут текста - %d\r\n", 
	text.attribute, text.normattr);

    cprintf ("Высота экрана %d , ширина экрана %d\r\n", 
	text. screenheight, text.screenwidth);

    cprintf("Позиция курсора: строка номер %d столбец номер %d\r\n",
	text.cury, text.curx);
}

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

#include <conio.h> 

void textattr(int attribute);

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

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

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

#include <conio.h>

void main(void)
{
    int color;

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

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

struct TextColor {
unsigned char foreground:4;
unsigned char background:3;
unsinged char blinking:!;
};

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

#include <conio.h>

void main(void) 
{
    union TextColor { 
struct { 
  unsigned char foreground:4;
  unsigned char background:3;
 	  unsigned char blinking:1;
} color_bits;
        unsigned char value;
    } colors;
    colors.color_bits.foreground = BLUE;
    colors.color_bits.background = RED;
    colors.color_bits.blinking = 1;

    textattr(colors.value);

    clrscr( );
    cprintf("Это - другой цвет текста\n");
}

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

#include <conio.h> 

void textcolor(int foregroundcolor);

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

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

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

#include <conio.h> 

void main(void)
{
    int color;

    for (color = 1; color < 16; color++)
	{
    textcolor(color);
    cprintf("Текущий цвет - %d\r\n", color);
	}

    textcolor(128 + 15);
    cprintf("Мерцание разрешено\r\n");
}

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

#include <conio.h> 

void textbackground (int backgroundcolor);

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

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

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

#include <conio.h>

void main(void)
{
    int color;

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

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

#include <conio.h>

void highvideo(void);
void lowvideo(void);
void normvideo(void);

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

#include <conio.h>

void main(void)
{
    clrscr( );

    highvideo( );
    cprintf("Этот текст выводится с наибольшей яркостыо\r\n");

    lowvideo( );
    cprintf("Этот текст выводится с наименьшей яркостыо\r\n");

    normvideo( );
    cprintf("Этот текст выводится с нормальной яркостыо\r\n");
}

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

#include <conio.h> 

void textmode(int desired mode);

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

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

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

textmode(C4350);

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

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

#include <conio.h>

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 <conio.h> 

void main(void)
{
    int i;

    clrscr ( );
    for (i = 1; i <= 5; i++)
	cprintf("Этo - строка номер %d\r\n", i);

    cprintf("Нажмите любую клавишу\n\r");
	getch( );

    movetext(1, 1, 30, 6, 45, 18);
    	gotoxy(1, 24);
}

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

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

#include <conio.h> 

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

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

#include <conio.h>

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");
      }
}

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