Персональная страничка
Диканева Тараса
Викторовича
7.1. Переменные-флаги: теория
Флаг – это полотнище правильной (как правило, прямоугольной) формы прикрепленное к древку или поднимаемое на специальной мачте (флагштоке). Исторически флаги появились для передачи простых сигналов на поле боя. Например: подняли флаг, и конница понеслась в атаку! Как-то так. В простейшем случае с помощью флага передается информация объемом 1 бит (одно из двух: флаг поднят или нет).
Переменная флаг – это, как правило, переменная логического типа, значение которой сигнализирует о состоянии вычислительного процесса. Приведем несколько примеров, когда результат может характеризоваться всего одной логической переменной:
1) Подводится баланс коммерческого предприятия. Дальнейшие действия могут зависеть от того, будет он положительным или отрицательным. Если отрицательный, надо просить кредит, положительный – планировать отдых на Багамах. В общем, самая существенная информация может быть передана одним битом.
2) Решаем квадратное уравнение. Если дискриминант не отрицательный – ищем корни. Для хода вычислительного важен факт не отрицательности, который также содержит 1 бит информации и может, таким образом, быть сохранен с помощью логической переменной.
3) Детям на уроке физкультуры велено построиться по росту. Если они построились не по росту, надо на них наорать. Опять действия учителя зависят от информации объемом 1 бит.
Но кто и кому может передавать информацию в ходе выполнения программы? Дело в том, что при разработке больших программ происходит разделение задачи на более мелкие подзадачи (блоки), каждая из которых решается отдельно и, может быть даже, разными людьми. В этом случае один блок, закончив свою работу должен передать ее результат другому блоку. Здесь и могут пригодиться флаги.
Пример 1. Решение квадратного уравнения.
Предположим, что программу решения квадратного уравнения пишут два человека (ну, можно же). Пусть первый умеет решать квадратные уравнения, но не знает, как вывести результат (не ходил на лекции). Второй знает, как вывести результат, но про квадратные уравнения слышит первый раз в жизни. Попробуем представить, какую программу они напишут.
Переменная-флаг передает информацию о наличии корней. С ее помощью первый блок сигнализирует второму блоку. Вы скажете, почему бы второму программисту вместо строчки
Зачем использовать еще одну переменную? Давайте вспомним, что второй программист ничего не знает о квадратных уравнениях и в частности не в курсе, что наличие корней определяется знаком дискриминанта. Не вдаваясь в тонкости чужой задачи, он просто просит первого программиста передать существенную информацию, через переменную-флаг.
На таком простом примере, как решение квадратного уравнения трудно проникнутся ощущением полезности флагов. Я, пожалуй, соглашусь, что в данном случае флаг это лишнее. Однако, нетрудно представить себе более сложную задачу, где такой подход окажется полезным.
Представьте себе, что вам требуется написать программу размером несколько тысяч строк (это сравнительно небольшая программа). Есть единственный способ создавать программы такого размера – это разбиение решаемой задачи на подзадачи и написание отдельных блоков программы, решающих каждый свою подзадачу. Чтобы можно было сосредоточиться на решении отдельной подзадачи надо сделать их решение по возможности максимально независимым друг от друга. Для этого от одного блока к другому должно передаваться как можно меньше информации. Так что даже если программу пишет всего один человек, флаги облегчат его работу.
Как уже отмечалось, флаги минимизируют информацию, передаваемую между блоками. Так в примере с квадратным уравнением использование флага позволило передавать всего 1 бит вместо 8-ми байт, которые пришлось бы потратить на значение дискриминанта. Общий принцип здесь такой – чем меньше информации, тем труднее допустить ошибку. При разработке сложных программ поиск ошибок занимает больше времени, чем собственно их написание и любая возможность уменьшить вероятность их появления должна приветствоваться.
В дополнение еще один пример.
Пример 2. Проверка упорядоченности последовательности.
Пользователь вводит 10 чисел. Требуется проверить, упорядочены ли они по возрастанию, и передать эту информацию с помощью переменной флага.
Если очередное введенное число (x) будет меньше предыдущего (x2), то флаг примет значение false и сохранит это значение до конца цикла.
Блоки, передающие друг другу информацию с помощью флагов, не обязательно должны идти последовательно друг за другом. Можно представить себе ситуацию, когда один блок является составной частью другого. Например:
Пример 3: Найти все простые числа от 1 до N.
Число называется простым, если не делится ни на какое другое число кроме 1 и самого себя. Простейший алгоритм поиска таких чисел состоит в том, чтобы перебрать все числа и для каждого проверить наличие делителей. Поиск делителей можно мыслить себе как отдельный блок программы, результатом работы которого будет присваивание значения флаговой переменной.
Блок поиска простых чисел будет включать в себя блок проверки на наличие делителей.
Программную реализацию этого алгоритма выполните в качестве самостоятельного упражнения (см. задачу 7.1).
Не обязательно использовать в качестве флага именно логическую переменную. В принципе флагом может считаться любая переменная, принимающая небольшое количество возможных значений, каждое из которых характеризует тот или иной результат вычислительного процесса.
В примере с квадратным уравнением можно было бы предусмотреть еще одну ситуацию, когда a = 0, то есть уравнение не квадратное. Тогда для передачи информации в следующий блок можно использовать либо две переменные логического типа, либо одну, но принимающую три значения (в качестве таковой можно использовать, например, переменную целого типа).
Флаг (компьютерная техника)
В программировании понятие флаг относится к одному или нескольким битам памяти, используемым для хранения двоичной комбинации или кода, который характеризует состояние некоторого объекта. Флаги обычно входят в определённые структуры данных, такие как записи баз данных, и их значения, как правило, связаны со значением структур данных, частью которых они являются. Во многих случаях двоичное значение флага представляет собой кодированное представление одного из нескольких возможных состояний или статусов объекта. В других случаях двоичные значения флагов могут представлять собой один или несколько атрибутов в битовом поле, зачастую связанных с возможностями или доступом, например, «может быть записано в», или «может быть удалено». Однако флагам могут быть назначены и другие значения. Один из вариантов использования флагов состоит в маркировке для назначения структуры данных к последующей обработке.
В микропроцессорах и других логических устройствах флаги обычно используются для управления и индикации промежуточного или конечного состояния, а также для характеристики результата различных операций. Микропроцессоры как правило имеют регистр статуса, который состоит из таких флагов, используемых для обозначения различных состояний после операции, например, если произошло арифметическое переполнение. Флаги могут использоваться в управлении последовательностью операций, в частности, в обработке условных команд перехода. Например, по команде je (Jump if Equal, Переход по равенству) в ассемблере X86 произойдёт переход, если был установлен флаг Z (zero, ноль) на предыдущий операции.
См. также
Полезное
Смотреть что такое «Флаг (компьютерная техника)» в других словарях:
Флаг переноса — CF (англ. Carry flag) в электронных арифметических устройствах специальный флаг, устанавливаемый в результате арифметического переноса или сдвига со старшего значащего бита. Для арифметической операции может рассматриваться как… … Википедия
Флаг (значения) — Флаг: Флаг полотнище, служащее символом государства (региона, города) или используемое для передачи информации (например, на флоте). Флаг (ботаника), или парус название одного из лепестков в венчике мотылькового типа. Флаг (нотная… … Википедия
Xenus. Точка кипения (компьютерная игра) — Xenus: Boiling point Разработчик Deep Shadows Издатели Games Factory Interactive Дата выпуска … Википедия
Регистр флагов — Регистр флагов регистр процессора, отражающий текущее состояние процессора. Содержание 1 Архитектура x86 1.1 Флаги состояния 1.2 Управляющий флаг … Википедия
Серпухов — У этого термина существуют и другие значения, см. Серпухов (значения). Город Серпухов … Википедия
Acer Inc. — Acer Год основания 1976 Тип Публичная компания Расположение … Википедия
GIGABYTE Technology — Тип Публичная Девиз компании Upgrade your life Год основания 1986 Расположение … Википедия
Соединенные Штаты Америки — (США, USA) Соединенные Штаты Америки это страна в Северной Америке Соединенные штаты Америки (США) это одна из крупнейших мировых держав Содержание >>>>>>>>>>>>>>>>> … Энциклопедия инвестора
Hitachi, Ltd. — Hitachi, Ltd. Год основания 1910 Тип Публичная компания Девиз компании «Inspire the Next» («Предвосхищая будущее») … Википедия
— Hitachi, Ltd. Тип Публичная компания Листинг на бирже NYSE: HIT … Википедия
Флаги в аргументах функций
Вы когда-нибудь сталкивались с таким кодом?
Эта функция, судя по названию, что-то обрабатывает (process). Но что означают параметры? Какой параметр здесь true, а какой false? По вызывающему коду об этом нельзя судить.
Нам придется заглянуть в объявление функции, которое дает подсказку:
Очевидно, автор использует два параметра типа bool как флаги (toggles). Реализация функции может быть похожа на это:
Назначение флагов очевидно, поскольку каждый из них имеет осмысленное название. Проблема возникает в вызывающем коде. И дело не только в том, что мы не можем сразу понять, какие флаги используются. Даже зная это, мы легко можем перепутать их порядок. На самом деле, мой первый пример должен был выглядеть так:
Но я перепутал порядок аргументов.
Столкнувшись с этим багом, программист, вероятно, добавит комментарии к вызову функции, чтобы явно показать свои намерения:
И это слишком похоже на именованные параметры функции — возможность, отсутствующую в C++. Если б она была, то могла бы выглядеть как-нибудь так:
Но если бы даже в C++ такое было, вряд ли это было бы совместимо с прямой передачей (perfect forwarding):
С этим может быть связан еще более коварный баг, который гораздо труднее отследить. Представьте, что функция process — это виртуальный метод класса. И в каком-то другом классе мы его переопределяем, при этом располагая флаги в неправильном порядке:
Компилятор не заметит проблемы, поскольку параметры различаются только по именам, а их типы одинаковы (оба bool).
Баги, возникающие по причине использования логических параметров в интерфейсе, на этом не заканчиваются. Из-за того, что почти все встроенные типы преобразовываются в bool, следующий пример компилируется без ошибок, но делает не то, что ожидается:
Более распространенная проблема — с использованием bool в конструкторах. Пускай есть класс с двумя конструкторами:
В какой-то момент Вы решаете удалить второй конструктор, и может быть надеетесь, что компилятор укажет Вам на все места, требующие исправления. Но этого не происходит. Из-за неявных преобразований в bool, первый конструктор будет использован везде, где раньше использовался второй.
Однако есть причина, почему люди обычно используют bool для представления флагов. Это единственный встроенный тип, доступный «из коробки» и предназначенный для представления только двух возможных значений.
Перечисления
Чтобы решить указанные проблемы, мы должны располагать типом, отличным от bool, который удовлетворял бы следующим требованиям:
— для каждого флага создается уникальный тип,
— неявные преобразования запрещаются.
C++11 вводит понятие классов перечислений, которые удовлетворяют обоим требованиям. Также мы можем использовать тип bool как базовый тип перечисления; таким образом, мы гарантируем, что перечисление содержит только два возможных значения и имеет размер одного bool. Вначале определяем классы флагов:
Теперь мы можем объявить нашу функцию:
Есть некоторая избыточность в этом объявлении, но зато порядок использования функции теперь такой, какой нужен:
И если я поставлю флаги в неправильном порядке, то получу ошибку компиляции из-за несоответствия типов:
Каждый флаг имеет уникальный тип, который исправно работает при прямой передаче (perfect forwarding), и Вы никак не сможете расположить параметры в неправильном порядке в объявлениях функций и переопределениях виртуальных методов.
Но использование перечислений в качестве флагов имеет свою цену. Флаги в некоторой мере похожи на значения типа bool, но классы перечислений не имитируют эту схожесть. Неявные преобразования в bool и обратно не работают (и это хорошо), но явные преобразования тоже не работают, и это проблема. Если мы взглянем еще раз на тело функции process, то поймем, что оно не компилируется:
Мне приходится использовать явное преобразование:
И если мне понадобится логическое выражение с двумя флагами, то оно будет выглядеть еще неадекватнее:
Кроме того, для экземпляра класса перечисления Вы не можете сделать прямую инициализацию из bool:
Опять придется делать явное преобразование:
Это можно считать дополнительной гарантией безопасности, но здесь слишком много явных преобразований. В классах перечислений больше «explicit», чем в конструкторах и операторах преобразования, объявленных как «explicit».
tagged_bool
Из-за проблем, возникающих при использовании bool и классов перечислений, мне пришлось сделать свой собственный инструмент, который называется tagged_bool. Вы можете найти его реализацию здесь. Она совсем небольшая. С ее помощью, классы флагов объявляются вот так:
Вам придется сделать предварительное объявление класса-тэга, такого как «WithValidation_tag». Определение для него писать не нужно. Он используется для создания уникальной специализации шаблона класса tagged_bool. Эта специализация может быть явно преобразована в bool и обратно, а также в другие специализации шаблона tagged_bool, поскольку, как обычно бывает на практике, какой-нибудь bool, передающийся на нижние уровни приложения, становится впоследствии другим флагом с другим именем. Использовать созданные таким образом флаги можно вот так:
Вот и все. tagged_bool — это часть библиотеки Explicit library, которая содержит несколько инструментов, позволяющих более явно выразить Ваши намерения при проектировании интерфейсов.
От переводчика
У Анджея ранее была другая статья про тэги — «Intuitive interface — Part I» от 5 июля 2013 г. (Part 2 так и не появилась на свет, не ищите). Если вкратце, то там поднималась такая проблема:
Когда поведение конструктора зависит от формы скобочек, это само по себе опасно. Кроме того, это делает непонятным вызывающий код:
Что такое 5 и 6? Это будет 5 шестерок или 6 пятерок? Если забыли — идите смотреть документацию.
И хотелось бы иметь еще один конструктор, создающий пустой вектор с заданной capacity: std::vector v(100). К сожалению, конструктор, принимающий один size_t, уже занят — он создает вектор с заданным size’ом, заполненный сконструированными по умолчанию объектами.
Анджей упоминает, что такой порядок вещей не дает в полной мере воспользоваться возможностями прямой передачи, но в комментариях ему разъяснили, что эта проблема решается без всяких тэгов.
Анджей пришел к выводу, что реализация вектора в библиотеке STL не вполне удачная. Было бы куда проще, если бы в его конструкторах использовались тэги:
Применительно к настоящей статье, это выглядело бы так:
Разница в том, что тэг и значение теперь объединены в один объект. В статье «Competing constructors» от 29 июля 2016 г. Анджей мимоходом написал, что ему не нравится идея такого объединения.
Теперь это уже не тэги, а полноценные объекты. Кому-нибудь может прийти в голову положить их в контейнер:
Поведение этого кода опять зависит от формы скобочек. Что за радость была вводить тэги, если мы снова вернулись к той же проблеме? По крайней мере, простые тэги вряд ли кому-нибудь захочется хранить в контейнере. Ведь они могут иметь только одно значение.
С bool, однако, эта угроза не так страшна. Конструкторы контейнеров STL не принимают bool, иначе как в составе initializer_list’ов. Видимо, поэтому Анджей и решился в этот раз объединить тэг и значение.
Напоследок приведу перевод нескольких комментариев к статье.
Комментарии
kszatan
February 17, 2017 at 11:36 am
Я бы в первую очередь подумал об избавлении от всех этих флагов и вывел бы код для подтверждений (validations) и нового/старого движка (new/old engine) в отдельные классы, чтобы передавать их как аргументы. Функция «process» и так уже делает слишком много.
Andrzej Krzemieński
February 17, 2017 at 12:03 pm
В простых случаях отказ от любых флагов действительно может оказаться лучшим выбором. Но когда решение установить флаг принимается несколькими уровнями выше в стеке вызовов, такой рефакторинг может оказаться неосуществимым или непрактичным.
micleowen
February 17, 2017 at 10:41 pm
«explicit» используется в конструкторах с одним параметром.
Andrzej Krzemieński
February 20, 2017 at 8:22 am
ARNAUD
February 18, 2017 at 6:39 pm
«Неявные преобразования в bool и обратно не работают (и это хорошо), но явные преобразования тоже не работают, и это проблема»
Не понимаю, что в этом плохого:
Сначала Вы используете общеизвестную возможность языка, и Ваш код прекрасно читается и понимается всеми специалистами по С++. Потом Вы переходите к использованию специального шаблона для автоматического преобразования в bool и обратно? Меня это не убеждает.
И еще. Представьте, что через какое-то время один из параметров перестанет быть bool и сможет принимать значения no_engine, engine_v1, engine_v2… Класс перечисления позволяет сделать такое расширение естественным путем, в отличие от Вашего tagged_bool.
Andrzej Krzemieński
February 20, 2017 at 8:36 am
Вы подняли два вопроса.
И, в случае использования пространств имен:
Для меня это компромисс между желаемым уровнем безопасности и удобством использования. Мой личный выбор — что-то безопаснее bool, но не такое многословное как классы перечислений. Видимо, Ваш компромисс лежит ближе к классам перечислений.
2. Возможность добавить третье состояние
Если Вы предвидите, что в будущем Вам может понадобиться третье состояние, то классы перечислений и правда могут быть предпочтительнее. А могут и не быть. Потому что, когда Вы добавляете третье состояние, все Ваши if’ы продолжают исправно компилироваться, хотя Вы, может быть, желаете их отредактировать, чтобы добавить проверку третьего состояния.
По моему опыту, эти флаги используются как временные решения, и их дальнейшее развитие не в том, чтобы добавить третье состояние, а в том, чтобы избавиться от двух имеющихся. Например, я улучшаю какую-то часть программы, но в течение пары месяцев хочу дать пользователям возможность переключиться обратно на старую реализацию, на случай, если я что-то недосмотрел, и улучшение только все испортит. Если после пары месяцев все пользователи остались довольны, я удаляю поддержку старой реализации и избавляюсь от флага.
mftdev00
March 13, 2017 at 1:05 pm
Я вообще не люблю флаги. Они противоречат принципу единственной ответственности. Делай что-то, если true, делай что-то другое, если false…
Andrzej Krzemieński
March 13, 2017 at 1:10 pm
Согласен. Везде, где это возможно, нужно обходиться без флагов.
SebB
March 21, 2017 at 6:09 pm
Можно ли вместо явного удаления конструкторов для каждого типа:
…просто удалить их для всех типов (кроме bool) разом?
Andrzej Krzemieński
March 22, 2017 at 7:32 am
Я просто не учел такую возможность, когда разрабатывал интерфейс. Может, и полезно было бы это добавить. Но теперь, когда Вы это предложили, я вижу один случай, где это имело бы отрицательный эффект: кто-то может использовать свой собственный (безопасный) логический тип с неявным преобразованием в bool. В этом случае, нам, может быть, нужно позволить этому типу работать с tagged_bool.
Флаг (компьютерная техника)
Пример использования флагов в языке С(Си):Иногда выгодно использовать массивы флагов, чтобы отметить некоторые элементы другого массива, для последующей работы с ними.
В микропроцессорах и других логических устройствах флаги обычно используются для управления и индикации промежуточного или конечного состояния, а также для характеристики результата различных операций. Микропроцессоры как правило имеют регистр статуса, который состоит из таких флагов, используемых для обозначения различных состояний после операции, например, если произошло арифметическое переполнение. Флаги могут использоваться в управлении последовательностью операций, в частности, в обработке условных команд перехода. Например, по команде je (Jump if Equal, Переход по равенству) в ассемблере X86 произойдёт переход, если был установлен флаг Z (zero, ноль) на предыдущей операции.
Связанные понятия
Упоминания в литературе
Связанные понятия (продолжение)
В программировании, ассемблерной вставкой называют возможность компилятора встраивать низкоуровневый код, написанный на ассемблере, в программу, написанную на языке высокого уровня, например, Си или Ada. Использование ассемблерных вставок может преследовать следующие цели.
Парсер (англ. parser; от parse – анализ, разбор) или синтаксический анализатор — часть программы, преобразующей входные данные (как правило, текст) в структурированный формат. Парсер выполняет синтаксический анализ текста.
В области телекоммуникаций и информатике параллельным соединением называют метод передачи нескольких сигналов с данными одновременно по нескольким параллельным каналам. Это принципиально отличается от последовательного соединения; это различие относится к одной из основных характеристик коммуникационного соединения.
В Unix-подобных операционных системах пользователи идентифицируются идентификаторами пользователя (англ. User identifier, UID).
Не путайте с ECC памятью, хотя регистровые модули всегда используют ECC.Регистровая память (англ. Registered Memory, RDIMM, иногда buffered memory) — вид компьютерной оперативной памяти, модули которой содержат регистр между микросхемами памяти и системным контроллером памяти. Наличие регистров уменьшает электрическую нагрузку на контроллер и позволяет устанавливать больше модулей памяти в одном канале. Регистровая память является более дорогой из-за меньшего объема производства и наличия дополнительных.
Урок №209. Функционал классов ostream и ios. Форматирование вывода
Обновл. 15 Сен 2021 |
На этом уроке мы рассмотрим функционал классов ostream и ios в языке С++.
Форматирование вывода
Есть два способа управления параметрами форматирования вывода:
флаги — это логические переменные, которые можно включить/выключить;
манипуляторы — это объекты, которые помещаются в поток и влияют на способ ввода/вывода данных.
Для включения флага используйте функцию setf() с соответствующим флагом в качестве параметра. Например, по умолчанию C++ не выводит знак + перед положительными числами. Однако, используя флаг std::showpos, мы можем это изменить:
Также можно включить сразу несколько флагов, используя побитовый оператор ИЛИ ( | ):
Чтобы отключить флаг, используйте функцию unsetf():
Многие флаги принадлежат к определенным группам форматирования. Группа форматирования — это группа флагов, которые задают аналогичные (иногда взаимоисключающие) параметры форматирования вывода. Например, есть группа форматирования basefield.
Флаги группы форматирования basefield:
oct (от англ. «octal» = «восьмеричный») — восьмеричная система счисления;
dec (от англ. «decimal» = «десятичный») — десятичная система счисления;
hex (от англ. «hexadecimal» = «шестнадцатеричный») — шестнадцатеричная система счисления.
Эти флаги управляют выводом целочисленных значений. По умолчанию установлен флаг std::dec, т.е. значения выводятся в десятичной системе счисления. Попробуем сделать следующее:
Ничего не работает! Почему? Дело в том, что setf() только включает флаги, он не настолько умен, чтобы одновременно отключать другие (взаимоисключающие) флаги. Следовательно, когда мы включаем std::hex, std::dec также включен и у него приоритет выше. Есть два способа решения данной проблемы.
Во-первых, мы можем отключить std::dec, а затем включить std::hex:
Теперь уже результат тот, что нужно:
Второй способ — использовать вариацию функции setf(), которая принимает два параметра:
первый параметр — это флаг, который нужно включить/выключить;
второй параметр — группа форматирования, к которой принадлежит флаг.
При использовании этой вариации функции setf() все флаги, принадлежащие группе форматирования, отключаются, а включается только передаваемый флаг. Например:
Язык C++ также предоставляет еще один способ изменения параметров форматирования: манипуляторы. Фишка манипуляторов в том, что они достаточно умны, чтобы одновременно включать и выключать соответствующие флаги. Например:
В общем, использовать манипуляторы гораздо проще, нежели включать/выключать флаги. Многие параметры форматирования можно изменять как через флаги, так и через манипуляторы, но есть и такие параметры форматирования, которые изменить можно либо только через флаги, либо только через манипуляторы.
Полезные флаги, манипуляторы и методы
Флаг:
Манипуляторы:
1 0
true false
1 0
true false
Флаг:
Манипуляторы:
Флаг:
uppercase — если включен, то используются заглавные буквы.
Манипуляторы:
uppercase — используются заглавные буквы.
nouppercase — используются строчные буквы.
1.23457e+007
1.23457E+007
1.23457e+007
1.23457E+007
Флаги группы форматирования basefield:
dec — значения выводятся в десятичной системе счисления;
hex — значения выводятся в шестнадцатеричной системе счисления;
oct — значения выводятся в восьмеричной системе счисления.
Манипуляторы:
dec — значения выводятся в десятичной системе счисления;
hex — значения выводятся в шестнадцатеричной системе счисления;
oct — значения выводятся в восьмеричной системе счисления.
Теперь вы уже должны понимать связь между флагами и манипуляторами.
Точность, запись чисел и десятичная точка
Используя манипуляторы (или флаги), можно изменить точность и формат вывода значений типа с плавающей точкой.
Флаги группы форматирования floatfield:
fixed — используется десятичная запись чисел типа с плавающей точкой;
scientific — используется экспоненциальная запись чисел типа с плавающей точкой;
showpoint — всегда отображается десятичная точка и конечные нули для чисел типа с плавающей точкой.
Манипуляторы:
fixed — используется десятичная запись значений;
scientific — используется экспоненциальная запись значений;
showpoint — отображается десятичная точка и конечные нули чисел типа с плавающей точкой;
noshowpoint — не отображаются десятичная точка и конечные нули чисел типа с плавающей точкой;
setprecision(int) — задаем точность для чисел типа с плавающей точкой.
Методы:
precision() — возвращаем текущую точность для чисел типа с плавающей точкой;
precision(int) — задаем точность для чисел типа с плавающей точкой.
Если используется десятичная или экспоненциальная запись чисел, то точность определяет количество цифр после запятой/точки. Обратите внимание, если точность меньше количества значащих цифр, то число будет округлено. Например: