Урок №30. размер типов данных

Характеристики типов с плавающей запятойCharacteristics of the floating-point types

C# поддерживает следующие предварительно определенные типы с плавающей запятой:C# supports the following predefined floating-point types:

Ключевое слово или тип C#C# type/keyword	Приблизительный диапазон значенийApproximate range	ТочностьPrecision	РазмерSize	Тип .NET.NET type
	От ±1,5 x 10−45 до ±3,4 x 1038±1.5 x 10−45 to ±3.4 x 1038	6–9 цифр~6-9 digits	4 байта4 bytes	System.Single
	от ±5,0 × 10−324 до ±1,7 × 10308±5.0 × 10−324 to ±1.7 × 10308	15–17 цифр~15-17 digits	8 байт8 bytes	System.Double
	от ±1,0 x 10-28 до ±7,9228 x 1028±1.0 x 10-28 to ±7.9228 x 1028	28-29 знаков28-29 digits	16 байт16 bytes	System.Decimal

В приведенной выше таблице каждый тип ключевого слова C# из крайнего левого столбца является псевдонимом для соответствующего типа .NET.In the preceding table, each C# type keyword from the leftmost column is an alias for the corresponding .NET type. Они взаимозаменяемые.They are interchangeable. Например, следующие объявления объявляют переменные одного типа:For example, the following declarations declare variables of the same type:

По умолчанию все типы с плавающей запятой имеют значение .The default value of each floating-point type is zero, . Все типы с плавающей запятой имеют константы и с минимальным и максимальными итоговыми значениями этого типа.Each of the floating-point types has the and constants that provide the minimum and maximum finite value of that type. Типы и также предоставляют константы, обозначающие бесконечные и нечисловые значения.The and types also provide constants that represent not-a-number and infinity values. Например, тип предоставляет следующие константы: Double.NaN, Double.NegativeInfinity и Double.PositiveInfinity.For example, the type provides the following constants: Double.NaN, Double.NegativeInfinity, and Double.PositiveInfinity.

Так как тип характеризуется более высокой точностью и меньшим диапазоном, чем и , он подходит для финансовых расчетов.Because the type has more precision and a smaller range than both and , it’s appropriate for financial and monetary calculations.

В одном и том же выражении можно сочетать и целочисленные типы, и типы и .You can mix integral types and the and types in an expression. В этом случае целочисленные типы неявно преобразуются в один из типов с плавающей запятой. При необходимости тип неявно преобразуется в .In this case, integral types are implicitly converted to one of the floating-point types and, if necessary, the type is implicitly converted to . Выражение вычисляется следующим образом.The expression is evaluated as follows:

• Если в выражении есть тип , оно оценивается как или в реляционных сравнениях или сравнениях на равенство.If there is type in the expression, the expression evaluates to , or to in relational and equality comparisons.
• Если в выражении нет типа , оно оценивается как или в реляционных сравнениях или сравнениях на равенство.If there is no type in the expression, the expression evaluates to , or to in relational and equality comparisons.

Можно также смешивать целочисленные типы и тип в выражении.You can also mix integral types and the type in an expression. В этом случае целочисленные типы неявно преобразуются в тип , а выражение вычисляется как или в реляционных сравнениях и сравнениях на равенство.In this case, integral types are implicitly converted to the type and the expression evaluates to , or to in relational and equality comparisons.

Тип нельзя смешивать с типами и в выражении.You cannot mix the type with the and types in an expression. В этом случае, если требуется выполнить арифметические операции или операции сравнения или равенства, необходимо явно преобразовать операнды из типа или в тип , как показано в следующем примере:In this case, if you want to perform arithmetic, comparison, or equality operations, you must explicitly convert the operands either from or to the type, as the following example shows:

Можно использовать строки стандартных числовых форматов или строки пользовательских числовых форматов для форматирования значения с плавающей запятой.You can use either standard numeric format strings or custom numeric format strings to format a floating-point value.

Вступление

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

Но многие начинающие программисты часто пытаются сделать что-то вроде следующего: . Однако, поскольку и являются целыми числами, никакого числового расширения не происходит. Выполняется целочисленное деление , результатом которого будет значение , которое затем неявно преобразуется в и присвоится переменной !

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

Но что будет, если использовать переменные? Например:

int i1 = 11;
int i2 = 3;
float x = i1 / i2;

1 2 3

inti1=11; inti2=3; floatx=i1i2;

Значением переменной будет . Как сообщить компилятору, что мы хотим использовать деление типа с плавающей точкой вместо целочисленного деления? Правильно! Использовать один из операторов явного преобразования типов данных, чтобы указать компилятору выполнить явное преобразование.

Работа с типом doubleWork with the double type

Числовой тип представляет число с плавающей запятой двойной точности.The numeric type represents a double-precision floating point number. Эти термины могут быть новыми для вас.Those terms may be new to you. Число с плавающей запятой можно использовать для представления нецелых чисел, которые могут быть очень большими или малыми.A floating point number is useful to represent non-integral numbers that may be very large or small in magnitude. Число двойной точности — это относительный термин, описывающий количество двоичных разрядов, используемых для хранения значения.Double-precision is a relative term that describes the number of binary digits used to store the value. Числа двойной точности имеют в два раза больше двоичных символов по сравнению с числами одиночной точности.Double precision numbers have twice the number of binary digits as single-precision. На современных компьютерах числа двойной точности используются чаще, чем одиночной.On modern computers, it’s more common to use double precision than single precision numbers. Числа одиночной точности объявляются с помощью ключевого слова .Single precision numbers are declared using the keyword.
Рассмотрим их.Let’s explore. Добавьте следующий код и просмотрите результат:Add the following code and see the result:

Обратите внимание, что ответ включает десятичную долю частного.Notice that the answer includes the decimal portion of the quotient. Попробуйте более сложное выражение с типом double:Try a slightly more complicated expression with doubles:. Диапазон значений типа double гораздо больше, чем диапазон значений целых чисел.The range of a double value is much greater than integer values

Добавьте следующий фрагмент после написанного кода:Try the following code below what you’ve written so far:

Диапазон значений типа double гораздо больше, чем диапазон значений целых чисел.The range of a double value is much greater than integer values. Добавьте следующий фрагмент после написанного кода:Try the following code below what you’ve written so far:

Значения выводятся в экспоненциальном представлении.These values are printed out in scientific notation. Число слева от символа является значащим.The number to the left of the is the significand. Число справа — это показатель степени, который равен 10.The number to the right is the exponent, as a power of 10.

Так же, как десятичные числа в математике, значения double в C# могут содержать ошибки округления.Just like decimal numbers in math, doubles in C# can have rounding errors. Выполните этот код:Try this code:

Вы знаете, что периодическая десятичная дробь не равняется .You know that repeating isn’t exactly the same as .

ЗадачаChallenge

Выполните другие вычисления с большими числами, малыми числами, умножением и делением с помощью типа .Try other calculations with large numbers, small numbers, multiplication, and division using the type. Попробуйте выполнить более сложные вычисления.Try more complicated calculations.

После того как вы решите сложную задачу, поместите написанный код в новый метод.After you’ve spent some time with the challenge, take the code you’ve written and place it in a new method. Присвойте этому методу имя .Name that new method .

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

Целочисленные типы данных отлично подходят для работы с целыми числами, но есть ведь еще и дробные числа. И тут нам на помощь приходит тип данных с плавающей точкой (или «тип данных с плавающей запятой», англ. «floating point»). Переменная такого типа может хранить любые действительные дробные значения, например: 4320.0, -3.33 или 0.01226. Почему точка «плавающая»? Дело в том, точка/запятая перемещается («плавает») между цифрами, разделяя целую и дробную части значения.

Есть три типа данных с плавающей точкой: float, double и long double. Язык C++ определяет только их минимальный размер (как и с целочисленными типами). Типы данных с плавающей точкой всегда являются signed (т.е. могут хранить как положительные, так и отрицательные числа).

Категория	Тип	Минимальный размер	Типичный размер
Тип данных с плавающей точкой	float	4 байта	4 байта
	double	8 байт	8 байт
	long double	8 байт	8, 12 или 16 байт

Объявление переменных разных типов данных с плавающей точкой:

float fValue;
double dValue;
long double dValue2;

1 2 3

floatfValue; doubledValue; longdoubledValue2;

Если нужно использовать целое число с переменной типа с плавающей точкой, то тогда после этого числа нужно поставить разделительную точку и нуль. Это позволяет различать переменные целочисленных типов от переменных типов с плавающей запятой:

int n(5); // 5 — это целочисленный тип
double d(5.0); // 5.0 — это тип данных с плавающей точкой (по умолчанию double)
float f(5.0f); // 5.0 — это тип данных с плавающей точкой («f» от «float»)

1 2 3

intn(5);// 5 — это целочисленный тип doubled(5.0);// 5.0 — это тип данных с плавающей точкой (по умолчанию double) floatf(5.0f);// 5.0 — это тип данных с плавающей точкой («f» от «float»)

Обратите внимание, литералы типа с плавающей точкой по умолчанию относятся к типу double. в конце числа означает тип float

Целочисленные литералыInteger literals

Целочисленные литералы могут быть:Integer literals can be

• десятичным числом: без префикса;decimal: without any prefix
• шестнадцатеричным числом: с префиксом или ;hexadecimal: with the or prefix
• двоичными: с префиксом или (доступно в C# 7.0 и более поздних версиях).binary: with the or prefix (available in C# 7.0 and later)

В приведенном ниже коде показан пример каждого из них.The following code demonstrates an example of each:

В предыдущем примере также показано использование в качестве цифрового разделителя, который поддерживается, начиная с версии C# 7.0.The preceding example also shows the use of as a digit separator, which is supported starting with C# 7.0. Цифровой разделитель можно использовать со всеми видами числовых литералов.You can use the digit separator with all kinds of numeric literals.

Тип целочисленного литерала определяется его суффиксом следующим образом:The type of an integer literal is determined by its suffix as follows:

• Если литерал не имеет суффикса, его типом будет первый из следующих типов, в котором может быть представлено его значение: , , , .If the literal has no suffix, its type is the first of the following types in which its value can be represented: , , , .

• Если у литерала есть суффикс или , его типом будет первый из следующих типов, в котором может быть представлено его значение: , .If the literal is suffixed by or , its type is the first of the following types in which its value can be represented: , .

• Если у литерала есть суффикс или , его типом будет первый из следующих типов, в котором может быть представлено его значение: , .If the literal is suffixed by or , its type is the first of the following types in which its value can be represented: , .

  Примечание

  Строчную букву можно использовать в качестве суффикса.You can use the lowercase letter as a suffix. Однако при этом выдается предупреждение компилятора, так как букву можно перепутать с цифрой .However, this generates a compiler warning because the letter can be confused with the digit . Для ясности используйте .Use for clarity.

• Если у литерала есть суффикс , , , , , , или , его тип — .If the literal is suffixed by , , , , , , , or , its type is .

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, происходит ошибка компиляции CS1021.If the value represented by an integer literal exceeds UInt64.MaxValue, a compiler error CS1021 occurs.

Если определенный тип целочисленного литерала — , а значение, представленное литералом, находится в диапазоне целевого типа, значение можно неявно преобразовать в , , , , или :If the determined type of an integer literal is and the value represented by the literal is within the range of the destination type, the value can be implicitly converted to , , , , , or :

Как показано в предыдущем примере, если значение литерала выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031.As the preceding example shows, if the literal’s value is not within the range of the destination type, a compiler error CS0031 occurs.

Можно также использовать приведение для преобразования значения, представленного целочисленным литералом, в тип, отличный от определенного типа литерала:You can also use a cast to convert the value represented by an integer literal to the type other than the determined type of the literal:

Оператор остатка %Remainder operator %

Оператор остатка вычисляет остаток от деления левого операнда на правый.The remainder operator computes the remainder after dividing its left-hand operand by its right-hand operand.

Целочисленный остатокInteger remainder

Для целочисленных операндов результатом является значение, произведенное .For the operands of integer types, the result of is the value produced by . Знак ненулевого остатка такой же, как и у левого операнда, как показано в следующем примере:The sign of the non-zero remainder is the same as that of the left-hand operand, as the following example shows:

Используйте метод Math.DivRem для вычисления результатов как целочисленного деления, так и определения остатка.Use the Math.DivRem method to compute both integer division and remainder results.

Остаток с плавающей запятойFloating-point remainder

Для операндов типа и результатом для конечных и будет значение , так что:For the and operands, the result of for the finite and is the value such that

• знак , если отлично от нуля, совпадает со знаком ;The sign of , if non-zero, is the same as the sign of .
• абсолютное значение является значением, произведенным , где  — это наибольшее возможное целое число, которое меньше или равно , а и являются абсолютными значениями и , соответственно.The absolute value of is the value produced by where is the largest possible integer that is less than or equal to and and are the absolute values of and , respectively.

Примечание

Этот метод вычисления остатка аналогичен тому, который использовался для целочисленных операндов, но отличается от спецификации IEEE 754.This method of computing the remainder is analogous to that used for integer operands, but different from the IEEE 754 specification. Если вам нужна операция вычисления остатка, которая соответствует спецификации IEEE 754, используйте метод Math.IEEERemainder.If you need the remainder operation that complies with the IEEE 754 specification, use the Math.IEEERemainder method.

Сведения о поведение оператора в случае неконечных операндов см. в разделе спецификации языка C#.For information about the behavior of the operator with non-finite operands, see the section of the C# language specification.

Для операндов оператор остатка эквивалентен типа System.Decimal.For the operands, the remainder operator is equivalent to the of the System.Decimal type.

В следующем примере показано поведение оператора остатка для операндов с плавающей запятой:The following example demonstrates the behavior of the remainder operator with floating-point operands:

Nullable-типы (нулевые типы) и операция ??

Объявление и инициализация Nullable-переменных

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

int nv = null;
bool bv = null;

На практике, особенно при работе с базами данных, может возникнуть ситуация, когда в записи из таблицы пропущены несколько столбцов (нет данных), в этом случае, соответствующей переменной нужно будет присвоить значение null, но она может иметь тип int или double, что приведет к ошибке.

Можно объявить переменную с использованием символа ? после указания типа, тогда она станет nullable-переменной – переменной поддерживающей null-значение:

int? nv1 = null;
bool? bv1 = null;

Использование символа ? является синтаксическим сахаром для конструкции Nullable<T>, где T – это имя типа. Представленные выше примеры можно переписать так:

Nullable<int> nv1 = null;
Nullable<bool> bv1 = null;

Проверка на null. Работа с HasValue и Value

Для того чтобы проверить, что переменная имеет значение null можно воспользоваться оператором is с шаблоном типа:

bool? flagA = true;

if(flagA is bool valueOfFlag)
{
    Console.WriteLine("flagA is not null, value: {valueOfFlag}");
}

Также можно воспользоваться свойствами класса Nullable

• Nullable<T>.HasValue

  Возвращает true если переменная имеет значение базового типа. То есть если она не null.

• Nullable<T>.Value

  Возвращает значение переменной если HasValue равно true, иначе выбрасывает исключение InvalidOperationException.

bool? flagB = false;

if(flagB.HasValue)
{
    Console.WriteLine("flagB is not null, value: {flagB.Value}");
}

Приведение Nullable-переменной к базовому типу

При работе с Nullable-переменными их нельзя напрямую присваивать переменным базового типа. Следующий код не будет скомпилирован:

double? nvd1 = 12.3;
double nvd2 = nvd1; // error

Для приведения Nullable-переменной к базовому типу можно воспользоваться явным приведением:

double nvd3 = (double) nvd1;

В этом случае следует помнить, что если значение Nullable-переменной равно null, то при выполнении данной операции будет выброшено исключение InvalidOperationException.

Второй вариант – это использование оператора ??, при этом нужно дополнительно задаться значением, которое будет присвоено переменной базового типа если в исходной лежит значение null

double nvd4 = nvd1 ?? 0.0;
Console.WriteLine(nvd4);


bool? nvb1 = null;
bool nvb2 = nvb1 ?? false;
Console.WriteLine(nvb1);
Console.WriteLine(nvb2);

Второй вариант позволяет более лаконично обрабатывать ситуацию, когда вызов какого-то метода может возвращать null, а результат его работы нужно присвоить типу-значению, при этом заранее известно, какое значение нужно присвоить переменной в этой ситуации:

static int? GetValue(bool flag)
{
    if (flag == true)
        return 1000;
    else
        return null;
}

static void Main(string[] args)
{
    int test1 = GetValue(true) ?? 123;
    Console.WriteLine(test1);
    int test2 = GetValue(false) ?? 123;
    Console.WriteLine(test2);
}

Типы данных

Тип	Занимаемый размер (байт)	Минимальное значение	Максимальное значение
	1	false	true
	1	-128	127
	1	255
	2	-32768	32767
	2	65535
	4	-2147483648	2147483647
	4	4294967295
	4	-3.4028235E+38	3.4028235E+38

Логический тип, может принимать только 2 значения — true (правда) и false (ложь). В памяти занимает 1 байт.

числа

char

Тип позволяет хранить 1 алфавитно-цифровой символ и занимае 1 байт. Для записи символа используются одинарные кавычки.

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

Переменная это типа — знаковая, диапазон допустимых значений — от -128 до 127.

int

Пожалуй самый частоиспользуемый тип для хранения целых чисел со знаком — integer (целое число). Занимает 2 байта и может хранить цисла от -32768 до 32767.

На платформе Arduino также присутствует тип , который ничем не отличается от типа int.

long

Тип long служит для хранение больших целых знаковых чисел. Диапазон его значений от -2147483648 до 2147483647, а занимает в памяти он 4 байта.

float

Тип данных чисел с плавающей точкой (или с плавающей запятой). Используется для нецелочисленных расчетов. В Arduino используется например для считывания значений с аналоговых пинов. Диапазон значений от -3.4028235E+38 до 3.4028235E+38,а занимает такая переменная 4 байта.

Точность — 6-7 знаков после запятой.

double

Тип ничем не отличается от типа float и введен для обратной совместимости. На многих других платформах он имеет большую чем у float точность.

string

Тип для хранение текстовых строк. Является массивом символов типа char и символа конца строки ‘\0’ в последнем его элементе. Не путать с классами string и String.

Строка может быть создана и инициализирована несколькими способами:

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

массив

Массив — это набор элементов одного типа с доступом к каждому элементу по индексу.

Нумерация индексов массива начинается с 0.

Преобразование типов

Преобразование типов — это приведение значение переменной к другому типа, отличному от типа данной переменной.

Приведение типов делится на явное и неявное.

Пример явного приведения типа:

Пример неявного приведения типа:

Условная конструкция if принимает на вход значение типа boolean, поэтому целочисленное значение переменной a будет приведено к типа boolean.

Еще один пример явного приведения типа:

Типизация переменных

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

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

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

Сильнотипизированные – те, где вся ответственность за указание типа переменных ложится на программиста

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

Язык C# относится к первым. Возможно, это лишает его такой гибкости как тот же самый JavaScript (который относится ко вторым), но при этом дает большую защищенность от ошибок.

Ошибки округления

Рассмотрим дробь 1/10. В десятичной системе счисления эту дробь можно представить, как 0.1. В двоичной системе счисления эта дробь представлена в виде бесконечной последовательности — 0.00011001100110011… Именно из-за подобных разногласий в представлении чисел в разных системах счисления, у нас могут возникать проблемы с точностью. Например:

#include <iostream>
#include <iomanip> // для std::setprecision()

int main()
{
double d(0.1);
std::cout << d << std::endl; // используем точность cout по умолчанию (6 цифр)
std::cout << std::setprecision(17);
std::cout << d << std::endl;
return 0;
}

1 2 3 4 5 6 7 8 9 10 11

#include <iostream> #include <iomanip> // для std::setprecision() intmain() { doubled(0.1); std::cout<<d<<std::endl;// используем точность cout по умолчанию (6 цифр) std::cout<<std::setprecision(17); std::cout<<d<<std::endl; return; }

Результат выполнения программы:

Первый cout выводит (что и ожидаемо). После того, как мы изменили для объекта cout точность вывода до 17 цифр, мы увидели, что значением переменной является не совсем ! Подобное происходит из-за ограничений в количестве выделяемой памяти для переменных типа double, а также из-за необходимости «округлять» числа. По факту мы получили типичную ошибку округления.

Подобные ошибки могут иметь неожиданные последствия:

#include <iostream>
#include <iomanip> // для std::setprecision()

int main()
{
std::cout << std::setprecision(17);

double d1(1.0);
std::cout << d1 << std::endl;

double d2(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1); // должно получиться 1.0
std::cout << d2 << std::endl;
}

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

#include <iostream> #include <iomanip> // для std::setprecision() intmain() { std::cout<<std::setprecision(17); doubled1(1.0); std::cout<<d1<<std::endl; doubled2(0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1);// должно получиться 1.0 std::cout<<d2<<std::endl; }

Результат выполнения программы:

Хотя мы ожидали, что и окажутся равными, но это не так. А что, если бы нам довелось сравнивать эти переменные и, исходя из результата, выполнять определенный сценарий? В таком случае ошибок нам не миновать.

Математические операции (например, сложение или умножение), как правило, только увеличивают масштаб этих ошибок. Даже если имеет погрешность в 17-й значащей цифре, то при выполнении операции сложения десять раз, ошибка округления переместится к 16-й значащей цифре.

Типы указателей

Для любого типа T существует тип «указатель на T».

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

char letterC = 'C';
char *letter = &letterC; //взятие адреса переменной letterC и присваивание в переменную letter
printf("This code is written in %c.", *letter); //"This code is written in C."

Помимо стандартных типов, можно объявлять указатели на структуры и объединения:

struct Point { int x,y; } A;
A.x = 12;
A.y = 34;
struct Point *p = &A;
printf("X: %d, Y: %d", (*p).x, (*p).y); //"X: 12, Y: 34"

Для обращения к полям структуры по указателю существует оператор «стрелочка» , синонимичный предыдущей записи: — то же самое, что и .

Поскольку указатель — тоже тип переменной, правило «для любого типа T» выполняется и для них: можно объявлять указатели на указатели. К примеру, можно пользоваться :

int w = 100;
int *x = &w;
int **y = &x;
int ***z = &y;
printf("w contains %d.", ***z); //"w contains 100."

Существуют также указатели на массивы и на функции. Указатели на массивы имеют следующий синтаксис:

char *pc10]; // массив из 10 указателей на char
char (*pa); // указатель на массив из 10 переменных типа char

 — массив указателей, занимающий байт (на распространённых платформах — обычно 40 или 80 байт), а  — это один указатель; занимает он обычно 4 или 8 байт, однако позволяет обращаться к массиву, занимающему 10 байт: , но .
Указатели на массивы отличаются от указателей на первый элемент арифметикой. Например, если указатели указывает на адрес 2000, то указатель будет указывать на адрес 2010.

char (*pa);
char array10 = "Wikipedia";
pa = &array;
printf("An example for %s.\n", *pa); //"An example for Wikipedia."
printf("%c %c %c", (*pa), (*pa), (*pa)); //"i i i"

Introduction to C float types

C provides various floating-point types that represent non-integer number with a decimal point at any position. For example, with integer types, you only can have numbers  , , … however with floating-point type, you can have , , and so on.

There are three standard floating-point types in C:

• : for numbers with single precision.
• : for numbers with double precision.
• : for numbers with extended precision.

The following table illustrates the technical attributes of various floating-point types in C. It is important to notice that this is only the minimal requirement for storage size defined by C.

Type	Size	Ranges	Smallest Positive Value	Precision
float	4 bytes	±3.4E+38	1.2E-38	6 digits
double	8 bytes	±1.7E+308	2.3E-308	15 digits
long double	10 bytes	±1.1E+4932	3.4E-4932	19 digits

СинтаксисSyntax

float Где n — это количество битов, используемых для хранения мантиссы числа в формате float при экспоненциальном представлении. Определяет точность данных и размер для хранения.float Where n is the number of bits that are used to store the mantissa of the float number in scientific notation and, therefore, dictates the precision and storage size. Если указан параметр n, это должно быть значение в диапазоне от 1 до 53.If n is specified, it must be a value between 1 and 53. Значение n по умолчанию — 53.The default value of n is 53.

Значение nn value	ТочностьPrecision	Объем памятиStorage size
1-241-24	7 цифр7 digits	4 байта4 bytes
25-5325-53	15 знаков15 digits	8 байт8 bytes

Примечание

В приложении SQL ServerSQL Server параметр n может принимать одно из двух возможных значений.SQL ServerSQL Server treats n as one of two possible values. Если 1<=n<=24, n принимает значение 24.If 1<=n<=24, n is treated as 24. Если 25<=n<=53, n принимает значение 53.If 25<=n<=53, n is treated as 53.

Тип данных SQL ServerSQL Server float соответствует стандарту ISO для всех значений n в диапазоне от 1 до 53.The SQL ServerSQL Server float data type complies with the ISO standard for all values of n from 1 through 53. Синонимом типа double precision является тип float(53) .The synonym for double precision is float(53).

Примечание

Ссылки на описание синтаксиса Transact-SQL для SQL Server 2014 и более ранних версий, см. в статье .To view Transact-SQL syntax for SQL Server 2014 and earlier, see .

Полиморфизм

полиморфизмом

В итоге

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