Printf c что это за программа

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

Теги: Форматированный ввод, форматированный вывод, printf, scanf, fgets, getch, строка формата, спецификатор формата, флаги, управляющие символы.

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

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

Функция форматированного вывода printf получает в качестве аргументов строку формат и аргументы, которые необходимо вывести в соответствии с форматом, и возвращает число выведенных символов. В случае ошибки возвращает отрицательное значение и устанавливает значение ferror. Если произошло несколько ошибок, errno равно EILSEQ.
int printf (const char * format, . );

#include #include void main() < //функция не получает никаких аргументов, кроме строки printf(«Hello world»); getch(); >

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

Basic Output Function – printf

Общий синтаксис спецификатора формата
%[флаги][ширина][.точность][длина]спецификатор
Спецификатор – это самый важный компонент. Он определяет тип переменной и способ её вывода.

Таб. 1 Спецификатор типа.

Спецификатор Что хотим вывести Пример

d или i	Целое со знаком в в десятичном виде	392
u	Целое без знака в десятичном виде	7235
o	Беззнаковое в восьмеричном виде	657
x	Беззнаковое целое в шестнадцатеричном виде	7fa
X	Беззнаковое целое в шестнадцатеричном виде, верхний регистр	7FA
f или F	Число с плавающей точкой	3.4563745
e	Экспоненциальная форма для числа с плавающей точкой	3.1234e+3
E	Экспоненциальная форма для числа с плавающей точкой, верхний регистр	3.1234E+3
g	Кратчайшее из представлений форматов f и e	3.12
G	Кратчайшее из представлений форматов F и E	3.12
a	Шестнадцатеричное представление числа с плавающей точкой	-0xc.90fep-2
A	Шестнадцатеричное представление числа с плавающей точкой, верхний регистр	-0xc.90FEP-2
c	Буква	a
s	Строка (нуль-терминированный массив букв)	Hello World
p	Адрес указателя	b8000000
n	Ничего не печатает. Аргументом должен быть указатель на signed int. По этому адресу будет сохранено количество букв, которое было выведено до встречи %n
%	Два идущих друг за другом процента выводят знак процента	%

printf Basics | C Programming Tutorial

#include #include void main()

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

Таб. 2 Флаги.

Флаг Описание

—	Выключка влево на заданное шириной значение
+	Явно указывать знак у числа, даже для положительных чисел
(пробел)	Если знак не будет выведен, то вставляет пробел перед выводимым числом
#	Когда используется вместе с o, x или X, вставляет перед числом 0, 0x или 0X Когда используется со спецификаторами a, A, e, E, f, F, g или G, вставляет десятичную точку, даже если после неё нет десятичных знаков.
	Вставляет нули, когда объявлен спецификатор ширины

Таб. 3 Ширина. Ширина Описание

(число)	Минимальное количество знаков, которое необходимо вывести. Если в числе меньше знаков, то вставляет пробелы (или нули)
*	Ширина не указана в строке формата, она передаётся отдельно в виде аргумента, который должен предшествовать выводимому числу

Таб. 4 Точность. .Точность Описание

.число	Для спецификаторов целых (d, i, o, u, x, X) точность определяет минимальное количество знаков, которое необходимо вывести. Если значение короче, то выводятся нули перед числом. Значение не обрезается, даже если оно длиннее. Точночть 0 означает, что для значения 0 ничего не выводится. Для спецификаторов чисел с плавающей точкой (a, A, e, E, f, F) это число знаков, которые необходимо вывести после десятичной точки (по умолчанию 6). Для g и G — это число значащих разрядов, которые необходимо вывести. Для s — выводится указанное число символов. По умолчанию выводятся все символы до первого нулевого. Если число не стоит, то по умолчанию точность равна 0
.*	Точность не указана в строке формата, она передаётся отдельно в виде аргумента, который должен предшествовать выводимому числу

#include #include void main()

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

Таб. 5 Длина.

спецификаторы Длина d, i u o x X f F e E g G a A c s p n

(none)	int	unsigned int	double	int	char*	void*	int*
hh	signed char	unsigned char	signed char*
h	short int	unsigned short int	short int*
l	long int	unsigned long int	wint_t	wchar_t*	long int*
ll	long long int	unsigned long long int	long long int*
j	intmax_t	uintmax_t	intmax_t*
z	size_t	size_t	size_t*
t	ptrdiff_t	ptrdiff_t	ptrdiff_t*
L	long double

#include #include void main()

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

Рассмотрим форматированный ввод функцией scanf.
int scanf(const char*, . )
Функция принимает строку формата ввода (она похожа на строку формата printf) и адреса, по которым необходимо записать считанные данные. Возвращает количество успешно проинициализированных аргументов.
Формат спецификатора ввода
%[*][ширина][длинна]спецификатор

Таб. 6 Спецификатор типа.

Спецификатор Описание Выбранные символы

i, u	Целые	Произвольное число цифр (0-9), возможно, начинающихся с + или -. Если число начинается с 0, то считывается в восьмеричном формате, если с 0x, то в шестнадцатеричном.
d	Десятичное целое	Произвольное число цифр (0-9), возможно, начинающихся с + или -.
o	восьмеричное целое	Произвольное число цифр (0-7), возможно, начинающихся с + или -.
x	Шестнадцатеричное целое	Произвольное число цифр (0-F), возможно, начинающихся с + или — и префикса 0x или 0X.
f, e, g	Число с плавающей точкой	Число, состоящее из набора цифр 0-9, возможно с десятичным разделителем (точкой). Возможно также представление в экспоненциальной форме. C99 позволяет также вводить число в шестнадцатеричном формате.
a
c	Символ	Если ширина не передана, то считывает один символ. Если ширина передана, то считывает нужное количество символов и размещает их в массиве БЕЗ терминального символа на конце.
s	Строка	Считывает все не пробельные символы. Если указана ширина, то не более n символов. Ставит на место n+1 символа терминальный.
p	Адрес указателя	Последовательность символов, трактуемая как адрес указателя. Формат зависит от реализации, но совпадает с тем, как выводит printf с ключом p
[символы]	Множество символов	Считывает только те символы, которые записаны в квадратных скобках, С99
[^символы]	Множество символов	Считывает только те символы, которые не указаны в квадратных скобках, С99
n	Ничего не считывает	Сохраняет число уже считанных символов по указанному адресу

Как и в printf, ширина, заданная символом * ожидает аргумента, который будт задавать ширину. Флаг длина совпадает с таким флагом функции printf.

#include #include void main() < int year, month, day; char buffer[128]; int count; //Требует форматированного ввода, например 2013:12:12 printf(«Enter data like x:x:x = «); scanf(«%d:%d:%d», month, printf(«year = %dnmonth = %d, day = %dn», year, month, day); //Считываем строку, не более 127 символов. При считывании в массив писать Enter string = «); scanf(«%127s», buffer); printf(«%s», buffer); getch(); >

Кроме функций scanf и printf есть ещё ряд функций, которые позволяют получать вводимые данные

int getch() [aka _getch(), getchar()] — возвращает введённый символ, при этом не выводит его на консоль.

#include #include void main() < char c = 0; do < c = getch(); printf(«%c», c); >while (c != ‘q’); >

char * fgets ( char * str, int num, FILE * stream ) — функция позволяет считывать строку с пробельными символами. Несмотря на то, что она работает с файлом, можно с её помощью считывать и из стандартного потока ввода. Её преимущество относительно gets в том, что она позволяет указать максимальный размер считываемой строки и заканчивает строку терминальным символом.

#include #include #include void main() < char buffer[128]; //Считываем из стандартного потока ввода fgets(buffer, 127, stdin); printf(«%s», buffer); //Этим можно заменить ожидание ввода символа scanf(«1»); >

Это не полный набор различных функций символьного ввода и вывода. Таких функций море, но очень многие из них небезопасны, поэтому перед использованием внимательно читайте документацию.

Непечатные символы

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

Таб. 7 Управляющие последовательности.

Последовательность Числовое значение Результат

a	0x07	Звуковой сигнал
b	0x08	Перевод каретки на одно значение назад
f	0x0c	Новая страница
n	0x0a	Перевод строки, новая строка
r	0x0d	Возврат каретки
t	0x09	Табуляция
v	0x0b	Вертикальная табуляция
«	0x22	Двойная кавычка
\	0x5с	Обратный слеш

#include #include void main() < char backspace = 0x08; //Выводим с использованием символа переноса строки printf(«HellonWorldn»); //Выводим символ переноса строки через его значение printf(«Hello%cWorldn», 0x0a); //»Выводим» сигнал printf(«a»); //Выводим сигнал, как символ printf(«%c», ‘a’); //Выводим сигнал через шестнадцатеричное значение printf(«%c», 0x07); printf(«This is sparta. bb%c», backspace); printf(» «); getch(); >

Всё ещё не понятно? – пиши вопросы на ящик

Источник: learnc.info

Форматированный вывод. Функция printf

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

Общий синтаксис функции printf следующий:

Рис.1. Общий синтаксис функции printf.

У функции printf есть один обязательный параметр – строка, заключенная в двойные кавычки. Эту строку еще называют формат-строкой .

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

Кроме обязательной строки форматирования есть и необязательные параметры. Они пишутся через запятую после формат-строки.

Формат-строка.

• символы, которые выводятся на экран без изменений
• escape-последовательности
• спецификаторы формата

Еscape-последовательности

С этой группой символов мы уже встречались в первом уроке. Символ n . Он, как вы наверное помните, переносит выводимый текст на новую строку. Есть и другие эскейп-последовательности (иногда можно встретить название управляющие последовательности). Любая такая последовательность начинается с символа обратный слеш .

Часто используемые escape-последовательности: n — новая строка
t — горизонтальная табуляция. Сдвигает выводимые данные вправо на ближайшую позицию табуляции. Обычно используется для выравнивания текста внутри строки.
‘ — вывод символа ‘
» — вывод символа »
\ — вывод символа
? — вывода символа ?

Как видите, последние четыре последовательности нужны лишь для того, чтобы вывести на экран символы «»», «’», «» и «?». Дело в том, что если эти символы просто записать в формат-строку, то они не отобразятся на экране, а в некоторых случаях программа и вовсе не скомпилируется. Следующая программа иллюстрирует работу escape-последовательностей.

#include int main(void)

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

Спецификаторы формата.

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

Основные спецификаторы формата: %d, %i — целые числа
%f, %g — вещественные числа
%c — символы

Есть и другие спецификаторы формата. Мы познакомимся с ними тогда, когда они нам понадобятся. Сами спецификаторы формата на экран не выводятся. Вместо них выводятся данные, которые передаются в функцию printf после строки форматирования. Функция printf работает следующим образом.

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

printf(«%dt%dn%d»,10,20,30);

Рис.2 Вывод Листинг 2.

printf(«pervoe slagaemoe: %dnvtoroe slagaemoe:%dnsumma: %dn»,10,20,30);

Рис.3 Вывод Листинг 3.

printf(«%d + %d = %dn», 20, 10, 20+10);

Рис.4 Вывод Листинг 4.

printf(«%d + %d %c %dn», 10, 20, ‘=’, 20+10);

Рис.5 Вывод Листинг 5.

На следующей картинке показан принцип работы функции printf .

Рис.6 Принцип работы функции printf.

• количество спецификаторов формата должно совпадать с количеством данных для вывода
• спецификаторы формата должны точно соответствовать типам выводимых данных

#include int main(void) < int z = 4; float b = 5.4; printf(«%fn»,z); // нарушено 2 правило // переменная z целого типа, а команда форматирования %f предназначена для // вывода переменных типа float printf(«%dn»,z, b); //нарушено 1 правило // нет команды форматирования для переменной b. return 0; >
Напишем небольшую программу, которая иллюстрирует использование спецификаторов формата.
#include int main(void)

Модификаторы формата.

Обратите внимание, что вещественные числа через спецификатор %f выведены с шестью знаками после запятой. У вас на компьютере может быть выведено как больше, так и меньше знаков. Обычно такая точность не нужна. К счастью, этим можно управлять. Для этого предназначены модификаторы формата . Модификаторы формата записываются между символом % и буквой используемого типа.

На рисунке ниже представлена спецификатор формата с использованием модификатора формата.

Рис.7 Модификатор формата

Первое число обозначает ширину поля, выделяемого для записи числа. Второе число обозначает точность, с которой мы хотим вывести данное вещественное число. В примере на картинке под вещественное число мы выделяем 8 символов и хотим видеть 3 знака после запятой.

Если указанного в ширине количества позиций нам не хватает для вывода числа, то ширина поля увеличивается автоматически, до минимально-возможного количества позиций. У первого числа может спереди еще стоять знак минус, например %-8.3f . Этот минус говорит о том, что необходимо выровнять число по левому краю используемой области. Для иллюстрации описанных возможностей модификаторов формата, напишем небольшую программу.

#include int main(void)< int a=777; // никаких модификаторов нет, //вывод использует минимальную ширину поля printf(«|%d|n», a); // ширина 8 позиций, выравнивание по левому краю printf(«|%-8d|n», a); // ширина 8 позиций, выравнивание по правому краю printf(«|%8d|n», a); // число позиций 2, но в числе 777 больше двух цифр // поэтому область расширяется до минимально-возможной ширины printf(«|%2d|n», a); float b=150.5; // никаких модификаторов нет, выведет используя минимальную ширину поля // и стандартную точность 6 знаков printf(«|%f|n», b); // ширина 8 позиций, выравнивание по левому краю, 3 знака после запятой printf(«|%-8.3f|n», b); // ширина 8 позиций, 2 знака после запятой, выравнивание по правому краю printf(«|%8.2f|n», b); // число позиций 4,точность 3 знака после запятой, но этого мало // поэтому ширина поля увеличивается до минимально-возможного значения printf(«|%4.3f|n», b); return 0; >
Результат работы данной программы представлен на рисунке ниже.

Рис.8 Вывод Листинг 8.

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

#include int main(void)
Сохрани в закладки или поддержи проект.

Практика

Решите предложенные задачи. Для удобства работы сразу переходите в полноэкранный режим Исследовательские задачи для хакеров:

1. Теперь вы можете увидеть, как выглядит мусор, который хранится в переменной после её объявления. Для этого объявите переменную любого типа и выведете её значение на экран использую функцию printf .
2. Найдите в стандарте языка, в справочной системе компилятора полный список escape-последовательностей. Попробуйте использовать их в вашей программе. Разберитесь как они работают.
3. Выясните, что произойдет, если в формат-строку функции printf вставить c , где c — любой символ, не входящий в список escape-последовательностей. [K», «’», «» и «?» без использования escape-последовательностей.
4. Изучите как работает спецификатор %e

Дополнительные материалы

1. Ранее я говорил, что тип double называется типом двойной точности, и что он в некотором смысле лучше, чем тип float . Запустите следующую программу, чтобы убедиться в этом.

#include int main(void)< int z = 1/10; float x = 1.0/10.0; double y = 1.0/10.0; printf(«int:n%dnn», z); printf(«float:n4t—t%.4fn10t—t%.12fn16t—t%.16fnn», x,x,x); printf(«double:n4t—t%.4fn10t—t%.12fn16t—t%.16fn», y,y,y); return(0); >

Источник: youngcoder.ru

Ввод-вывод в Си

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

Ввод и вывод информации осуществляется через функции стандартной библиотеки. Прототипы рассматриваемых функций находятся в файле stdio.h . Эта библиотека содержит функции

• printf() — для вывода информации
• scanf() — для ввода информации.

Вывод информации

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

Общая форма записи функции printf() :

printf( «СтрокаФорматов» , объект1, объект2, . объектn);

СтрокаФорматов состоит из следующих элементов:

• управляющих символов;
• текста, представленного для непосредственного вывода;
• форматов, предназначенных для вывода значений переменных различных типов.

Объекты могут отсутствовать.

Управляющие символы не выводятся на экран, а управляют расположением выводимых символов. Отличительной чертой управляющего символа является наличие обратного слэша ‘’ перед ним.

Основные управляющие символы:

• ‘n’ — перевод строки;
• ‘t’ — горизонтальная табуляция;
• ‘v’ — вертикальная табуляция;
• ‘b’ — возврат на символ;
• ‘r’ — возврат на начало строки;
• ‘a’ — звуковой сигнал.

Форматы нужны для того, чтобы указывать вид, в котором информация будет выведена на экран. Отличительной чертой формата является наличие символа процент ‘%’ перед ним:

• %d — целое число типа int со знаком в десятичной системе счисления;
• %u — целое число типа unsigned int ;
• %x — целое число типа int со знаком в шестнадцатеричной системе счисления;
• %o — целое число типа int со знаком в восьмеричной системе счисления;
• %hd — целое число типа short со знаком в десятичной системе счисления;
• %hu — целое число типа unsigned short ;
• %hx — целое число типа short со знаком в шестнадцатеричной системе счисления;
• %ld — целое число типа long int со знаком в десятичной системе счисления;
• %lu — целое число типа unsigned long int ;
• %lx — целое число типа long int со знаком в шестнадцатеричной системе счисления;
• %f — вещественный формат (числа с плавающей точкой типа float );
• %lf — вещественный формат двойной точности (числа с плавающей точкой типа double );
• %e — вещественный формат в экспоненциальной форме (числа с плавающей точкой типа float в экспоненциальной форме);
• %c — символьный формат;
• %s — строковый формат.

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

1
2
3
4
5
6
7
8
9
10

Результат работы программы

Тот же самый код может быть представлен с использованием одного вызова printf :

Табличный вывод

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

#include
int main()
float x = 1.2345;
printf( «x=%10.5fn» , x);
getchar();
return 0;
>

Результат выполнения

В приведенном примере 10 — общее количество знакомест, отводимое под значение переменной; 5 — количество позиций после разделителя целой и дробной части (после десятичной точки). В указанном примере количество знакомест в выводимом числе меньше 10, поэтому свободные знакоместа слева от числа заполняются пробелами. Такой способ форматирования часто используется для построения таблиц.

Ввод информации

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

scanf ( «CтрокаФорматов» , адрес1, адрес2. );

Строка форматов аналогична функции printf() .
Для формирования адреса переменной используется символ амперсанд ‘объект

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include
#include // для перехода на русский язык
int main()
float y;
system( «chcp 1251» ); // переходим в консоли на русский язык
system( «cls» ); // очищаем окно консоли
printf( «Введите y: » ); // выводим сообщение
scanf( «%f» , // вводим значения переменной y
printf( «Значение переменной y=%f» , y); // выводим значение переменной y
getchar(); getchar();
return 0;
>

Результат работы программы:

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

#define _CRT_SECURE_NO_WARNINGS

Другой вариант — воспользоваться функцией защищенного ввода scanf_s( ) , которая появилась несколько позже, но содержит тот же самый список параметров.

Источник: prog-cpp.ru

std:: printf, std:: fprintf, std:: sprintf, std:: snprintf

Loads the data from the given locations, converts them to character string equivalents and writes the results to a variety of sinks.

1) Writes the results to stdout .
2) Writes the results to a file stream stream .
3) Writes the results to a character string buffer .

4) Writes the results to a character string buffer . At most buf_size — 1 characters are written. The resulting character string will be terminated with a null character, unless buf_size is zero. If buf_size is zero, nothing is written and buffer may be a null pointer, however the return value (number of bytes that would be written not including the null terminator) is still calculated and returned.

If a call to sprintf or snprintf causes copying to take place between objects that overlap, the behavior is undefined (e.g. sprintf ( buf, «%s text» , buf ) ; )

Contents

[edit] Parameters

stream	—	output file stream to write to
buffer	—	pointer to a character string to write to
buf_size	—	up to buf_size — 1 characters may be written, plus the null terminator
format	—	pointer to a null-terminated multibyte string specifying how to interpret the data
.	—	arguments specifying data to print. If any argument after default conversions is not the type expected by the corresponding conversion specifier, or if there are fewer arguments than required by format , the behavior is undefined. If there are more arguments than required by format , the extraneous arguments are evaluated and ignored.

The format string consists of ordinary multibyte characters (except % ), which are copied unchanged into the output stream, and conversion specifications. Each conversion specification has the following format:

• introductory % character

• (optional) one or more flags that modify the behavior of the conversion:

• — : the result of the conversion is left-justified within the field (by default it is right-justified)
• + : the sign of signed conversions is always prepended to the result of the conversion (by default the result is preceded by minus only when it is negative)
• space: if the result of a signed conversion does not start with a sign character, or is empty, space is prepended to the result. It is ignored if + flag is present.
• # : alternative form of the conversion is performed. See the table below for exact effects otherwise the behavior is undefined.
• 0 : for integer and floating point number conversions, leading zeros are used to pad the field instead of space characters. For integer numbers it is ignored if the precision is explicitly specified. For other conversions using this flag results in undefined behavior. It is ignored if — flag is present.

• (optional) integer value or * that specifies minimum field width. The result is padded with space characters (by default), if required, on the left when right-justified, or on the right if left-justified. In the case when * is used, the width is specified by an additional argument of type int , which appears before the argument to be converted and the argument supplying precision if one is supplied. If the value of the argument is negative, it results with the — flag specified and positive field width. (Note: This is the minimum width: The value is never truncated.)

• (optional) . followed by integer number or * , or neither that specifies precision of the conversion. In the case when * is used, the precision is specified by an additional argument of type int , which appears before the argument to be converted, but after the argument supplying minimum field width if one is supplied. If the value of this argument is negative, it is ignored. If neither a number nor * is used, the precision is taken as zero. See the table below for exact effects of precision.

• (optional) length modifier that specifies the size of the argument (in combination with the conversion format specifier, it specifies the type of the corresponding argument)

• conversion format specifier

The following format specifiers are available:

Length
Modifier

The argument is first converted to unsigned char . If the l modifier is used, the argument is first converted to a character string as if by %ls with a wchar_t [ 2 ] argument.

The argument must be a pointer to the initial element of an array of characters. Precision specifies the maximum number of bytes to be written. If Precision is not specified, writes every byte up to and not including the first null terminator. If the l specifier is used, the argument must be a pointer to the initial element of an array of wchar_t , which is converted to char array as if by a call to wcrtomb with zero-initialized conversion state.

Precision specifies the minimum number of digits to appear. The default precision is 1 .

If both the converted value and the precision are ​ 0 ​ the conversion results in no characters.

signed char
signed size_t

Precision specifies the minimum number of digits to appear. The default precision is 1 . If both the converted value and the precision are ​ 0 ​ the conversion results in no characters. In the alternative implementation precision is increased if necessary, to write one leading zero. In that case if both the converted value and the precision are ​ 0 ​ , single ​ 0 ​ is written.

unsigned char
unsigned short
unsigned int
unsigned long
unsigned long long
unsigned version of ptrdiff_t

For the x conversion letters abcdef are used.
For the X conversion letters ABCDEF are used.
Precision specifies the minimum number of digits to appear. The default precision is 1 . If both the converted value and the precision are ​ 0 ​ the conversion results in no characters. In the alternative implementation 0x or 0X is prefixed to results if the converted value is nonzero.

Precision specifies the minimum number of digits to appear. The default precision is 1 . If both the converted value and the precision are ​ 0 ​ the conversion results in no characters.

Precision specifies the exact number of digits to appear after the decimal point character. The default precision is 6 . In the alternative implementation decimal point character is written even if no digits follow it. For infinity and not-a-number conversion style see notes.

double (C++11)
long double

For the e conversion style [-]d.ddd e ±dd is used.
For the E conversion style [-]d.ddd E ±dd is used.
The exponent contains at least two digits, more digits are used only if necessary. If the value is ​ 0 ​ , the exponent is also ​ 0 ​ . Precision specifies the exact number of digits to appear after the decimal point character. The default precision is 6 . In the alternative implementation decimal point character is written even if no digits follow it. For infinity and not-a-number conversion style see notes.

converts floating-point number to the hexadecimal exponent notation.

For the a conversion style [-] 0x h.hhh p ±d is used.
For the A conversion style [-] 0X h.hhh P ±d is used.
The first hexadecimal digit is not 0 if the argument is a normalized floating point value. If the value is ​ 0 ​ , the exponent is also ​ 0 ​ . Precision specifies the exact number of digits to appear after the hexadecimal point character. The default precision is sufficient for exact representation of the value. In the alternative implementation decimal point character is written even if no digits follow it. For infinity and not-a-number conversion style see notes.

For the g conversion style conversion with style e or f will be performed.
For the G conversion style conversion with style E or F will be performed.
Let P equal the precision if nonzero, 6 if the precision is not specified, or 1 if the precision is ​ 0 ​ . Then, if a conversion with style E would have an exponent of X :

• if P > X ≥ −4, the conversion is with style f or F and precision P − 1 − X.
• otherwise, the conversion is with style e or E and precision P − 1.

Unless alternative representation is requested the trailing zeros are removed, also the decimal point character is removed if no fractional part is left. For infinity and not-a-number conversion style see notes.

The result is written to the value pointed to by the argument. The specification may not contain any flag, field width, or precision.

Источник: en.cppreference.com