Какие функции ввода вывода существуют в с
При запуске программы на Си автоматически открываются ряд потоков, основными из которых являются следующие:
- Стандартный поток ввода stdin
- Стандартный поток вывода stdout
- Стандартный поток вывода сообщений об ошибках stderr
Стандартный поток ввода stdin по умолчанию соответствует клавиатуре, а потоки stdout и stderr — экрану монитора.
Для управления вводом-выводом с помощью этих потоков используются ряд функций:
- getchar() : ввод с клавиатуры одного символа
- putchar() : вывод на консоль одного символа
- fgets() : ввод одной строки
- puts() / fputs() : вывод одной строки на консоль
- scanf() : ввод с консоли с форматированием данных
- sscanf() : ввод с из строки с форматированием данных
- printf() : вывод с форматированием данных
Функции printf и scanf уже рассматривались ранее, поэтому посмотрим, как применять остальные функции.
Ввод и вывод символов
Для ввода и вывода символа применяются функции getchar() и putchar() . Но следует сказать, что на самом деле они полноценными функциями не являются, а определены как макросы в заголовочном файле stdio.h :
#define getchar() getc(stdin) #define putchar(c) putc((c), stdout)
Вывод символа
Для вывода отдельного символа на консоль предназначена функция putchar() со следующим прототипом:
int putchar(int c);
Выводимый символ в виде числового кода передается в putchar в качестве параметра, он же возвращается функцией.
#include int main(void) < char c = 'A'; putchar(c); // Выводим символ A >
Ввод символа
Для ввода одного символа с клавиатуры применяется функция getchar() , которая имеет следующий прототип:
int getchar(void);
В качестве результата функция возвращает числовой код введенного символа.
При использовании функции getchar следует учитывать, что при печати текста посредством клавиатуры в буфер операционной системы заносятся коды печатаемых символов, а сами символы отображаются на экране. Поучение программой введенного символа из буфера производится с помощью нажатия клавиши Enter.
И если буфер операционной системы не пуст, то при вызове функции getc() она получает очередной символ из буфера. Если же буфер пуст, то происходит чтение байта из потока ввода с помощью системной функции, название которой зависит от операционной системы.
При этом при нажатии клавиши Enter, в буфер также помещается код этой клавиши. То есть если мы введем один символ и нажмем на Enter, в буфере окажутся два числовых кода — введенного символа и клавиши Enter. И это надо учитывать при работе с функцией getchar. В частости, рассмотрим простой, но показательный пример:
#include int main(void) < printf("1"); getchar(); // ожидание ввода символа printf("2"); getchar(); // ожидание ввода символа printf("3"); return 0; >
Сначала на экран выводится цифра 1, после чего функция getchar ожидает ввода символа. Если после ввода символа мы нажмем Enter, то в буфер будет помещены два числовых кода — введеного символа и клавиши Enter. Поэтому при втором вызове getchar эта функция считывает байт из буфера — то есть числовой код клавиши Enter.
Например, введем при первом вызове функции getchar символ «a», а затем Enter:
1a 23
Но если при каждом вызове getchar мы будем только нажимать клавишу Enter, тогда в буфер будет заноситься только код этой клавиши, и соответственно программа будет работать, как и ожидалось:
1 2 3
Применим функции getchar и putchar для ввода и вывода символов с клавиатуры:
#include int main(void) < int c; while((c=getchar())!=EOF) < putchar(c); >return 0; >
Функция getchar() считывает числовой код символа, который потом выводится в функции putchar() . Для вывода из программы необходимо ввести комбинацию клавиш Ctrl+C.
Ввод и вывод строк
Вывод строк и puts
Для вывода одной строки на консоль предназначена функция puts() со следующим прототипом:
int putchar(char *s);
В качестве параметра передается указатель на строку, а возвращаемым результатом функции является последний выведенный символ.
При этом функция puts() будет выводить символы переданной строки, пока не дойдет до нулевого символа ‘\0’. Если же выводимый массив символов не содержит этого символа, то результат программы неопределен. Например:
#include int main(void) < puts("Hello World"); // выводим строковый литерал char* name = "Hello Metanit.com"; puts(name); // выводим значение переменной return 0; >
Hello World Hello Metanit.com
Вывод строк и fputs
Функция fputs() также записывает в поток вывода строку, то есть набор символов, который завершается символом ‘\0’. При записи строки нулевой символ ‘\0’ не записывается. Она имеет следующий прототип:
int fputs(const char *s, FILE *stream);
Первый параметр функции — записываемая строка, а второй — указатель на поток вывода. В качестве результата функция возвращает неотрицательное целое число. При ошибках в процессе записи возвращается значение EOF .
Применим функцию для записи в стандартный поток вывода, то есть на консоль. В этом случае в качестве второго параметра надо передать значение stdout :
#include int main(void)
Ввод строк и fgets
Для ввода строки с клавиатуры применяется функция fgets() , которая имеет следующий прототип:
char *fgets(char *str, int count, FILE *stream);
- char *str : строка, в которую производится считывание.
- int count : сколько символов необходимо считывать.
- FILE *stream : файловый поток, из которого производится считывание. В качестве потока ввода может выступать и консольный ввод.
Функция fgets() прекращает считывание, когда пользователь нажимает клавишу ENTER, то есть когда в поток добавляется символ перевода строки.
Рассмотрим считывание строки с консоли. Для этого в качестве третьего параметра в функцию передается значение stdin :
#include #define MAX 15 int main(void)
Здесь функция fgets считывает не более 15 символов в строку name, а В реальности функция предложит ввести 14 символов, так как последний символ зарезервирован для нулевого символа ‘\0’. Если будет введено больше символов, то fgets все равно считает не более 15 символов. Таким образом функция позволяет проверить количество считываемых символов и поэтому считается безопасной.
Пример работы программы:
Enter name: Tom Smith Your name: Tom Smith
Стоит отметить, что функция fgets() возвращает указатель char * — указатель на буфер, в который считаны данные. В реальности это тот же самый буфер, который передавался в качестве первого параметра, то есть в примере выше — это массив name. Однако этот результат может нам пригодится для проверки успешности выполнения функции — если считывание прошло неудачно, то функция возвращает NULL :
#include #define MAX 15 int main(void) < char name[MAX]; printf("Enter name: "); if(fgets(name, MAX, stdin) != NULL) // if(fgets(name, MAX, stdin)) - можно сократить < printf("Your name: %s\n", name); >else < printf("Critical Error. "); >return 0; >
Для эмуляции ошибки можно передать в функцию вторым параметром число 0.
fgets и scanf
При использовании функции fgets() после функции scanf() мы можем столкнуться с некорректным вводом:
#include #define N 32 int main(void) < int age; char name[N]; // считываем возраст в переменную age printf("Input age: "); scanf("%d", &age); // считываем строку в переменну. name printf("Input name: "); fgets(name, N, stdin); // проверяем ввод printf("Age: %d\n", age); printf("Name: %s\n", name); >
В данном случае сначала с помощью функции scanf() считываем число в переменную age. После этого считываем имя — строку с помощью функции fgets() в переменную name. Но посмотрим, какой будет результат работы программы:
Input age: 39 Input name: Age: 39Name:
В данном случае мы видим, что ввод имени с помощью fgets вроде как пропускается. По крайней мере мы не можем ввести имя, а программа сразу же выводит результат.
Все дело в том, что функция scanf() считывает именно то, что ей предписано — число в виде переменной типа int. Все остальные символы остаются в буфере, в который предварительно попадают введенные с клавиатуры символы. Так, после ввода возраста мы нажимаем на клавишу Enter, и в буфер попадает символ «\n», то есть перевод строки. И fgets считывает этот символ из буфера, после чего ввод имени завершается. Очевидно, это не то поведение, на которое мы рассчитывали.
Чтобы исправить ситуацию, мы можем использовать различные хаки. Рассмотрим пару из них. Все они сводятся к тому, чтобы вынуть из буфера этот символ перевода строки.
Первый способ — считывание символа с помощью вызова scanf(«%*c») :
#include #define N 32 int main(void) < int age; char name[N]; // считываем возраст в переменную age printf("Input age: "); scanf("%d", &age); scanf("%*c"); // вытаскиваем символ из буфера // считываем строку в переменну. name printf("Input name: "); fgets(name, N, stdin); // проверяем ввод printf("Age: %d\n", age); printf("Name: %s\n", name); >
Второй способ — мы можем считать символ с помощью getchar() :
#include #define N 32 int main(void) < int age; char name[N]; // считываем возраст в переменную age printf("Input age: "); scanf("%d", &age); getchar(); // вытаскиваем символ из буфера // считываем строку в переменну. name printf("Input name: "); fgets(name, N, stdin); // проверяем ввод printf("Age: %d\n", age); printf("Name: %s\n", name); >
Результат работы программы:
Input age: 39 Input name: Tom Age: 39 Name: Tom
Какие функции ввода вывода существуют в с
Для вывода информации на консоль мы уже использовали встроенный метод Console.WriteLine . То есть, если мы хотим вывести некоторую информацию на консоль, то нам надо передать ее в метод Console.WriteLine:
string hello = "Привет мир"; Console.WriteLine(hello); Console.WriteLine("Добро пожаловать в C#!"); Console.WriteLine("Пока мир. "); Console.WriteLine(24.5);
Привет мир! Добро пожаловать в C#! Пока мир. 24,5
Нередко возникает необходимость вывести на консоль в одной строке значения сразу нескольких переменных. В этом случае мы можем использовать прием, который называется интерполяцией:
string name = "Tom"; int age = 34; double height = 1.7; Console.WriteLine($"Имя: Возраст: Рост: м");
Для встраивания отдельных значений в выводимую на консоль строку используются фигурные скобки, в которые заключается встраиваемое значение. Это можем значение переменной ( ) или более сложное выражение (например, операция сложения ). А перед всей строкой ставится знак доллара $.
При выводе на консоль вместо помещенных в фигурные скобки выражений будут выводиться их значения:
Имя: Tom Возраст: 34 Рост: 1,7м
Есть другой способ вывода на консоль сразу нескольких значений:
string name = "Tom"; int age = 34; double height = 1.7; Console.WriteLine("Имя: Возраст: Рост: м", name, height, age);
Здесь мы видим, что строка в Console.WriteLine содержит некие числа в фигурных скобках: , , . Это плейсхолдеры, вместо которых при выводе строки на консоль будут подставляться некоторые значения. Подставляемые значения указываются после строки через запятую.
При этом важен порядок подобных плейсхолдеров. Например, в данном случае после строки первой указана переменная name, потом height и потом age. Поэтому значение переменной name будет вставляться вместо первого плейсхолдера — (нумерация начинается с нуля), height — вместо , а age — вместо . Поэтому в итоге пи выводе на консоль строка
"Имя: Возраст: Рост: м"
будет заменена на
"Имя: Tom Возраст: 34 Рост: 1,7м"
Console.Write
Кроме Console.WriteLine() можно также использовать метод Console.Write() , он работает точно так же за тем исключением, что не добавляет переход на следующую строку, то есть последующий консольный вывод будет выводиться на той же строке.
string name = "Tom"; int age = 34; double height = 1.7; Console.Write($"Имя: Возраст: Рост: м");
Консольный ввод
Кроме вывода информации на консоль мы можем получать информацию с консоли. Для этого предназначен метод Console.ReadLine() . Он позволяет получить введенную строку.
Console.Write("Введите свое имя: "); string? name = Console.ReadLine(); Console.WriteLine($"Привет ");
В данном случае все, что вводит пользователь, с помощью метода Console.ReadLine() передается в переменную name.
Пример работы программы:
Введите свое имя: Том Привет Том
Особенностью метода Console.ReadLine() является то, что он может считать информацию с консоли только в виде строки. Кроме того, возможная ситуация, когда для метода Console.ReadLine не окажется доступных для считывания строк, то есть когда ему нечего считывать, он возвращаает значение null , то есть, грубо говоря, фактически отсутствие значения. И чтобы отразить эту ситуацию мы определяем переменную name , в которую получаем ввод с консоли, как переменную типа string? . Здесь string указывает, что переменная может хранить значения типа string, то есть строки. А знак вопроса ? указывает, что переменная также может хранить значение null , то есть по сути не иметь никакого значения. Далее мы более подробно разберем null и как с ним работать.
Однако, может возникнуть вопрос, как нам быть, если, допустим, мы хотим ввести возраст в переменную типа int или другую информацию в переменные типа double или decimal? По умолчанию платформа .NET предоставляет ряд методов, которые позволяют преобразовать различные значения к типам int, double и т.д. Некоторые из этих методов:
- Convert.ToInt32() (преобразует к типу int)
- Convert.ToDouble() (преобразует к типу double)
- Convert.ToDecimal() (преобразует к типу decimal)
Пример ввода значений:
Console.Write("Введите имя: "); string? name = Console.ReadLine(); Console.Write("Введите возраст: "); int age = Convert.ToInt32(Console.ReadLine()); Console.Write("Введите рост: "); double height = Convert.ToDouble(Console.ReadLine()); Console.Write("Введите размер зарплаты: "); decimal salary = Convert.ToDecimal(Console.ReadLine()); Console.WriteLine($"Имя: Возраст: Рост: м Зарплата: $");
При вводе важно учитывать текущую операционную систему. В одних культурах разделителем между целой и дробной частью является точка (США, Великобритания. ), в других — запятая (Россия, Германия. ). Например, если текущая ОС — русскоязычная, значит, надо вводить дробные числа с разделителем запятой. Если локализация англоязычная, значит, разделителем целой и дробной части при вводе будет точка.
Пример работы программы:
Введите имя: Том Введите возраст: 25 Введите рост: 1,75 Введите размер зарплаты: 300,67 Имя: Том Возраст: 25 Рост: 1,75м Зарплата: 300,67$
Работа с потоками ввода-вывода в C++
Программа, выводящая в консоль сообщение Hello, world! , с которой традиционно начинают изучение языка программирования, на языке C++ выглядит следующим образом:
#include using namespace std; int main() cout <"Hello, world!" <endl; return 0; > Директива #include и функция main() знакомы читателю по языку C. Способ вывода строки в консоль отличается от стандартной функции printf языка C и даёт нам повод начать разговор про C++.
Чтобы считать данные из стандартного потока ввода stdin , необходимо воспользоваться объектом cin и оператором извлечения >> .
int a; double x; cin >> a >> x; Здесь мы снова построили цепочку вызовов и получили значения сразу для двух переменных. При обращении к потоку ввода мы не указывали тип данных, которые необходимо прочитать. Оператор >> сам определяет типы объектов и заполняет их из потока ввода.
Объекты cout , cin , а также операторы вставки и извлечения определены в заголовочном файле
Работа с файлами
Все операции ввода-вывода в C++ организованы через потоки и операторы > . Мы уже рассмотрели операции ввода-вывода в потоки stdout и stdin . Операции ввода-вывода с файлами устроены схожим образом. Для работы с файловыми потоками необходимо подключить заголовочный файл . Следующая программа создает файл test.txt и записывает в него строку Hello, world!
#include using namespace std; int main() ofstream ofile("test.txt", ios::out); if (ofile.is_open()) ofile <"Hello, world!"; > return 0; > Сначала мы создали объект типа ofstream . В его конструктор мы передали имя файла test.txt и флаг ios::out , указывающий на то, что мы собираемся осуществлять операции вывода. Всегда необходимо проверять, что операция открытия/создания файла прошла успешно. Если не выполнить эту проверку, то, если по какой-либо причине файл открыть не удалось, дальнейшие шаги приведут к аварийному завершению программы. Метод is_open() позволяет выполнить такою проверку. Дальше идет уже знакомый нам вызов оператора
Чтение данных из файла производится следующим образом:
#include #include #include using namespace std; int main() ifstream ifile("test.txt", ios::in); if (ifile.is_open()) string line; while (ifile >> line) cout <line <' '; > > return 0; > Здесь мы воспользовались файловым потоком ввода ifstream и флагом ios::in . В этой программе мы создали переменную line типа string , чтобы хранить считанные из файла данные. Неочевидным моментом здесь является использование цикла while . Дело в том, что оператор >> считывает символы до тех пор, пока не встретит разделитель (пробел, табуляция или перенос строки). Если бы мы вызвали этот оператор один раз, то в переменную line было бы записано Hello, , а это не то, чего мы хотели. Цикл позволяет прочитать файл до конца.
Если же мы хотим прочитать только одну строчку из файла, то можно воспользоваться функцией getline , определенной в . С этой функцией наша программа примет следующий вид:
#include #include #include using namespace std; int main() ifstream ifile("test.txt", ios::in); if (ifile.is_open()) string line; getline(ifile, line); cout <line <end; > return 0; > Наконец, для чтения символов из потока по одному можно использовать метод get()
char c; while (ifile.get(c)) cout <c; > Аналогичный метод есть и у объекта cin .
По умолчанию файловые потоки работают в текстовом режиме, т.е. передают и принимают строковые символы. В некоторых случаях необходимо работать непосредственно с последовательностью байт, которые не должны быть интерпретированы как строковые символы. Для таких случаев существует флаг ios::binary . Детали работы с бинарными файлами смотрите в документации.
Строковые потоки
Часто бывает удобно работать со строковыми потоками. Инструменты для работы со строковыми потоками подключаются с помощью заголовочного файла . Строковые потоки позволяют удобно инициализировать объекты различных типов из их текстового представления. Представим себе, что мы получили географические координаты НГУ в виде строки «(54.847830, 83.094392)» . Наша задача извлечь из строки две величины типа double . Сделать это можно следующим образом:
#include #include #include using namespace std; int main() string nsucoor("(54.847830, 83.094392)"); stringstream ss(nsucoor); double lat, lon; ss.ignore(1); // skip '(' ss >> lat; ss.ignore(2); // skip ", " ss >> lon; cout <lat <", " <lon <endl; return 0; > Резюме
Мы обсудили, что все операции ввода-вывода в С++ реализованы единообразно с помощью потоков. Вывод в поток осуществляется с помощью оператора вставки > . Мы рассмотрели три типа потоков: стандартные, файловые и строковые. Этого достаточно для уверенного начала работы с потоками ввода-вывода в C++.
Документация
- http://www.cplusplus.com/reference/iolibrary/
- https://en.cppreference.com/w/cpp/io
Обзор средств ввода-вывода в C++
Приложение, написанное на любом языке программирования, должно взаимодействовать с окружающим миром. Иначе пользы от него не будет. Как правило, такое взаимодействие осуществляется посредством ввода-вывода информации на монитор или в файл. Правда, есть некоторое множество программ, которые не используют файловый или консольный ввод-вывод: это программы, осуществляющие низкоуровневое взаимодействие с аппаратной частью компьютера и периферией (ядро ОС, драйверы и пр.), но это уже экзотика.
В стандартном C++ существует два основных пути ввода-вывода информации: с помощью потоков, реализованных в STL (Standard Template Library) и посредством традиционной системы ввода-вывода, унаследованной от C. Если копнуть немного глубже, то окажется, что и потоки, и традиционная система ввода-вывода для осуществления необходимых действий используют вызовы операционной системы. И это правильно.
- Традиционный ввод-вывод
- Пример использования stdio
- Пример использования потоков STL
Дальнейшее изложение не претендует на полноту, но описывает основные принципы использования библиотек. Подробности использования можно посмотреть в многочисленной литературе по C++ и STL, в MSDN и пр.
Традиционный ввод-вывод
Для использования традиционного ввода-вывода в духе C, в программу необходимо включить заголовочный файл . (Разумеется, компилятор должен иметь доступ к соответствующей объектной библиотеке для правильной сборки исполняемого файла.)
Библиотека stdio предоставляет необходимый набор функций для ввода и вывода информации как в текстовом, так и в двоичном представлении. Следует отметить, что в отличие от классической C‑библиотеки, в современных библиотеках имеются более безопасные аналоги «классических» функций. Как правило, они имеют такое же имя, к которому добавлен суффикс _s. Рекомендуется использовать именно эти, безопасные функции.
Самая Первая Программа с использованием библиотеки stdio выглядит так:
int main()
При запуске консольного приложения неявно открываются три потока: stdin — для ввода с клавиатуры, stdout — для буферизованного вывода на монитор и stderr — для небуферизованного вывода на монитор сообщений об ошибках. Эти три символа определены посредством .
В stdio для консольного ввода-вывода предусмотрена отдельная группа функций. Однако эти функции, как правило, являются обёртками для аналогичных функций файлового ввода-вывода, для которых аргумент типа FILE задан по умолчанию.
Самая Первая Программа с использование файлового вывода из библиотеки stdio выглядит так:
int main()
Некоторые популярные функции из stdio:
Сущность FILE представляет собой структуру, в которой хранится вся информация для управления потоком ввода-вывода.
Файл открывается функцией fopen(), которой передаются два параметра. Первый параметр определяет имя файла. Второй — определяет режим открытия файла: чтение, запись, произвольный доступ и т.п., а также указание на то, как работать с данными: в текстовом или двоичном режиме. Подробности — см. в документации.
Пример использования stdio
#include const char *filename = "testfile.txt"; int main() < FILE *fin, *fout; int ecode; // открытие файла для записи в текстовом режиме, // запись данных и закрытие файла. if((fout = fopen(filename, "w")) != NULL) < for (int i = 0; i < 16; i++) < if ((ecode = fprintf(fout, "%d\n", i*i)) > fclose(fout); > else < fprintf(stderr, "Output file open error \"%s\", code %d\n", filename, errno); return 1; >// открытие файла для чтения в текстовом режиме, // чтение данных, форматированный вывод на консоль, закрытие файла. int data; int counter = 0; if((fin = fopen(filename, "r")) != NULL) < while ((ecode = fscanf(fin, "%d", &data)) != EOF) < printf("%8d", data); if (++counter % 4 == 0) < putchar('\n'); >> if ((ecode = ferror(fin)) != 0) < fprintf(stderr, "Read error in file \"%s\", code %d\n", filename, ecode); fclose(fin); return 2; >fclose(fin); > else < fprintf(stderr, "Input file open error \"%s\", code %d\n", filename, errno); return 2; >return 0; >Следует отметить, что существует еще одна библиотека, ориентированная исключительно на консольный ввод-вывод — .
Ввод-вывод с помощью потоков STL
Для использования объектно-ориентированного консольного ввода-вывода с помощью потоков (stream) STL в программу необходимо включить заголовочный файл , а для файлового ещё и . (Разумеется, компилятор должен иметь доступ к соответствующей объектной библиотеке для правильной сборки исполняемого файла.)
Самая Первая Программа с использованием потоков STL выглядит так:
using namespace std; int main()
При запуске консольного приложения неявно открываются четыре потока: сin — для ввода с клавиатуры, сout — для буферизованного вывода на монитор, сerr — для небуферизованного вывода на монитор сообщений об ошибках и clog — буферизованный аналог cerr. Эти четыре символа определены посредством .
Потоки cin, cout и cerr соответствуют потокам stdin, stdout и stderr соответственно.
Иерархия классов ввода-вывода STL достаточно сложна. Любители тонких ощущений могут найти её описание в литературе. Впрочем, остальных также не минует чаша сия, но только позже, когда потребуются знания чуть повыше того базового уровня, который описывается здесь.
Для ввода-вывода сначала необходимо создать поток — экземпляр соответствующего класса STL, а затем связать его с файлом. Для потока вывода используется класс ofstream, для потока ввода — ifstream, для потока ввода-вывода — fstream. В каждом из этих классов есть метод open(), который связывает поток с файлом. Проще говоря, открывает файл. Методу передаются два параметра: имя файла и режим открытия файла. Второй параметр представляет собой набор битовых флагов, определяющих режим открытия файла (чтение, запись и пр.) и способ работы с данными (текстовый или двоичный режим). Второй параметр опционален, т.е. имеет значение по умолчанию, соответствующее классу.
Вышеупомянутые классы имеют также конструкторы, позволяющие открыть файл сразу при создании потока. Параметры этих конструкторов полностью совпадают с параметрами метода open().
При ошибке открытия файла (в контексте логического выражения) поток получает значение false.
Файл закрывается методом close(). Этот метод также вызывается при разрушении экземпляров классов потоков.
Операции чтения и записи в поток, связанный с файлом, осуществляются либо с помощью операторов >, перегруженных для классов потоков ввода-вывода, либо с помощью любых других методов классов потоков ввода-вывода.
Некоторые наиболее употребляемые методы:
Пример использования потоков STL
#include using namespace std; const char *filename = "testfile2.txt"; int main() < // создание потока, открытие файла для записи в текстовом режиме, // запись данных и закрытие файла. ofstream ostr; ostr.open(filename); if (ostr) < for (int i = 0; i < 16; i++) < ostr > ostr.close(); > else < cerr // открытие файла (в конструкторе) для чтения в текстовом режиме, // чтение данных, форматированный вывод на консоль, закрытие файла. int data; int counter = 0; ifstream istr(filename); if (istr) < while (!(istr >> data).eof()) < if (istr.bad()) < cerr cout.width(8); cout > istr.close(); > else < cerr return 0; >Взаимодействие потокового и традиционного ввода-вывода
Апологеты C++ рекомендуют использовать для ввода-вывода только потоки STL и отказаться от использования традиционного ввода-вывода в духе C. Однако, ничто не мешает, по крайней мере пока, использовать традиционную систему ввода-вывода. Более того, предусмотрена специальная функция для синхронизации ввода-вывода, выполненного посредством потоков и посредством старых функций.
bool sync_with_stdio(bool sync = true);Заключение
Какой механизм использовать — вопрос предпочтений программиста, если работодателем явно не предписано использование конкретного механизма. В любом случае для физического ввода-вывода используются вызовы операционной системы. Всё остальное — обёртка, набор более или менее удобных функций или классов для взаимодействия с ОС.
Использование механизма потоков считается более безопасным. Но, как известно, плохую программу можно написать на любом языке программирования. Это также относится и к использованию библиотек. Автор статьи: Череп.