Переменная double: Вещественные типы (double, float) — Типы данных — Основы языка

Тип данных Double — Visual Basic

Twitter LinkedIn Facebook Адрес электронной почты

• Статья
• 04/11/2023

Содержит подписанные 64-разрядные (8-байтовые) числа двойной точности с плавающей запятой со знаком, которые варьируются от -1,79769313486231570E+308 до -4,94065645841246544E-324 для отрицательных значений и от 4,94065645841246544E-324 до 1,79769313486231570E+308 для положительных значений.

Числа двойной точности хранят аппроксимацию реального числа.

Тип Double данных предоставляет наибольшее и наименьшее возможные величины для числа.

Значение по умолчанию для типа Double — 0.

Советы по программированию

• Точность. При работе с числами с плавающей запятой помните, что они не всегда имеют точное представление в памяти. Это может привести к непредвиденным результатам определенных операций, таких как сравнение значений Mod и оператор . Дополнительные сведения см. в разделе Устранение неполадок с типами данных.

• Конечные нули. Типы данных с плавающей запятой не имеют внутреннего представления конечных нулевых символов. Например, они не различают версии 4.2000 и 4.2. Следовательно, конечные нулевые символы не отображаются при отображении или печати значений с плавающей запятой.

• Символы типов. При добавлении к литералу символа типа литерала R производится принудительное приведение литерала к типу данных Double. Например, если за целочисленным значением Rследует , значение меняется на Double.

  ' Visual Basic expands the 4 in the statement Dim dub As Double = 4R to 4.0:
  Dim dub As Double = 4.0R
  

  При добавлении символа идентификатора типа # к любому идентификатору производится принудительное приведение этого идентификатора к типу Double. В следующем примере переменная num типируется как Double:

  Dim num# = 3
  

• Тип Framework. В .NET Framework данный тип соответствует структуре System.Double.

См. также раздел

• System.Double
• Типы данных
• Тип данных Decimal
• Тип данных Single
• Type Conversion Functions
• Сводка по преобразованию
• Эффективное использование типов данных
• Устранение неполадок, связанных с типами данных
• Символы типов

Основные типы — Kotlin

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

Числа

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

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

Тип	Размер (биты)	Минимальное значение	Максимальное значение
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 — 1)
Long	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 — 1)

Все переменные, инициализированные целыми значениями, не превышающими максимальное значение

Int, имеют предполагаемый тип Int. Если начальное значение превышает это значение, то тип Long. Чтобы явно указать тип Long, добавьте после значения L.

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
val oneByte: Byte = 1

Типы с плавающей точкой

Для действительных чисел в Kotlin есть типы с плавающей точкой Float и Double. Согласно стандарту IEEE 754, типы с плавающей точкой различаются своим десятичным разрядом, то есть количеством десятичных цифр, которые они могут хранить. С точки зрения IEEE 754 Float является одинарно точным, а Double обеспечивает двойную точность.

Тип	Размер (биты)	Значимые биты	Биты экспоненты	Разряды
Float	32	24	8	6-7
Double	64	53	11	15-16

Вы можете инициализировать переменные Double и Float числами, имеющими дробную часть. Она должна быть отделена от целой части точкой (.). Для переменных, инициализированных дробными числами, компилятор автоматически определяет тип Double.

val pi = 3.14 // Double
// val one: Double = 1 // Ошибка: несоответствие типов
val oneDouble = 1.0 // Double

Чтобы явно указать тип Float, добавьте после значения f или F. Если такое значение содержит более 6-7 разрядов, оно будет округлено.

val e = 2.7182818284 // Double
val eFloat = 2.7182818284f // Float, фактическое значение 2.7182817

Обратите внимание, что в отличие от некоторых других языков, в Kotlin нет неявных преобразований для чисел. Например, функция с Double параметром может вызываться только для Double, но не для Float, Int или других числовых значений.

fun main() {
    fun printDouble(d: Double) { print(d) }
    val i = 1    
    val d = 1.0
    val f = 1.0f 
    printDouble(d)
//  printDouble(i) // Ошибка: несоответствие типов
//  printDouble(f) // Ошибка: несоответствие типов
}

Чтобы преобразовать числовые значения в различные типы, используйте Явные преобразования.

Символьные постоянные

В языке Kotlin присутствуют следующие виды символьных постоянных (констант) для целых значений:

• Десятичные числа: 123
  • Тип Long
    обозначается заглавной L: 123L
• Шестнадцатеричные числа: 0x0F
• Двоичные числа: 0b00001011

ВНИМАНИЕ: Восьмеричные литералы не поддерживаются.

Также Kotlin поддерживает числа с плавающей запятой:

• Тип Double по умолчанию: 123.5, 123.5e10
• Тип Float обозначается с помощью f или F: 123.5f

Вы можете использовать нижние подчеркивания, чтобы сделать числовые константы более читаемыми:

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

Представление чисел в JVM

Обычно платформа JVM хранит числа в виде примитивных типов: int, double и так далее.

Если же вам необходима ссылка, которая может принимать значение null (например, Int?), то используйте обёртки. В этих случаях числа помещаются в Java классы как Integer, Double и так далее.

Обратите внимание, что использование обёрток для одного и того же числа не гарантирует равенства ссылок на них.

val a: Int = 100
val boxedA: Int? = a
val anotherBoxedA: Int? = a
val b: Int = 10000
val boxedB: Int? = b
val anotherBoxedB: Int? = b
println(boxedA === anotherBoxedA) // true
println(boxedB === anotherBoxedB) // false

Все nullable-ссылки на a на самом деле являются одним и тем же объектом из-за оптимизации памяти, которую JVM применяет к Integer между «-128» и «127». Но b больше этих значений, поэтому ссылки на b являются разными объектами.

Однако, равенство по значению сохраняется.

val b: Int = 10000
println(b == b) // Prints 'true'
val boxedB: Int? = b
val anotherBoxedB: Int? = b
println(boxedB == anotherBoxedB) // Prints 'true'

Явные преобразования

Из-за разницы в представлениях меньшие типы не являются подтипами бОльших типов. В противном случае возникли бы сложности.

// Возможный код, который на самом деле не скомпилируется:
val a: Int? = 1 // "Обёрнутый" Int (java.lang.Integer)
val b: Long? = a // неявное преобразование возвращает "обёрнутый" Long (java.lang.Long)
print(b == a) // Нежданчик! Данное выражение выведет "false" т. к. метод equals() типа Long предполагает, что вторая часть выражения также имеет тип Long

Таким образом, будет утрачена не только тождественность (равенство по ссылке), но и равенство по значению.

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

Byte переменной типа Int без явного преобразования.

val b: Byte = 1 // всё хорошо, литералы проверяются статически
// val i: Int = b // ОШИБКА
val i1: Int = b.toInt()

Каждый численный тип поддерживает следующие преобразования:

• toByte(): Byte
• toShort(): Short
• toInt(): Int
• toLong(): Long
• toFloat(): Float
• toDouble(): Double
• toChar(): Char

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

val l = 1L + 3 // Long + Int => Long

Операции

Котлин поддерживает стандартный набор арифметических операций над числами: +, -, *, /, %. Они объявляются членами соответствующих классов.

println(1 + 2)
println(2_500_000_000L - 1L)
println(3.14 * 2.71)
println(10.0 / 3)

Вы также можете переопределить эти операторы для пользовательских классов. См. Перегрузка операторов для деталей.

Деление целых чисел

Деление целых чисел всегда возвращает целое число. Любая дробная часть отбрасывается.

val x = 5 / 2
// println(x == 2.5) // ОШИБКА: Оператор '==' не может быть применен к 'Int' и 'Double'
println(x == 2) // true

Это справедливо для деления любых двух целочисленных типов.

val x = 5L / 2
println(x == 2L) // true

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

val x = 5 / 2.toDouble()
println(x == 2. 5) // true

Побитовые операции

Kotlin поддерживает обычный набор побитовых операций над целыми числами. Они работают на двоичном уровне непосредственно с битовыми представлениями чисел. Побитовые операции представлены функциями, которые могут быть вызваны в инфиксной форме. Они могут быть применены только к Int и Long.

val x = (1 shl 2) and 0x000FF000

Ниже приведён полный список битовых операций:

• shl(bits) – сдвиг влево с учётом знака (<< в Java)
• shr(bits) – сдвиг вправо с учётом знака (>> в Java)
• ushr(bits) – сдвиг вправо без учёта знака (>>> в Java)
• and(bits) – побитовое И
• or(bits) – побитовое ИЛИ
• xor(bits) – побитовое исключающее ИЛИ
• inv() – побитовое отрицание

Сравнение чисел с плавающей точкой

В этом разделе обсуждаются следующие операции над числами с плавающей запятой:

• Проверки на равенство: a == b и a != b
• Операторы сравнения: a < b, a > b, a <= b, a >= b
• Создание диапазона и проверка диапазона: a. .b, x in a..b, x !in a..b

Когда статически известно, что операнды a и b являются Float или Double или их аналогами с nullable-значением (тип объявлен или является результатом умного приведения), операции с числами и диапазоном, который они образуют, соответствуют стандарту IEEE 754 для арифметики с плавающей точкой.

Однако для поддержки общих вариантов использования и обеспечения полного упорядочивания, когда операнды статически не объявлены как числа с плавающей запятой (например, Any, Comparable<...>, параметр типа), операции используют реализации equals и compareTo для Float и Double, которые не согласуются со стандартом, так что:

• NaN считается равным самому себе
• NaN считается больше, чем любой другой элемент, включая «POSITIVE_INFINITY»
• -0. 0 считается меньше, чем 0.0

Целые беззнаковые числа

В дополнение к целочисленным типам, в Kotlin есть следующие типы целых беззнаковых чисел:

• UByte: беззнаковое 8-битное целое число, в диапазоне от 0 до 255
• UShort: беззнаковое 16-битное целое число, в диапазоне от 0 до 65535
• UInt: беззнаковое 32-битное целое число, в диапазоне от 0 до 2³² — 1
• ULong: беззнаковое 64-битное целое число, в диапазоне от 0 до 2⁶⁴ — 1

Беззнаковые типы поддерживают большинство операций своих знаковых аналогов.

Изменение типа с беззнакового типа на его знаковый аналог (и наоборот) является двоично несовместимым изменением.

Беззнаковые массивы и диапазоны

Беззнаковые массивы и операции над ними находятся в стадии бета-тестирования. Они могут быть несовместимо изменены в любое время.

Как и в случае с примитивами, каждому типу без знака соответствует тип массивов знаковых типов:

• UByteArray: массив беззнаковых byte
• UShortArray: массив беззнаковых short
• UIntArray: массив беззнаковых int
• ULongArray: массив беззнаковых long

Как и целочисленные массивы со знаком, такие массивы предоставляют API, аналогичный классу Array, без дополнительных затрат на оборачивание.

При использовании массивов без знака вы получите предупреждение, что эта функция еще не стабильна. Чтобы удалить предупреждение используйте аннотацию @ExperimentalUnsignedTypes. Вам решать, должны ли ваши пользователи явно соглашаться на использование вашего API, но имейте в виду, что беззнаковый массив не является стабильной функцией, поэтому API, который он использует, может быть нарушен изменениями в языке. Узнайте больше о требованиях регистрации.

Диапазоны и прогрессии поддерживаются для UInt и ULong классами UIntRange,UIntProgression, ULongRange и ULongProgression. Вместе с целочисленными беззнаковыми типами эти классы стабильны.

Литералы

Чтобы целые беззнаковые числа было легче использовать, в Kotlin можно помечать целочисленный литерал суффиксом, указывающим на определенный беззнаковый тип (аналогично Float или Long):

• u и U помечают беззнаковые литералы. Точный тип определяется на основе ожидаемого типа. Если ожидаемый тип не указан, компилятор будет использовать UInt или ULong в зависимости от размера литерала.

val b: UByte = 1u  // UByte, есть ожидаемый тип
val s: UShort = 1u // UShort, есть ожидаемый тип
val l: ULong = 1u  // ULong, есть ожидаемый тип
val a1 = 42u // UInt: ожидаемого типа нет, константе подходит тип UInt
val a2 = 0xFFFF_FFFF_FFFFu // ULong: ожидаемого типа нет, тип UInt не подходит константе

• uL and UL явно помечают литерал как unsigned long.

val a = 1UL // ULong, даже несмотря на то, что ожидаемого типа нет и константа вписывается в UInt

Дальнейшее обсуждение

См. предложения для беззнаковых типов для технических деталей и дальнейшего обсуждения.

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

Тип Boolean представляет логический тип данных и принимает два значения: true и false.

При необходимости использования nullable-ссылок логические переменные оборачиваются Boolean?.

Встроенные действия над логическими переменными включают:

• || – ленивое логическое ИЛИ
• && – ленивое логическое И
• ! – отрицание

val myTrue: Boolean = true
val myFalse: Boolean = false
val boolNull: Boolean? = null
println(myTrue || myFalse)
println(myTrue && myFalse)
println(!myTrue)

В JVM: nullable-ссылки на логические объекты заключены в рамки аналогично числам.

Символы

Символы в Kotlin представлены типом Char. Символьные литералы заключаются в одинарные кавычки: '1'.

Специальные символы начинаются с обратного слеша \. Поддерживаются следующие escape-последовательности: \t, \b, \n, \r, \', \", \\ и \$.

Для кодирования любого другого символа используйте синтаксис escape-последовательности Юникода: '\uFF00'.

val aChar: Char = 'a'
println(aChar)
println('\n') // выводит дополнительный символ новой строки
println('\uFF00')

Если значение символьной переменной – цифра, её можно явно преобразовать в Int с помощью функции digitToInt().

В JVM: Подобно числам, символы оборачиваются при необходимости использования nullable-ссылки. При использовании обёрток тождественность (равенство по ссылке) не сохраняется.

Строки

Строки в Kotlin представлены типом String. Как правило, строка представляет собой последовательность символов в двойных кавычках (").

val str = "abcd 123"

Строки состоят из символов, которые могут быть получены по порядковому номеру: s[i]. Проход по строке выполняется циклом for.

for (c in str) {
    println(c)
}

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

val str = "abcd"
println(str.uppercase()) // Создается и выводится новый объект String
println(str) // исходная строка остается прежней

Для объединения строк используется оператор +. Это работает и для объединения строк с другими типами, если первый элемент в выражении является строкой.

val s = "abc" + 1
println(s + "def") // abc1def

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

Строковые литералы

В Kotlin представлены два типа строковых литералов:

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

Вот пример экранированной строки:

val s = "Hello, world!\n"

Экранирование выполняется общепринятым способом, а именно с помощью обратного слеша (\). Список поддерживаемых escape-последовательностей см. в разделе Символы выше.

Обычная строка выделена тройной кавычкой ("""), не содержит экранированных символов, но может содержать символы новой строки и любые другие символы:

val text = """
  for (c in "foo")
    print(c)
"""

Чтобы удалить пробелы в начале обычных строк, используйте функцию trimMargin().

val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()

По умолчанию | используется в качестве префикса поля, но вы можете выбрать другой символ и передать его в качестве параметра, например, trimMargin(">").

Строковые шаблоны

Строки могут содержать шаблонные выражения, т.е. участки кода, которые выполняются, а полученный результат встраивается в строку. Шаблон начинается со знака доллара ($) и состоит либо из простого имени (например, переменной),

val i = 10
println("i = $i") // выведет "i = 10"

либо из произвольного выражения в фигурных скобках.

val s = "abc"
println("$s.length is ${s.length}") // выведет "abc.length is 3"

Шаблоны поддерживаются как в обычных, так и в экранированных строках. При необходимости вставить символ $ в обычную строку (такие строки не поддерживают экранирование обратным слешом) перед любым символом, который разрешен в качестве начала идентификатора, используйте следующий синтаксис:

val price = """
${'$'}_9.99
"""

Массивы

Массивы в Kotlin представлены классом Array, обладающим функциями get и set (которые обозначаются [] согласно соглашению о перегрузке операторов), и свойством size, а также несколькими полезными встроенными функциями.

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit
    operator fun iterator(): Iterator<T>
    // ...
}

Для создания массива используйте функцию arrayOf(), которой в качестве аргумента передаются элементы массива, т. е. выполнение arrayOf(1, 2, 3) создаёт массив [1, 2, 3]. С другой стороны функция arrayOfNulls() может быть использована для создания массива заданного размера, заполненного значениями null.

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

// создаёт массив типа Array<String> со значениями ["0", "1", "4", "9", "16"]
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }

Как отмечено выше, оператор [] используется вместо вызовов встроенных функций get() и set().

Обратите внимание: в отличие от Java массивы в Kotlin являются инвариантными. Это значит, что Kotlin запрещает нам присваивать массив Array<String> переменной типа Array<Any>, предотвращая таким образом возможный отказ во время исполнения (хотя вы можете использовать Array<out Any>, см. Проекции типов).

Массивы примитивных типов

Также в Kotlin есть особые классы для представления массивов примитивных типов без дополнительных затрат на оборачивание: ByteArray, ShortArray, IntArray и т.д. Данные классы не наследуют класс Array, хотя и обладают тем же набором методов и свойств. У каждого из них есть соответствующая фабричная функция:

val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]

// int массив, размером 5 со значениями [0, 0, 0, 0, 0]
val arr = IntArray(5)
// инициализация элементов массива константой
// int массив, размером 5 со значениями [42, 42, 42, 42, 42]
val arr = IntArray(5) { 42 }
// инициализация элементов массива лямбда-выражением
// int массив, размером 5 со значениями [0, 1, 2, 3, 4] (элементы инициализированы своим индексом)
var arr = IntArray(5) { it * 1 } 

Что такое Double в C?

В программировании мы часто сталкиваемся с десятичными значениями. Но часто мы сталкиваемся с десятичными значениями, которые велики с точки зрения точности (например, 5,11647e-75,11647e-75,11647e-7). В языке C такие числа не могут храниться в предопределенном типе данных для десятичных дробей (например, с плавающей запятой). Таким образом, вводится новый тип данных для хранения таких больших значений десятичных знаков.

Двойник в C — это тип данных, который используется для хранения высокоточных чисел с плавающей запятой 9.0004 данные или числа (до 15–17 цифр). Он используется для хранения больших значений десятичных чисел.

Сохраняемые значения в два раза превышают размер данных, которые могут быть сохранены в типе данных float. Таким образом, он называется двойным типом данных.

Любая переменная, объявленная с использованием типа данных double в C, имеет размер 8 байтов (или 64 бита).

Примечание:

• В типе данных double 1 бит используется для представления знака, 11 бит — для экспоненты, а оставшиеся 52 бита — для мантиссы.

• Двойное число в c находится в диапазоне от 1.7E-308 до 1.7E+308 . Double может использоваться для представления данных действительных чисел, десятичных дробей, отрицательных значений и т. д.

Синтаксис объявления

Переменные типа double в c объявляются с использованием ключевого слова double, за которым следует имя переменной.

Инициализация двойной переменной

Когда мы объявляем переменную, она в основном содержит мусорное значение. Таким образом, чтобы наша переменная имела определенное значение, нам нужно инициализировать переменную double этим определенным значением.

Есть два способа инициализировать двойник в C:

1. Путем присвоения объявленной двойной переменной значения с помощью оператора присваивания:

Примечание: Может хранить до 15-17 цифр.

2. Присвоив переменной double значение во время объявления с помощью оператора присваивания:

Пример Double в C

В этом разделе мы обсудим несколько примеров double в C.

В приведенном выше примере объявляется temp1 и ему присваивается значение 98,4. temp2 объявлен, но ему не присвоено какое-либо значение, поэтому он будет содержать значение мусора, а temp3 объявлен, поэтому имеет значение мусора, но позже ему будет присвоено значение 97,88.

Как напечатать двойное значение в C?

Теперь, когда мы узнали, как объявить двойное число в языке C и инициализировать двойное значение в языке C, возникает вопрос, как отобразить двойное значение в языке C?

Двойник в c может быть напечатан как с использованием %f, так и %lf. И спецификатор формата %f, и спецификатор формата %lf представляют float и double. printf() в c обрабатывает как float, так и double одинаково.

Вывод:

Примечание:
В случае общего спецификатора (например, int) значение будет приведено к типу, и будет напечатано целочисленное значение. Это связано с тем, что эти общие спецификаторы уже предполагают, что значение имеет целочисленный тип.

Представление Double в C

Точность double в c зависит от его реализации в коде. В общем, современные компиляторы используют стандарт IEEE-754 .

Стандарт IEEE для вычислений с плавающей запятой (IEEE 754) — это технический стандарт для вычислений с плавающей запятой, который был установлен в 1985 году Институтом инженеров по электротехнике и электронике (IEEE). Стандарт решил многие проблемы, обнаруженные в различных реализациях с плавающей запятой, которые затрудняли их надежное использование и снижали их переносимость.

В таких компиляторах числа представляются с использованием 64-битного кода следующим образом:

• Первый бит обозначает знак. Положительное значение представлено 0, а отрицательное — 1.
• 52 бита мантиссы (мантисса).
• 11 бит экспоненты.

Может хранить значение до 15-16 цифр.

Ниже приводится графическое описание представления double в C:

Некоторые программы типа Double Date в C

В этом разделе мы увидим несколько программ, в которых используется double в C.

Программа для получения размера типов данных с использованием функции sizeof()

Функцию sizeof() можно использовать для определения размера различных типов данных в c. Эта функция примет тип данных в качестве параметра и вернет размер в байтах.

Код:

Вывод:

Пояснение к примеру:

В приведенном выше примере мы передаем типы данных int, char, float и double в размер функции. printf используется для отображения их вывода.

Программа для преобразования футов в метры с использованием типа данных Double

Мы можем преобразовать единицы измерения, используя double в C. Это можно сделать, взяв входные данные в футах и ​​разделив значение на 3,28. Поскольку результатом может быть большое десятичное значение, он будет сохранен в типе данных double.

Код:

Вывод:

Объяснение примера:

В приведенном выше коде мы определили функцию ‘functionToMeter’ , который принимает двойное значение в качестве параметра. FootInput / 3.28 преобразует значение футов в метры и возвращает значение.

Программа для преобразования целочисленных данных в тип данных Double

В этом разделе мы узнаем, как преобразовать тип данных в c.

Код:

Вывод:

В приведенном выше примере у нас есть числитель и знаменатель целочисленного типа. Мы создали оставшуюся переменную типа double. Числитель/знаменательчислитель/знаменательчислитель/знаменатель выведет целое значение как целое число / целое число вернет целое число .

Таким образом, мы преобразуем тип данных числителя в двойной с (двойным) числителем. Теперь числитель/знаменатель, числитель/знаменатель, числитель/знаменатель вернет двойное значение, которое можно сохранить в остатке.

Программа для преобразования температуры по Цельсию в градусы Фаренгейта

Вывод:

Программа для вывода суммы двух двойных чисел с помощью функции

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

Код:

Вывод:

Объяснение примера:

В приведенном выше примере мы передаем функции sum() два двойных значения num1 и num2, имеющие значения 9,459 и 3,45. Функция суммы вернет число1 + число2.

Типы данных Float и Double в C

Ниже приведены несколько различий между float и double в C:

Плавающий	Двойной
Тип данных float содержит 32-битное значение с плавающей запятой.	Тип данных double содержит 64-битное значение с плавающей запятой.
Тип float равен 4 байтам.	Тип double равен 8 байтам.
Тип данных с плавающей запятой относительно быстрее с точки зрения скорости работы, потому что, когда вам не нужна двойная точность, и вы ограничены пропускной способностью памяти , а ваше оборудование не несет штрафа за поплавки. Они экономят пропускную способность памяти, поскольку занимают половину места на число.	Тип данных double медленный по сравнению с float.
Тип данных float может содержать примерно 7 цифр	Тип данных double может содержать примерно 15-17 цифр
Диапазон значений float находится между 1,5∗10−451,5 * 10-451,5 *10−45 до 3,4∗10383,4 * 10383,4∗1038	Диапазон значений double находится между 5,0∗10-3455,0 * 10-3455,0∗10-345 до 1,7∗103081,7 * 103081,7∗10308 9 0214

Узнать больше

Посетите эту ссылку, чтобы узнать больше о double в c.

Заключение

• Двойник в C используется для хранения высокоточных данных или чисел с плавающей запятой.
• Двойное число в C находится в диапазоне от 5,0∗10−3455,0 * 10-3455,0∗10−345 до 1,7∗103081,7 * 103081,7∗10308.
• Двойник в C может содержать до 15-17 цифр.
• Точная точность double зависит от реализации кода.

Тип данных VBA Double (переменная Dim)

Вернуться к примерам кода VBA

В этой статье

• Тип двойной переменной
• Тип данных Single
• Типы данных Int или Long
• Объявление двойной переменной на уровне модуля или на глобальном уровне
  • Уровень модуля
  • Глобальный уровень
• Двойной формат сохраняется как строка

Тип переменной Double

Тип данных VBA Double используется для хранения чисел, требующих десятичных разрядов. Он может хранить от -1,79769313486231E308 до -4,94065645841247E-324 для отрицательных значений и от 4,94065645841247E-324 до 1,79769313486232E308 для положительных значений.

Чтобы объявить переменную Double, вы используете оператор Dim (сокращение от Dimension):

 Dim dblA as Double
 

Затем, чтобы присвоить значение переменной, просто используйте знак равенства:

 dlbA = 3658,25 

Помещение этого в процедуру выглядит следующим образом:

 Sub dblExample()
'объявить двойную переменную
   Dim dblA как Double
'заполнить двойную переменную
   дБА = 3658,25
'показать окно сообщения
   MsgBox дблА
Конец суб 

Если вы запустите приведенный выше код, появится следующее окно сообщения.

Тип данных Single

Тип данных Single представляет собой укороченную версию типа данных Double. Из-за этого он может влиять на округление при использовании в процедуре, так как тип данных single будет округлен до 4 знаков после запятой, а тип данных Double будет округлен до 12 знаков после запятой. Если вам не нужен тип данных Double, вы можете использовать тип данных Single

Типы данных Int или Long

Если вам не нужен десятичный разряд, вы можете использовать либо тип данных Int, либо тип данных Long.

 Dim intA as Integer 

 Dim lngB as Long 

Объявление переменной Double на уровне модуля или на глобальном уровне

В предыдущих примерах мы объявили переменную Double внутри процедуры. Переменные, объявленные в процедуре, могут использоваться только внутри этой процедуры.

Вместо этого вы можете объявить переменные типа Double на уровне модуля или на глобальном уровне.

Уровень модуля

Переменные уровня модуля объявляются в верхней части модулей кода с помощью оператора Dim .

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

Глобальный уровень

Переменные глобального уровня также объявляются в верхней части модулей кода. Однако вместо использования оператора Dim используйте оператор Public , чтобы указать, что переменная Double доступна для использования во всем проекте VBA.

 Public DblA as Double 

Если вы объявите переменную double на уровне модуля, а затем попытаетесь использовать ее в другом модуле, произойдет ошибка.

Однако, если бы вы использовали ключевое слово Public для объявления двойной переменной, ошибка не возникнет, и процедура будет работать нормально.

Кодирование VBA стало проще

Остановить поиск кода VBA в сети. Узнайте больше об AutoMacro — конструкторе кода VBA, который позволяет новичкам создавать процедуры с нуля с минимальными знаниями в области программирования и множеством функций, позволяющих сэкономить время для всех пользователей!

Узнать больше

Формат Double Stored as String

Может быть время, когда вы захотите преобразовать тип данных double в строку — например, вам может понадобиться отобразить символ валюты и округлить число до 2 знаков после запятой.