Функция printf() для форматированного вывода

Практический курс по C/C++: https://stepik.org/course/193691

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

print formatted (форматированный вывод)

А само определение (прототип) функции следующее:

int printf(const char* format, …);

Первый параметр format – это указатель на строку. Пока его можно воспринимать просто как строку, в которой определен формат для вывода информации в стандартный поток stdout. А троеточие определяет произвольное число дополнительных параметров. Обычно, это переменные или выражения, значения которых следует выводить в заданном формате. В качестве возвращаемого типа указан int, то есть функция возвращает целое число. Это число соответствует количеству выведенных символов в стандартный поток stdout (в нашем случае на экран). Обычно, на практике, этим значением пренебрегают и вызывают функцию printf(), как говорят, ради побочного эффекта, т.е. ради передачи данных в выходной поток.

В самом простом варианте мы с вами использовали эту функцию для вывода строки на экран:

#include <stdio.h>
 
int main(void)
{
    printf("Hello, World!\n");
    return 0;
}

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

Итак, первый параметр format функции printf() определяет не просто выводимую строку, а формат выдаваемых данных. И для этого в нашем распоряжении имеются, так называемые, спецификаторы преобразования. Основные из них следующие.

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

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

int var_i = 1208;

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

printf("value = %d\n", var_i);

После запуска программы на экран будет выведено:

value = 1208

Почему так и как это работает? Сморите, вначале функция printf() выполняет анализ форматной строки. В некотором смысле она работает как ее интерпретатор. Как только в строке встречается символ %, скорее всего, это некоторый спецификатор. И, действительно, дальше идет символ d, функция «понимает», что это спецификатор %d, на место которого нужно подставить значение переменной в виде целого десятичного числа со знаком (если он есть; знак + не ставится). При этом берется первая переменная, записанная после форматной строки. В нашем случае – это var_i со значением 1208. В результате получаем итоговую строку «value = 1208».

А теперь, давайте, вместо спецификатора %d запишем, например, спецификатор %x:

printf("value = %x\n", var_i);

В результате будет выведена строка:

value = 4b8

То есть, спецификатор %x преобразовывает данные из переменной var_i в шестнадцатеричный формат и подставляет на свое место. И так работает каждый спецификатор. Даже если прописать:

printf("value = %f\n", var_i);

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

value = 0.000000

Но, если изменить тип переменной var_i на вещественный:

double var_i = 1208;

то увидим правильное значение:

value = 1208.000000

Суффиксы типов для спецификаторов

Этот пример показывает, что спецификаторы должны быть согласованы с типами данных переменных или выражений. Причем, целочисленные типы char и short, при передаче значений функции printf(), автоматически приводятся к типу int. Поэтому спецификатор %d охватывает все три типа: char, short, int. Если же переменная имеет тип long или long long, то перед спецификаторами допустимо прописывать малые буквы l и ll соответственно:

• l – суффикс для типов long или unsigned long;
• ll – суффикс для типов long long или unsigned long long.

Так как в моей версии компилятора типы long и int по размеру совпадают и имеют 4 байта (32 бита), то приведу пример с типом long long, который занимает 8 байтов (64 бита):

printf("value = %lld\n", -12345678901234LL);
printf("value = %llu\n", 12345678901234LL);

Если при выводе в спецификаторах убрать буквы ll, то значение будет отображено некорректно:

printf("value = %d\n", -12345678901234LL);

Увидим:

value = -1942892530

Аналогично и с вещественными типами: float автоматически преобразовывается в double, поэтому спецификаторы %f, %F, %e и %E корректно обрабатывают оба из них. А вот для типа long double следует прописывать суффикс в виде заглавной буквы L:

• L – суффикс для типа long double.

Например:

long double var_ld = 0.5;
printf("value = %Lf\n", var_ld);

Увидим строку:

value = 0.500000

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

printf("value = %f\n", var_ld);

На выходе:

value = -0.000000

Так с помощью суффиксов учитываются все базовые типы переменных языка Си.

Вывод нескольких переменных

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

short var_h = 100;
int var_i = 1024;
long double var_ld = 0.5;

Функцию printf() можно записать в виде:

printf("var_h = %d, var_i = %d, %Lf\n", var_h, var_i, var_ld);

Так как тип short преобразуется в тип int, то для переменных var_h и var_i допустимо использовать спецификатор %d. А вот для переменной var_ld типа long double обязательно следует использовать суффикс L перед спецификатором вещественного типа. В результате обработки этой форматной строки слева-направо, функция printf() вместо первого спецификатора %d подставит значение из переменной var_h; вместо второго %d – значение из переменной var_i; вместо третьего %Lf – значение из переменной var_ld. И этот порядок всегда такой: в n-й по счету спецификатор подставляется n-я по счету переменная или выражение. В результате, получим вывод в виде строки:

var_h = 100, var_i = 1024, 0.500000

Флаги спецификаторов

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

Давайте посмотрим на конкретных примерах, как можно использовать эти флаги по отдельности и в комбинации с другими флагами. Объявим в программе две переменные var_i и var_d с некоторыми начальными значениями, а затем выведем их в столбик с шириной поля 10:

#include <stdio.h>
 
int main(void)
{
    int var_i = -1283;
    double var_d = 54.34675;
 
    printf("[%10d]\n", var_i);
    printf("[%10f]\n", var_d);
    return 0;
}

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

[     -1283]
[ 54.346750]

В обоих случаях ширина равна 10 символов и выводимые данные выровнены по правому краю. Можно изменить это поведение и сделать выравнивание по левому краю следующим образом:

printf("[%-10d]\n", var_i);
printf("[%-10f]\n", var_d);

Увидим строчки:

[-1283     ]
[54.346750 ]

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

printf("[%-5d]\n", var_i);
printf("[%-5f]\n", var_d);

Увидим строчки:

[-1283]
[54.346750]

Если вместо целого числа указывать дробное, то в случае с целыми числами число до точки (12) будет задавать общую ширину вывода, а число после точки (7) – ширину отображаемых данных, которая дополняется нулями:

printf("[%12.7d]\n", var_i);
printf("[%12.2f]\n", var_d);

В случае с вещественными числами, значение 12 определяет общую минимальную ширину вывода, а число после точки (2) – точность выводимого значения. После запуска программы увидим:

[    -0001283]
[       54.35]

Или в таком виде:

printf("[%.7d]\n", var_i);
printf("[%.2f]\n", var_d);

Получим вывод:

[-0001283]
[54.35]

Следующие два флага # и + работают следующим образом:

printf("[%#X]\n", var_i);
printf("[%+.2f]\n", var_d);

Получим:

[0XFFFFFAFD]
[+54.35]

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

Практический курс по C/C++: https://stepik.org/course/193691

Видео по теме

Язык Си. Рождение легенды

#1. Этапы трансляции программы в машинный код. Стандарты

#2. Установка компилятора gcc и Visual Studio Code на ОС Windows

#3. Структура и понимание работы программы "Hello, World!"

#4. Двоичная, шестнадцатеричная и восьмеричная системы счисления

#5. Переменные и их базовые типы. Модификаторы unsigned и signed

#6. Операция присваивания. Числовые и символьные литералы. Операция sizeof

#7. Стандартные потоки ввода/вывода. Функции putchar() и getchar()

#8. Функция printf() для форматированного вывода

#9. Функция scanf() для форматированного ввода

#10. Арифметические операции: сложение, вычитание, умножение и деление

#11. Арифметические операции деления по модулю, инкремента и декремента

#12. Арифметические операции +=, -=, *=, /=, %=

#13. Булевый тип. Операции сравнения. Логические И, ИЛИ, НЕ

#14. Условный оператор if. Конструкция if-else

#15. Условное тернарное выражение

#16. Оператор switch множественного выбора. Ключевое слово break

#17. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операции

#18. Генерация псевдослучайных чисел. Функции математической библиотеки

#19. Директивы макропроцессора #define и #undef

#20. Директива #define для определения макросов-функций. Операции # и ##

#21. Директивы #include и условной компиляции

#22. Оператор цикла while

#23. Оператор цикла for

#24. Цикл do-while с постусловием. Вложенные циклы

#25. Операторы break, continue и goto

#26. Указатели. Проще простого

#27. Указатели. Приведение типов. Константа NULL

#28. Долгожданная адресная арифметика

#29. Введение в массивы

#30. Вычисление размера массива. Инициализация массивов

#31. Указатели на массивы

#32. Ключевое слово const с указателями и переменными

#33. Операции с массивами копирование, вставка, удаление и сортировка

#34. Двумерные и многомерные массивы. Указатели на двумерные массивы

#35. Строки. Способы объявления, escape-последовательности

#36. Ввод/вывод строк в стандартные потоки

#37. Строковые функции strlen(), strcpy(), strncpy(), strcat(), strncat()

#38. Строковые функции сравнения, поиска символов и фрагментов

#39. Строковые функции sprintf(), atoi(), atol(), atoll() и atof()

#40. Объявление и вызов функций

#41. Оператор return. Вызов функций в аргументах

#42. Прототипы функций

#43. Указатели как параметры. Передача массивов в функции

#44. Указатели на функцию. Функция как параметр (callback)

#45. Стековый фрейм. Автоматические переменные

#46. Рекурсивные функции

#47. Функции с произвольным числом параметров

#48. Локальные и глобальные переменные

#49. Локальные во вложенных блоках

#50. Ключевые слова static и extern

#51. Функции malloc(), free(), calloc(), realloc(), memcpy() и memmove()

#52. Перечисления (enum). Директива typedef

#53. Структуры. Вложенные структуры

#54. Указатели на структуры. Передача структур в функции

#55. Реализация стека (пример использования структур)

#56. Объединения (union). Битовые поля

#57. Файловые функции: fopen(), fclose(), fgetc(), fputc()

#58. Функции perror(), fseek() и ftell()

#59. Функции fputs(), fgets() и fprintf(), fscanf()

#60. Функции feof(), fflush(), setvbuf()

#61. Бинарный режим доступа. Функции fwrite() и fread()

С++. Начало

#1. Первая программа на С++

#2. Ввод-вывод с помощью объектов cin и cout

#3. Пространства имен (namespace)

#4. Оператор using

#5. Новые типы данных. Приведение типов указателей

#6. Инициализация переменных. Ключевые слова auto и decltype

#7. Ссылки. Константные ссылки

#8. Объект-строка string. Операции с объектами класса string

#9. Файловые потоки. Открытие и закрытие файлов. Режимы доступа

#10. Чтение и запись данных в файл в текстовом режиме

#11. Чтение и запись данных в файл в бинарном режиме

#12. Перегрузка функций. Директива extern C

#13. Значения параметров функции по умолчанию

#14. inline-функции

#15. Лямбда-выражения. Объявление и вызов

#16. Захват внешних значений в лямбда выражениях

#17. Структуры в С++, как обновленный тип данных

#18. Структуры. Режимы доступа. Сеттеры и геттеры

#19. Структуры. Конструкторы и деструкторы

#20. Операторы new / delete и new [] / delete []

#21. Особенности работы new и delete

#22. Smart-указатели типа unique_ptr

#23. Smart-указатели типа shared_ptr