Сколько значащих разрядов в числе 0 1234567890

Функция ЗнаковПослеЗапятой

Выводит количество значащих знаков после запятой, т.е. последние нули в результате не участвуют.

Синтаксис:

• Число – обязательный аргумент. Число или ссылка на число, для которого выводится количество знаков после запятой.

Будьте внимательнее, работая с большими числами и числами высокой точности, так как Excel точно может хранить в ячейках до 15 знаков. В случае превышения этого количества меньшие разряды усекаются. Пример:

• Число 0,1234567890123456789 будет преобразовано до 0,123456789012345;
• Число 1234567890,123456789 округлиться до 1234567890,12345.

Для того, чтобы использовать описанные в данной категории функции, скачайте и установите нашу надстройку.
Работа надстройки была успешно протестирована на версиях Excel: 2007, 2010 и 2013. В случае возникновения проблем с ее использованием, сообщайте Администрации сайта.

• Критерий Манна-Уитни
• Подключение MySQL в Excel
• Подключение Excel к SQL Server

Если материалы office-menu.ru Вам помогли, то поддержите, пожалуйста, проект, чтобы я мог развивать его дальше.

Сколько значащих разрядов в числе 0 1234567890

Каждая переменная имеет определенный тип. И этот тип определяет, какие значения может иметь переменная, какие операции с ней можно производить и сколько байт в памяти она будет занимать. В языке C++ определены следующие базовые типы данных: логический тип bool , целочисленные типы, типа чисел с плавающей точкой, символьные типы. Рассмотрим эти группы по отдельности.

Логический тип

Логический тип bool может хранить одно из двух значений: true (истинно, верно) и false (неверно, ложно). Например, определим пару переменных данного типа и выведем их значения на консоль:

#include int main() < bool isAlive ; bool isDead ; std::cout

При выводе значения типа bool преобразуются в 1 (если true) и 0 (если false). Как правило, данный тип применяется преимущество в условных выражениях, которые будут далее рассмотрены.

Значение по умолчанию для переменных этого типа — false .

Целочисленные типы

Целые числа в языке C++ представлены следующими типами:

• signed char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от -128 до 127
• unsigned char : представляет один символ. Занимает в памяти 1 байт (8 бит). Может хранить любой значение из диапазона от 0 до 255
• char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255 Несмотря на то, что данный тип представляет тот же диапазон значений, что и вышеописанный тип signed char , но они не эквивалентны. Тип char предназначен для хранения числового кода символа и в реальности может представлять как signed byte , так и unsigned byte в зависимости от конкретного компилятора.
• short : представляет целое число в диапазоне от –32768 до 32767. Занимает в памяти 2 байта (16 бит). Данный тип также имеет псевдонимы short int , signed short int , signed short .
• unsigned short : представляет целое число в диапазоне от 0 до 65535. Занимает в памяти 2 байта (16 бит). Данный тип также имеет синоним unsigned short int .
• int : представляет целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита). Диапазон предельных значений соответственно также может варьироваться от –32768 до 32767 (при 2 байтах) или от −2 147 483 648 до 2 147 483 647 (при 4 байтах). Но в любом случае размер должен быть больше или равен размеру типа short и меньше или равен размеру типа long Данный тип имеет псевдонимы signed int и signed .
• unsigned int : представляет положительное целое число. В зависимости от архитектуры процессора может занимать 2 байта (16 бит) или 4 байта (32 бита), и из-за этого диапазон предельных значений может меняться: от 0 до 65535 (для 2 байт), либо от 0 до 4 294 967 295 (для 4 байт). Имеет псевдоним unsigned
• long : в зависимости от архитектуры может занимать 4 или 8 байт и представляет целое число в диапазоне от −2 147 483 648 до 2 147 483 647 (при 4 байтах) или от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807 (при 8 байтах). Занимает в памяти 4 байта (32 бита) или. Имеет псевдонимы long int , signed long int и signed long
• unsigned long : представляет целое число в диапазоне от 0 до 4 294 967 295. Занимает в памяти 4 байта (32 бита). Имеет синоним unsigned long int .
• long long : представляет целое число в диапазоне от −9 223 372 036 854 775 808 до +9 223 372 036 854 775 807. Занимает в памяти 8 байт (64 бита). Имеет псевдонимы long long int , signed long long int и signed long long .
• unsigned long long : представляет целое число в диапазоне от 0 до 18 446 744 073 709 551 615. Занимает в памяти, как правило, 8 байт (64 бита). Имеет псевдоним unsigned long long int .

Для представления чисел в С++ применятся целочисленные литералы со знаком или без, типа -10 или 10. Например, определим ряд переменных целочисленных типов и выведем их значения на консоль:

#include int main() < signed char num1< -64 >; unsigned char num2< 64 >; short num3< -88 >; unsigned short num4< 88 >; int num5< -1024 >; unsigned int num6< 1024 >; long num7< -2048 >; unsigned long num8< 2048 >; long long num9< -4096 >; unsigned long long num10< 4096 >; std::cout u или U. Литералы типов long и long long имеют суффиксы L/l и LL/ll соответственно:
 
#include int main() < unsigned int num6< 1024U >; // U - unsigned int long num7< -2048L >; // L - long unsigned long num8< 2048UL >; // UL - unsigned long long long num9< -4096LL >; // LL - long long unsigned long long num10< 4096ULL >;// ULL - unsigned long long std::cout #include int main() < int num< 1'234'567'890 >; std::cout 
Различные системы исчисления
По умолчанию все стандартные целочисленные литералы представляют числа в привычной нам десятичной системе. Однако C++ также позволяет использовать и числа в других системах исчисления.
Чтобы указать, что число - шестнадцатеричное, перед числом указывается префикс 0x или 0X . Например:
int num1< 0x1A>; // 26 - в десятичной int num2< 0xFF >; // 255 - в десятичной int num3< 0xFFFFFF >; //16777215 - в десятичной
Чтобы указать, что число - восьмеричное, перед числом указывается ноль 0 . Например:
int num1< 034>; // 26 - в десятичной int num2< 0377 >; // 255 - в десятичной
Бинарные литералы предваряются префиксом 0b или 0B :
int num1< 0b11010>; // 26 - в десятичной int num2< 0b11111111 >; // 255 - в десятичной
Все эти типы литералов также поддерживают суффиксы U/L/LL :
unsigned int num1< 0b11010U>; // 26 - в десятичной long num2< 0377L >; // 255 - в десятичной unsigned long num3< 0xFFFFFFULL >; //16777215 - в десятичной
Числа с плавающей точкой
Для хранения дробных чисел в C++ применяются числа с плавающей точкой. Число с плавающей точкой состоит из двух частей: мантиссы и показателя степени . Оба могут быть как положительными, так и отрицательными. Величина числа – это мантисса, умноженная на десять в степени экспоненты.
Например, число 365 может быть записано в виде числа с плавающей точкой следующим образом:
3.650000E02
В качестве разделителя целой и дробной частей используется символ точки. Мантисса здесь имеет семь десятичных цифр - 3.650000 , показатель степени - две цифры 02 . Буква E означает экспоненту, после нее указывается показатель степени (степени десяти), на которую умножается часть 3.650000 (мантисса), чтобы получить требуемое значение. То есть, чтобы вернуться к обычному десятичному представлению, нужно выполнить следующую операцию:
3.650000 × 102 = 365
Другой пример - возьмем небольшое число:
-3.650000E-03
В данном случае мы имеем дело с числом –3.65 × 10 -3 , что равно –0.00365 . Здесь мы видим, что в зависимости от значения показателя степени десятичная точка "плавает". Собственно поэтому их и называют числами с плавающей точкой.
Однако хотя такая запись позволяет определить очень большой диапазон чисел, не все эти числа могут быть представлены с полной точностью; числа с плавающей запятой в целом являются приблизительными представления точного числа. Например, число 1254311179 выглядело бы так: 1.254311E09 . Однако если перейти к десятичной записи, то это будет 1254311000 . А это не то же самое, что и 1254311179 , поскольку мы потеряли три младших разряда.
В языке C++ есть три типа для представления чисел с плавающей точкой:

float : представляет вещественное число одинарной точности с плавающей точкой в диапазоне +/- 3.4E-38 до 3.4E+38. В памяти занимает 4 байта (32 бита)
double : представляет вещественное число двойной точности с плавающей точкой в диапазоне +/- 1.7E-308 до 1.7E+308. В памяти занимает 8 байт (64 бита)
long double : представляет вещественное число двойной точности с плавающей точкой не менее 8 байт (64 бит). В зависимости от размера занимаемой памяти может отличаться диапазон допустимых значений.

В своем внутреннем бинарном представлении каждое число с плавающей запятой состоит из одного бита знака, за которым следует фиксированное количество битов для показателя степени и набор битов для хранения мантиссы. В числах float 1 бит предназначен для хранения знака, 8 бит для экспоненты и 23 для мантиссы, что в сумме дает 32 бита. Мантисса позволяет определить точность числа в виде 7 десятичных знаков.
В числах double : 1 знаковый бит, 11 бит для экспоненты и 52 бит для мантиссы, то есть в сумме 64 бита. 52-разрядная мантисса позволяет определить точность до 16 десятичных знаков.
Для типа long double расклад зависит от конкретного компилятора и реализации этого типа данных. Большинство компиляторов предоставляют точность до 18 - 19 десятичных знаков (64-битная мантисса), в других же (как например, в Microsoft Visual C++) long double аналогичен типу double .
В C++ литералы чисел с плавающими точками представлены дробными числами, которые в качестве разделителя целой и дробной частей применяют точку:
double num ;
Даже если переменной присваивается целое число, чтобы показать, что мы присваиваем число с плавающей точкой, применяется точка:
double num1< 1 >; // 1 - целочисленный литерал double num2< 1. >; //1. - литерал числа с плавающей точкой
Так, здесь число 1. представляет литерал числа с плавающей точкой, и в принципе аналогичен 1.0 .
По умолчанию все такие числа с точкой расцениваются как числа типа double. Чтобы показать, что число представляет другой тип, для float применяется суффикс f / F , а для long double - l / L :
float num1< 10.56f >; // float long double num2< 10.56l >; // long double
В качестве альтернативы также можно применять экспоненциальную запись:
double num1< 5E3 >; // 5E3 = 5000.0 double num2< 2.5e-3 >; // 2.5e-3 = 0.0025
Размеры типов данных
При перечислении типов данных указывался размер, который он занимает в памяти. Но стандарт языка устанавливает лишь минимальные значения, которые должны быть. Например, для типов int и short минимальное значение - 16 бит, для типа long - 32 бита, для типа long double - 64 разряда. При этом размер типа long должен быть не меньше размера типа int, а размер типа int - не меньше размера типа short, а размер типа long double должен быть не меньше double . А разработчики компиляторов могут выбирать предельные размеры для типов самостоятельно, исходя из аппаратных возможностей компьютера.
К примеру, компилятор g++ Windows для long double использует 16 байт. А компилятор в Visual Studio, который также работает под Windows, и clang++ под Windows для long double используют 8 байт. То есть даже в рамках одной платформы разные компиляторы могут по разному подходить к размерам некоторых типов данных. Но в целом используются те размеры, которые указаны выше при описании типов данных.
Однако бывают ситуации, когда необходимо точно знать размер определенного типа. И для этого в С++ есть оператор sizeof() , который возвращает размер памяти в байтах, которую занимает переменная:
#include int main() < long double number ; std::cout 
sizeof(number) = 16
Символьные типы
В C++ есть следующие символьные типы данных:

char : представляет один символ в кодировке ASCII. Занимает в памяти 1 байт (8 бит). Может хранить любое значение из диапазона от -128 до 127, либо от 0 до 255
wchar_t : представляет расширенный символ. На Windows занимает в памяти 2 байта (16 бит), на Linux - 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 65 535 (при 2 байтах), либо от 0 до 4 294 967 295 (для 4 байт)
char8_t : представляет один символ в кодировке Unicode. Занимает в памяти 1 байт. Может хранить любой значение из диапазона от 0 до 256
char16_t : представляет один символ в кодировке Unicode. Занимает в памяти 2 байта (16 бит). Может хранить любой значение из диапазона от 0 до 65 535
char32_t : представляет один символ в кодировке Unicode. Занимает в памяти 4 байта (32 бита). Может хранить любой значение из диапазона от 0 до 4 294 967 295

char
Переменная типа char хранит числовой код одного символа и занимает один байт. Стандарт языка С++ не определяет кодировку символов, которая будет использоваться для символов char, поэтому производители компиляторов могут выбирать любую кодировку, но обычно это ASCII.
В качестве значения переменная типа char может принимать один символ в одинарных кавычках, либо числовой код символа:
#include int main() < char a1 ; char a2 ; std::cout


В данном случае переменные a1 и a2 будут иметь одно и то же значение, так как 65 - это числовой код символа "A" в таблице ASCII. При выводе на консоль с помощью cout по умолчанию отображается символ.
Кроме того, в C++ можно использовать специальные управляющие последовательности, которые предваряются слешем и которые интерпретируются особым образом. Например, "\n" представляет перевод строки, а "\t" - табуляцию.
Однако ASCII обычно подходит для наборов символов языков, которые используют латиницу. Но если необходимо работать с символами для нескольких языков одновременно или с символами языков, отличных от английского, 256-символьных кодов может быть недостаточно. И в этом случае применяется Unicode .
Unicode (Юникод) — это стандарт, который определяет набор символов и их кодовых точек, а также несколько различных кодировок для этих кодовых точек. Наиболее часто используемые кодировки: UTF-8, UTF-16 и UTF-32. Разница между ними заключается в том, как представлена кодовая точка символа; числовое же значение кода для любого символа остается одним и тем же в любой из кодировок. Основные отличия:

UTF-8 представляет символ как последовательность переменной длины от одного до четырех байт. Набор символов ASCII появляется в UTF-8 как однобайтовые коды, которые имеют те же значения кодов, что и в ASCII. UTF-8 на сегодняшний день является самой популярной кодировкой Unicode.
UTF-16 представляет символы как одно или два 16-битных значения.
UTF-32 представляет все символы как 32-битные значения

В C++ есть четыре типа для хранения символов Unicode: wchar_t , char8_t , char16_t и char32_t ( char16_t и char32_t были добавлены в C+11, а char8_t - в C++20).
wchar_t
Тип wchar_t — это основной тип, предназначенный для наборов символов, размер которых выходит за пределы одного байта. Собственно отсюда и его название: wchar_t - wide (широкий) char. происходит от широкого символа, потому что этот символ «шире», чем обычный однобайтовый символ. Значения wchar_t определяются также как и символы char за тем исключением, что они предваряются символов "L":
wchar_t a1 ;
Также можно передать код символа
wchar_t a1 ;
Значение, заключенное в одинарные кавычки, представляет собой шестнадцатеричный код символа. Обратная косая черта указывает на начало управляющей последовательности, а x после обратной косой черты означает, что код шестнадцатеричный.
Стоит учитывать, что для вывода на консоль символов wchar_t следует использовать не std::cout , а поток std::wcout :
#include int main() < char h = 'H'; wchar_t i ; std::wcout


При этом поток std::wcout может работать как с char, так и с wchar_t. А поток std::cout для переменной wchar_t вместо символа будет выводить его числовой код.
Проблема с типом wchar_t заключается в том, что его размер сильно зависит от реализации и применяемой кодировки. Кодировка обычно соответствует предпочтительной кодировке целевой платформы. Так, для Windows wchar_t обычно имеет ширину 16 бит и кодируется с помощью UTF-16. Большинство других платформ устанавливают размер в 32 бита, а в качестве кодировки применяют UTF-32. С одной стороны, это позволяет больше соответствовать конкретной платформе. Но с другой стороны, затрудняет написание кода, переносимого на разные платформы. Поэтому в общем случае часто рекомендуется использовать типы char8_t , char16_t и char32_t . Значения этих типов предназначены для хранения символов в кодировке UTF-8, UTF-16 или UTF-32 соответственно, а их размеры одинаковы на всех распространенных платформах.
Для определения символов типов char8_t , char16_t и char32_t применяются соответственно префиксы u8, u и U:
char8_t c< u8'l' >; char16_t d< u'l' >; char32_t e< U'o' >;
Стоит отметить, что для вывода на консоль значений char8_t/char16_t/char32_t пока нет встроенных инструментов типа std:cout/std:wcout .
Спецификатор auto
Иногда бывает трудно определить тип выражения. В этом случае можно предоставить компилятору самому выводить тип объекта. И для этого применяется спецификатор auto . При этом если мы определяем переменную со спецификатором auto, эта переменная должна быть обязательно инициализирована каким-либо значением:
auto number = 5; // number имеет тип int auto sum ; // sum имеет тип double auto distance ; // distance имеет тип unsigned long
На основании присвоенного значения компилятор выведет тип переменной. Неинициализированные переменные со спецификатором auto не допускаются:
Строки настраиваемых числовых форматов
Чтобы определить способ форматирования числовых данных, можно создать строку настраиваемого числового формата, состоящую из одного или нескольких описателей настраиваемого формата. Строка настраиваемого числового формата — это любая строка формата, не являющаяся строкой стандартного числового формата.
Строки настраиваемых числовых форматов поддерживаются некоторыми перегрузками метода ToString всех числовых типов. Например, можно задать строку числового формата для методов ToString(String) и ToString(String, IFormatProvider) типа Int32 . Строки настраиваемых числовых форматов также поддерживаются функцией составного форматирования .NET Framework, используемой некоторыми методами Write и WriteLine классов Console и StreamWriter, а также методами String.Format и StringBuilder.AppendFormat. Функция интерполяции строк также поддерживает строки настраиваемого числового формата.
Вы можете загрузить служебную программу форматирования — приложение Windows Forms для .NET Core, позволяющее применять строки формата к значениям даты и времени и числовым значениям и отображающее результирующую строку. Исходный код доступен для C# и Visual Basic.
В следующей таблице приведены описатели стандартного числового формата и примеры выходных данных, формируемых каждым описателем формата. Дополнительные сведения об использовании строк настраиваемого числового формата см. в разделе Примечания ; обширную демонстрацию их использования см. в разделе Пример .


Спецификатор формата
Имя
Описание
Примеры



"0"
Знак-заместитель нуля
Заменяет ноль соответствующей цифрой, если такая имеется. В противном случае в результирующей строке будет стоять ноль.


0.45678 ("0.00", en-US) -> 0,46
Обратите внимание, что в итоговой строке не будет отображаться цифра, если соответствующей цифрой в строке ввода является незначащий 0. Например, 0003 ("###") —> 3.
0.45678 ("#.#", en-US) -> 46
2147483647 ("#,#", en-US) -> 2,147 483 647
2147483647 ("#,#", es-ES) -> 2.147.483.647
2147483647 ("#,#,", en-US) -> 2,147
0.3697 ("%#0.00", el-GR) -> %36,97
0.3697 ("#.0 %", en-US) -> 37,0 %
1503.92311 ("0.0##e+00") -> 1.504e+03
В приведенных ниже разделах содержится подробная информация о всех описателях настраиваемого числового формата.
Некоторые примеры C# в этой статье выполняются во встроенном средстве выполнения кода и на тестовой площадке Try.NET. Нажмите на кнопку Выполнить, чтобы выполнить пример в интерактивном окне. После выполнения кода вы можете изменить его и выполнить измененный код, снова нажав на кнопку Выполнить. Либо в интерактивном окне выполняется измененный код, либо, если компиляция завершается с ошибкой, в интерактивном окне отображаются все сообщения об ошибках компилятора C#.
Настраиваемый описатель "0"
Описатель настраиваемого формата "0" служит нулевым символом-заполнителем. Если форматируемое значение содержит цифру в позиции, где в строке формата стоит ноль, то эта цифра копируется в результирующую строку; в противном случае в результирующей строке будет стоять ноль. Позиция крайнего левого нуля перед разделителем целой и дробной частей и позиция крайнего правого нуля после разделителя целой и дробной частей определяют диапазон цифр, которые всегда включаются в результирующую строку.
Спецификатор "00" приводит к округлению значения до ближайшего значения цифры, предшествующей десятичной точке-разделителю, если назначено использование округления от нуля. Например, в результате форматирования числа 34,5 с помощью строки "00" будет получена строка со значением"35".
В следующем примере показано форматирование нескольких значений с помощью строк настраиваемого формата, содержащих нулевые заполнители.
double value; value = 123; Console::WriteLine(value.ToString("00000")); Console::WriteLine(String::Format("", value)); // Displays 00123 value = 1.2; Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1.20 Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 01.20 CultureInfo^ daDK = CultureInfo::CreateSpecificCulture("da-DK"); Console::WriteLine(value.ToString("00.00", daDK)); Console::WriteLine(String::Format(daDK, "", value)); // Displays 01,20 value = .56; Console::WriteLine(value.ToString("0.0", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 0.6 value = 1234567890; Console::WriteLine(value.ToString("0,0", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1,234,567,890 CultureInfo^ elGR = CultureInfo::CreateSpecificCulture("el-GR"); Console::WriteLine(value.ToString("0,0", elGR)); Console::WriteLine(String::Format(elGR, "", value)); // Displays 1.234.567.890 value = 1234567890.123456; Console::WriteLine(value.ToString("0,0.0", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1,234,567,890.1 value = 1234.567890; Console::WriteLine(value.ToString("0,0.00", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1,234.57 
 double value; value = 123; Console.WriteLine(value.ToString("00000")); Console.WriteLine(String.Format("", value)); // Displays 00123 value = 1.2; Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1.20 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 01.20 CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK"); Console.WriteLine(value.ToString("00.00", daDK)); Console.WriteLine(String.Format(daDK, "", value)); // Displays 01,20 value = .56; Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 0.6 value = 1234567890; Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1,234,567,890 CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR"); Console.WriteLine(value.ToString("0,0", elGR)); Console.WriteLine(String.Format(elGR, "", value)); // Displays 1.234.567.890 value = 1234567890.123456; Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1,234,567,890.1 value = 1234.567890; Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1,234.57 
Dim value As Double value = 123 Console.WriteLine(value.ToString("00000")) Console.WriteLine(String.Format("", value)) ' Displays 00123 value = 1.2 Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1.20 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 01.20 Dim daDK As CultureInfo = CultureInfo.CreateSpecificCulture("da-DK") Console.WriteLine(value.ToString("00.00", daDK)) Console.WriteLine(String.Format(daDK, "", value)) ' Displays 01,20 value = .56 Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 0.6 value = 1234567890 Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1,234,567,890 Dim elGR As CultureInfo = CultureInfo.CreateSpecificCulture("el-GR") Console.WriteLine(value.ToString("0,0", elGR)) Console.WriteLine(String.Format(elGR, "", value)) ' Displays 1.234.567.890 value = 1234567890.123456 Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1,234,567,890.1 value = 1234.567890 Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1,234.57 
Настраиваемый описатель "#"
Описатель настраиваемого формата "#" служит символом-заполнителем для цифр. Если в форматируемом значении на позиции, где в строке формата присутствует символ "#", есть цифра, то эта цифра копируется в результирующую строку. В противном случае в выходной строке на этой позиции ничего не записывается.
Обратите внимание, что при использовании этого описателя незначащие нули не отображаются, даже если ноль является единственной цифрой в строке. Ноль отображается только в том случае, если он является значащей цифрой отображаемого числа.
Строка формата "##" приводит к округлению значения до ближайшего значения цифры, предшествующей десятичному разделителю, если назначено использование округления от нуля. Например, в результате форматирования числа 34,5 с помощью строки "##" будет получена строка со значением "35".
В следующем примере показано форматирование нескольких значений с помощью строк настраиваемого формата, содержащих заполнители для цифр.
 double value; value = 1.2; Console::WriteLine(value.ToString("#.##", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1.2 value = 123; Console::WriteLine(value.ToString("#####")); Console::WriteLine(String::Format("", value)); // Displays 123 value = 123456; Console::WriteLine(value.ToString("[##-##-##]")); Console::WriteLine(String::Format("", value)); // Displays [12-34-56] value = 1234567890; Console::WriteLine(value.ToString("#")); Console::WriteLine(String::Format("", value)); // Displays 1234567890 Console::WriteLine(value.ToString("(###) ###-####")); Console::WriteLine(String::Format("", value)); // Displays (123) 456-7890 
double value; value = 1.2; Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1.2 value = 123; Console.WriteLine(value.ToString("#####")); Console.WriteLine(String.Format("", value)); // Displays 123 value = 123456; Console.WriteLine(value.ToString("[##-##-##]")); Console.WriteLine(String.Format("", value)); // Displays [12-34-56] value = 1234567890; Console.WriteLine(value.ToString("#")); Console.WriteLine(String.Format("", value)); // Displays 1234567890 Console.WriteLine(value.ToString("(###) ###-####")); Console.WriteLine(String.Format("", value)); // Displays (123) 456-7890 
Dim value As Double value = 1.2 Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1.2 value = 123 Console.WriteLine(value.ToString("#####")) Console.WriteLine(String.Format("", value)) ' Displays 123 value = 123456 Console.WriteLine(value.ToString("[##-##-##]")) Console.WriteLine(String.Format("", value)) ' Displays [12-34-56] value = 1234567890 Console.WriteLine(value.ToString("#")) Console.WriteLine(String.Format("", value)) ' Displays 1234567890 Console.WriteLine(value.ToString("(###) ###-####")) Console.WriteLine(String.Format("", value)) ' Displays (123) 456-7890 
Чтобы получить итоговую строку, в которой отсутствуют цифры или начальные нули заменены пробелами, используйте функциональность составного форматирования и укажите ширину поля, как показано в следующем примере.
using namespace System; void main() < Double value = .324; Console::WriteLine("The value is: ''", value); > // The example displays the following output if the current culture // is en-US: // The value is: ' .324' 
using System; public class SpaceOrDigit < public static void Main() < Double value = .324; Console.WriteLine("The value is: ''", value); > > // The example displays the following output if the current culture // is en-US: // The value is: ' .324' 
Module SpaceExample Public Sub Main() Dim value As Double = 0.324 Console.WriteLine("The value is: ''", value) End Sub End Module ' The example displays the following output if the current culture ' is en-US: ' The value is: ' .324' 
Настраиваемый описатель "."
Описатель настраиваемого формата "." вставляет в результирующую строку локализованный разделитель целой и дробной частей числа. Первая точка в строке формата определяет расположение разделителя целой и дробной частей форматированного значения, а все прочие точки игнорируются. Если описатель формата заканчивается "." только значимыми цифрами, отформатированными в результирующем строке.
Символ, используемый в качестве разделителя целой и дробной части в результирующей строке, не всегда будет точкой; его значение определяется свойством NumberDecimalSeparator объекта NumberFormatInfo , управляющего форматированием.
В следующем примере спецификатор формата "." используется для определения местоположения десятичного разделителя в нескольких выходных строках.
 double value; value = 1.2; Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1.20 Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 01.20 Console::WriteLine(value.ToString("00.00", CultureInfo::CreateSpecificCulture("da-DK"))); Console::WriteLine(String::Format(CultureInfo::CreateSpecificCulture("da-DK"), "", value)); // Displays 01,20 value = .086; Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 8.6% value = 86000; Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 8.6E+4 
double value; value = 1.2; Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1.20 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 01.20 Console.WriteLine(value.ToString("00.00", CultureInfo.CreateSpecificCulture("da-DK"))); Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"), "", value)); // Displays 01,20 value = .086; Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 8.6% value = 86000; Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 8.6E+4 
Dim value As Double value = 1.2 Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1.20 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 01.20 Console.WriteLine(value.ToString("00.00", _ CultureInfo.CreateSpecificCulture("da-DK"))) Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"), "", value)) ' Displays 01,20 value = .086 Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 8.6% value = 86000 Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 8.6E+4 
Настраиваемый описатель ","
Символ "," служит в качестве описателя разделителя групп и описателя масштабирования чисел.

Разделитель групп: если между двумя заполнителями для цифр ("0" или "#"), задающими форматирование целой части числа, стоит одна или несколько запятых, то между всеми группами целой части числа вставляется символ-разделитель групп. Свойства NumberGroupSeparator и NumberGroupSizes текущего объекта NumberFormatInfo определяют знак, используемый в качестве разделителя групп числа и размера каждой группы числа. Например, если строка "#,#" и неизменяемый язык и региональные параметры используются для форматирования числа 1000, то результатом является "1,000".
Описатель масштабирования чисел: если сразу слева от явно или неявно заданного разделителя целой и дробной части стоит одна или несколько запятых, форматируемое число делится на 1000 для каждой указанной запятой. Например, если строка "0,," используется для форматирования числа 100 миллионов, то результатом является "100".

Разделитель групп и описатель масштабирования чисел можно использовать в строке формата одновременно. Например, если строка "#, 0,," и неизменяемый язык и региональные параметры используются для форматирования числа один миллиард, то результатом является "1,000".
В следующем примере демонстрируется использование запятой в качестве разделителя групп.
double value = 1234567890; Console::WriteLine(value.ToString("#,#", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1,234,567,890 Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1,235 
double value = 1234567890; Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1,234,567,890 Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1,235 
Dim value As Double = 1234567890 Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1,234,567,890 Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1,235 
Следующий пример иллюстрирует использование запятой как спецификатора масштабирования числа.
 double value = 1234567890; Console::WriteLine(value.ToString("#,,", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1235 Console::WriteLine(value.ToString("#. ", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1 Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 1,235 
double value = 1234567890; Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1235 Console.WriteLine(value.ToString("#. ", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1 Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 1,235 
Dim value As Double = 1234567890 Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1235 Console.WriteLine(value.ToString("#. ", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1 Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 1,235 
Настраиваемый описатель "%"
При использовании символа процента ("%") в строке формата число перед форматированием будет умножено на 100. В то место, где в строке формата стоит символ "%", в число будет вставлен локализованный символ процента. Используемый при этом символ процента определяется свойством PercentSymbol текущего объекта NumberFormatInfo .
В следующем примере определяется несколько строк настраиваемого формата, включающих настраиваемый описатель "%".
double value = .086; Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 8.6% 
double value = .086; Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 8.6% 
Dim value As Double = .086 Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 8.6% 
Настраиваемый описатель "‰"
При использовании в строке формата символа промилле ("‰" или "\u2030") перед форматированием число будет умножено на 1000. В позицию возвращаемой строки, соответствующую положению символа "‰" в строке формата, будет вставлен необходимый символ промилле. Используемый знак промилле определяется значением свойства NumberFormatInfo.PerMilleSymbol объекта, содержащего сведения о форматировании для заданного языка и региональных параметров.
В следующем примере определяется строка настраиваемого формата, включающая настраиваемый описатель "‰".
double value = .00354; String^ perMilleFmt = "#0.## " + '\u2030'; Console::WriteLine(value.ToString(perMilleFmt, CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 3.54‰ 
double value = .00354; string perMilleFmt = "#0.## " + '\u2030'; Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 3.54‰ 
Dim value As Double = .00354 Dim perMilleFmt As String = "#0.## " & ChrW(&h2030) Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 3.54 ‰ 
Настраиваемые описатели "E" и "e"
Если в строке формата присутствует подстрока "E", "E+", "E-", "e", "e+" или "e-", за которой сразу следует по меньшей мере один ноль, то число форматируется с использованием экспоненциальной нотации. Между числом и экспонентой при этом вставляется символ "E" или "e". Минимальное число цифр экспоненты в результирующей строке определяется количеством нулей, стоящих после индикатора экспоненциальной нотации. Форматы "E+" и "e+" указывают на то, что перед экспонентой всегда должен стоять положительный или отрицательный знак. Форматы "E", "e", "E-" и "e-" указывают на то, что символ знака должен ставиться только перед экспонентой с отрицательным значением.
В следующем примере несколько числовых значений форматируются с помощью спецификаторов экспоненциального представления.
double value = 86000; Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 8.6E+4 Console::WriteLine(value.ToString("0.###E+000", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 8.6E+004 Console::WriteLine(value.ToString("0.###E-000", CultureInfo::InvariantCulture)); Console::WriteLine(String::Format(CultureInfo::InvariantCulture, "", value)); // Displays 8.6E004 
double value = 86000; Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 8.6E+4 Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 8.6E+004 Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture)); Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)); // Displays 8.6E004 
Dim value As Double = 86000 Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 8.6E+4 Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 8.6E+004 Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture)) Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "", value)) ' Displays 8.6E004 
Escape-символ "\"
Символы "#", "0", ".", ",", "%" и "‰" в строке формата воспринимаются как описатели формата, а не как символы-литералы. В зависимости от положения в строке настраиваемого формата символ "E" верхнего и нижнего регистра, также как и символы "+" и "-", могут восприниматься как описатели формата.
Чтобы предотвратить интерпретацию символа в качестве описателя формата, перед ним можно поставить так называемый escape-символ — обратную косую черту. Наличие escape-символа означает, что следующий за ним символ является литералом, который следует перенести в результирующую строку без изменений.
Чтобы включить в результирующую строку обратную косую черту, перед ней нужно поставить дополнительную обратную косую черту ( \\ ).
Кроме того, в некоторых компиляторах, например компиляторах C++ и C#, одиночная обратная косая черта также может восприниматься как escape-символ. Чтобы гарантировать, что строка будет правильно воспринята при форматировании, можно поставить символ буквального строкового литерала (символ "\@") перед строкой в C# или добавить дополнительный символ обратной косой черты перед каждой обратной косой чертой в C# и C++. В следующем примере кода на языке C# демонстрируются оба подхода.
В следующем примере используется escape-символ для предотвращения интерпретации символов форматирования "#", "0" и "\" как escape-символов или описателей формата. В примерах на языке C# используется дополнительная обратная косая черта, позволяющая гарантировать, что обратная косая черта будет воспринята как символ-литерал.
int value = 123; Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#")); Console::WriteLine(String::Format("", value)); // Displays ### 123 dollars and 00 cents ### Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#")); Console::WriteLine(String::Format("", value)); // Displays ### 123 dollars and 00 cents ### Console::WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\")); Console::WriteLine(String::Format("", value)); // Displays \\\ 123 dollars and 00 cents \\\ Console::WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\")); Console::WriteLine(String::Format("", value)); // Displays \\\ 123 dollars and 00 cents \\\ 
int value = 123; Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#")); Console.WriteLine(String.Format("", value)); // Displays ### 123 dollars and 00 cents ### Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#")); Console.WriteLine(String.Format(@"", value)); // Displays ### 123 dollars and 00 cents ### Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\")); Console.WriteLine(String.Format("", value)); // Displays \\\ 123 dollars and 00 cents \\\ Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\")); Console.WriteLine(String.Format(@"", value)); // Displays \\\ 123 dollars and 00 cents \\\ 
Dim value As Integer = 123 Console.WriteLine(value.ToString("\#\#\# ##0 dollars and \0\0 cents \#\#\#")) Console.WriteLine(String.Format("", value)) ' Displays ### 123 dollars and 00 cents ### Console.WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\")) Console.WriteLine(String.Format("", value)) ' Displays \\\ 123 dollars and 00 cents \\\ 
Разделитель секций ";"
Точка с запятой (";") — это описатель условного формата, применяющий разное форматирование к числу в зависимости от того, является оно положительным числом, отрицательным числом или нулем. Для этого следует создать строку формата, состоящую из трех секций, разделенных точкой с запятой. Эти секции описаны в следующей таблице.


Число секций
Description



Один раздел
Строка форматирования применяется ко всем значениям.


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


Вторая секция может быть пустой (между двумя точками с запятой пусто), в этом случае первая секция будет использоваться для форматирования нулевых значений.
При форматировании конечного значения разделители секций игнорируют любое существовавшее ранее форматирование, связанное с числом. Например, при использовании разделителей секций отрицательные значения всегда отображаются без знака "минус". Чтобы конечное отформатированное значение содержало знак "минус", его следует явным образом включить в настраиваемый спецификатор формата.
В следующем примере описатель формата ";" используется для форматирования положительных чисел, отрицательных чисел и нулей различными способами.
double posValue = 1234; double negValue = -1234; double zeroValue = 0; String^ fmt2 = "##;(##)"; String^ fmt3 = "##;(##);**Zero**"; Console::WriteLine(posValue.ToString(fmt2)); Console::WriteLine(String::Format("", posValue)); // Displays 1234 Console::WriteLine(negValue.ToString(fmt2)); Console::WriteLine(String::Format("", negValue)); // Displays (1234) Console::WriteLine(zeroValue.ToString(fmt3)); Console::WriteLine(String::Format("", zeroValue)); // Displays **Zero** 
double posValue = 1234; double negValue = -1234; double zeroValue = 0; string fmt2 = "##;(##)"; string fmt3 = "##;(##);**Zero**"; Console.WriteLine(posValue.ToString(fmt2)); Console.WriteLine(String.Format("", posValue)); // Displays 1234 Console.WriteLine(negValue.ToString(fmt2)); Console.WriteLine(String.Format("", negValue)); // Displays (1234) Console.WriteLine(zeroValue.ToString(fmt3)); Console.WriteLine(String.Format("", zeroValue)); // Displays **Zero** 
Dim posValue As Double = 1234 Dim negValue As Double = -1234 Dim zeroValue As Double = 0 Dim fmt2 As String = "##;(##)" Dim fmt3 As String = "##;(##);**Zero**" Console.WriteLine(posValue.ToString(fmt2)) Console.WriteLine(String.Format("", posValue)) ' Displays 1234 Console.WriteLine(negValue.ToString(fmt2)) Console.WriteLine(String.Format("", negValue)) ' Displays (1234) Console.WriteLine(zeroValue.ToString(fmt3)) Console.WriteLine(String.Format("", zeroValue)) ' Displays **Zero** 
Символьные литералы
Описатели формата, которые появляются в строке настраиваемых числовых форматов, всегда интерпретируются как символы формата и никогда не обрабатываются как литеральные символы. К ним относятся следующие символы:
Все остальные символы всегда интерпретируется как символьные литералы. В операции форматирования они включаются в результирующую строку без изменений. В операции анализа они должны точно соответствовать символам во входной строке. При сравнении учитывается регистр.
В следующем примере демонстрируется распространенный пример применения литеральных символов единиц измерения (в данном случае тысяч):
double n = 123.8; Console.WriteLine($""); // The example displays the following output: // 123.8K 
Dim n As Double = 123.8 Console.WriteLine($"") ' The example displays the following output: ' 123.8K 
Указать необходимость интерпретации символов как литеральных, а не как символов формата, для их последующего включения в результирующую строку или успешного анализа во входной строке можно двумя способами:

Путем экранирования символа формата. Дополнительные сведения см. в разделе "\" escape-символ.
Путем заключения всей литеральной строки в апострофы.

В следующем примере применяются оба подхода, что позволяет включить зарезервированные символы в настраиваемую строку числового формата.
double n = 9.3; Console.WriteLine($@""); Console.WriteLine($@""); Console.WriteLine($@""); Console.WriteLine(); Console.WriteLine($""); Console.WriteLine($@""); // The example displays the following output: // 9.3% // '9' // \9\ // // 9.3% // \9\ 
Dim n As Double = 9.3 Console.WriteLine($"") Console.WriteLine($"") Console.WriteLine($"") Console.WriteLine() Console.WriteLine($"") Console.WriteLine($"") ' The example displays the following output: ' 9.3% ' '9' ' \9\ ' ' 9.3% ' \9\ 
Примечания.
Бесконечности действительных чисел с плавающей запятой и NaN
Независимо от строки форматирования, если значение Halfтипа с DoubleSingleплавающей запятой является положительным бесконечностью, отрицательным бесконечностью или не числом (NaN), форматированная строка является значением соответствующего PositiveInfinitySymbolили NegativeInfinitySymbolNaNSymbol свойства, заданного текущим применимым NumberFormatInfo объектом.
Параметры панели управления
Параметры элемента панели управления Язык и региональные стандарты влияют на выходную строку, получаемую в результате операции форматирования. Эти параметры используются для инициализации объекта, связанного NumberFormatInfo с текущим языком и региональными параметрами, а текущий язык и региональные параметры предоставляют значения, используемые для управления форматированием. Результирующие строки будут различаться на компьютерах с разными параметрами.
Кроме того, если конструктор CultureInfo(String) используется для создания нового экземпляра объекта CultureInfo , представляющего язык и региональные параметры, аналогичные текущему языку и региональным параметрам системы, то все настройки, заданные в разделе Язык и региональные стандарты панели управления, будут применяться к новому объекту CultureInfo . Можно воспользоваться конструктором CultureInfo(String, Boolean) для создания объекта CultureInfo , который не отражает настройки системы.
Строки формата с фиксированной запятой и округлением
Строки формата с фиксированной запятой (строки формата, не содержащие символов экспоненциальной нотации) округляют значение с точностью, определяемой количеством символов-заполнителей, стоящих справа от разделителя целой и дробной частей. Если в строке формата нет десятичной точки, то число округляется до ближайшего целого значения. Если слева от десятичной точки больше цифр, чем знаков-заместителей цифр, то лишние знаки копируются в выходную строку перед первым знаком-заместителем цифры.
Пример
В следующем примере показаны две строки настраиваемого числового формата. В обоих случаях заполнитель для цифр ( # ) отображает числовые данные, а все остальные символы копируются в результирующую строку.
double number1 = 1234567890; String^ value1 = number1.ToString("(###) ###-####"); Console::WriteLine(value1); int number2 = 42; String^ value2 = number2.ToString("My Number = #"); Console::WriteLine(value2); // The example displays the following output: // (123) 456-7890 // My Number = 42 
double number1 = 1234567890; string value1 = number1.ToString("(###) ###-####"); Console.WriteLine(value1); int number2 = 42; string value2 = number2.ToString("My Number = #"); Console.WriteLine(value2); // The example displays the following output: // (123) 456-7890 // My Number = 42 
Dim number1 As Double = 1234567890 Dim value1 As String = number1.ToString("(###) ###-####") Console.WriteLine(value1) Dim number2 As Integer = 42 Dim value2 As String = number2.ToString("My Number = #") Console.WriteLine(value2) ' The example displays the following output: ' (123) 456-7890 ' My Number = 42 
См. также

System.Globalization.NumberFormatInfo
Типы форматирования
Стандартные строки в числовом формате
Практическое руководство. Добавление к числу начальных нулей
Пример: служебная программа форматирования .NET Core WinForms (C#)
Пример: служебная программа форматирования .NET Core WinForms (Visual Basic)

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

1. Значащие цифры данного числа — это все цифры от первой слева, не равной нулю, до последней записанной цифры справа. При этом нули, следующие из множителя 10 n , не учитываются.
а) число 12,0 имеет три значащие цифры;
б) число 30 имеет две значащие цифры;
в) число 120×10 3 имеет три значащие цифры;
г) число 0,514×10 имеет три значащие цифры;
д) число 0,0056 имеет две значащие цифры.
2. Когда необходимо указать, что число является точным, после числа должно быть указано слово "точно" или же последняя значащая цифра печатается жирным шрифтом.
Пример. В печатном тексте:
1 кВт×ч = 3600000 Дж (точно), или = 36000000 Дж
3. Следует различать записи приближенных чисел по количеству значащих цифр.
1) Следует различать числа 2,4 и 2,40. Запись 2,4 означает, что верны только цифры целых и десятых; истинное значение числа может быть например 2,43 и 2,38. Запись 2,40 означает, что верны и сотые доли числа; истинное число может быть 2,403 и 2,398, но не 2,421 и не 2,382.
2) Запись 382 означает, что все цифры верны; если за последнюю цифру ручаться нельзя, то число должно быть записано 3,8×10 2 .
3) Если в числе 4720 верны лишь две первые цифры, оно должно быть записано 47×10 или 4,7×10.
4. Число, для которого указывается допускаемое отклонение, должно иметь последнюю значащую цифру того же разряда, как и последняя значащая цифра отклонения.
а) Правильно: 17,0 ± 0,2
Неправильно: 17 ± 0,2 или 17,00 ± 0,2
б) Правильно: 12,13 ± 0,17
Неправильно: 12,13 ± 0,2 или 12,1 ± 0,17
в) Правильно: 46,40 ± 0,15
Неправильно: 46,4 ± 0,15 или 46,402 ± 0,15
5. Числовые значения величины и ее погрешности (отклонения) целесообразно записывать с указанием одной и той же единицы физических величин.
Пример. 80,555 ± 0,002 кг
6. Интервалы между числовыми значениями величин следует записывать:

От 60 до 100 или от 60 до 100;
Свыше 100 до 120 или свыше 100 до 120;
Свыше 120 до 150 или свыше 120 до 150.

7. Числовые значения величин должны указываться в стандартах с одинаковым числом разрядов, которое необходимо для обеспечения требуемых эксплуатационных свойств и качества продукции. Запись числовых значений величин до первого, второго, третьего и т.д. десятичного знака для различных типоразмеров, видов марок продукции одного названия, как правило, должна быть одинаковой. Например, если градация толщины стальной горячекатаной ленты 0,25 мм, то весь ряд толщин ленты должен быть указан с точностью до второго десятичного знака.
Правильно: 1,50; 1,85; 2,00
Неправильно: 1,5; 1,75; 2.
В зависимости от технической характеристики и назначения продукции количество десятичных знаков числовых значений величин одного и того же параметра, размера, показателя или нормы может иметь несколько ступеней (групп) и должно быть одинаковым только внутри этой ступени (группы).
Ссылка на источник
1. СТ СЭВ 543-77 "Числа. Правила записи и округления"; 
2. Блог "Лаборатория_" на Яндекс.Дзен, статья "Правила записи чисел".
01.09.2021 11:22:16 | Автор статьи: Усачёва Вера


Похожие публикации:

Как в ворде включить поля страницы
Как изменить размер сноски в ворде
Как увеличить таблицу в html
Не приходят письма на майл ру что делать