Типы данных
Содержание:
- Преобразование типов данных в C#
- Целочисленные литералыInteger literals
- Типы указателей
- Инициализация полей структуры
- Вычисления с целыми числамиExplore integer math
- Вещественные константы
- Классы памяти
- Типы с плавающей точкой
- Таблицы
- Строковые константы
- Таблица преобразования типов с плавающей запятойTable of conversions from floating-point types
- Work with Exponential Numbers
- Вещественные типы данных
- Целые типы фиксированной длины
- Структуры
- Вывод информации
Преобразование типов данных в C#
Преобразование типов данных, это приведение одного типа к другому. Например, приведение целочисленной переменной к числу с плавающей точной, или преобразование числа в строку. В C# выделяют два варианта преобразования типов:
- Неявное преобразование типов. Это, так называемое безопасное преобразование типов в C#. Например, преобразование из типа float (более «маленький» тип) в тип double (более «большой» тип). При таком преобразовании никакая информация не «потеряется», что при обратном преобразовании вполне возможно.
- Явное преобразование типов. Такое преобразование выполняется программистом с прямым указанием типа, к которому нужно привести переменную. Для такого преобразования требуется наличие оператора преобразования.
А теперь, я покажу как можно использовать явное преобразование типов в C#:
using System;
namespace TypesConvertion
{
class Program
{
static void Main(string[] args)
{
//Число с плавающей точкой
double doubleData = 245.45;
//Вывод этого числа
Console.WriteLine(doubleData);
//А теперь, мы сделаем на основе этого числа, цело число
int intData = (int)doubleData;
//Вывод целого числа
Console.WriteLine(intData);
//Чтобы окно не закрылось раньше времени
Console.ReadKey();
}
}
}
Преобразование типа double в тип int выполнялось в выделенной строке (строке с номером 16). Если вы соберете данный пример и запустите его, то увидите, что преобразование типов прошло, т.е. из числа с плавающей точкой мы получили целое число.
Так же, для преобразования данных из одного типа в другой, есть целый класс с именем Convert, у которого имеются специальные методы. Ниже, в таблице, представлены основные методы этого класса.
| Название метода | Целевой тип |
|---|---|
| ToBoolean | bool |
| ToByte | byte |
| ToChar | char |
| ToDouble | double |
| ToSingle | float |
| ToInt32 | int |
| ToInt64 | long |
| ToString | string |
А теперь, пример использования класса Convert и его методов:
using System;
namespace TypesConvertion
{
class Program
{
static void Main(string[] args)
{
//Число с плавающей точкой
double doubleData = 245.45;
//Вывод этого числа
Console.WriteLine(doubleData);
//А теперь, мы сделаем на основе этого числа, цело число
int intData = Convert.ToInt32(doubleData);
//Вывод целого числа
Console.WriteLine(intData);
//Чтобы окно не закрылось раньше времени
Console.ReadKey();
}
}
}
Как видите, это практически тот же код, что был в первом примере, но с использованием другого подхода в преобразовании типов.
Пользоваться возможность преобразования типов вам придется довольно часто!
Целочисленные литералы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:
Типы указателей
Для любого типа 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"
Инициализация полей структуры
Инициализация полей структуры может осуществляться двумя способами:
- присвоение значений элементам структуры в процессе объявления переменной, относящейся к типу структуры;
- присвоение начальных значений элементам структуры с использованием функций ввода-вывода (например, printf() и scanf()).
В первом способе инициализация осуществляется по следующей форме:
struct ИмяСтруктуры ИмяПеременной={ЗначениеЭлемента1, ЗначениеЭлемента_2, . . . , ЗначениеЭлементаn};
Пример
struct date bd={8,»июня», 1978};
ИмяПеременной.ИмяЭлементаСтруктуры
printf(«%d %s %d»,bd.day, bd.month, bd.year);
Пример
1234567891011121314151617181920212223242526272829303132
#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>struct date { int day; char month; int year;};struct persone { char firstname; char lastname; struct date bd;};int main() { system(«chcp 1251»); system(«cls»); struct persone p; printf(«Введите имя : «); scanf(«%s», p.firstname); printf(«Введите фамилию : «); scanf(«%s», p.lastname); printf(«Введите дату рождения\nЧисло: «); scanf(«%d», &p.bd.day); printf(«Месяц: «); scanf(«%s», p.bd.month); printf(«Год: «); scanf(«%d», &p.bd.year); printf(«\nВы ввели : %s %s, дата рождения %d %s %d года», p.firstname, p.lastname, p.bd.day, p.bd.month, p.bd.year); getchar(); getchar(); return 0;}
Имя структурной переменной может быть указано при объявлении структуры. В этом случае оно размещается после закрывающей фигурной скобки }. Область видимости такой структурной переменной будет определяться местом описания структуры.
struct complex_type // имя структуры{ double real; double imag;} number; // имя структурной переменной
Поля приведенной структурной переменной: number.real, number.imag .
Вычисления с целыми числамиExplore integer math
Создайте каталог с именем numbers-quickstart.Create a directory named numbers-quickstart. Сделайте его текущим, выполнив следующую команду:Make that the current directory and run the following command:
Откройте файл Program.cs в любом редакторе и замените строку следующим кодом:Open Program.cs in your favorite editor, and replace the line with the following code:
Чтобы выполнить этот код, введите в окно командной строки.Run this code by typing in your command window.
Вы увидели одну из основных математических операций с целыми числами.You’ve seen one of the fundamental math operations with integers. Тип представляет целое положительное или отрицательное число или ноль.The type represents an integer, a zero, positive, or negative whole number. Для сложения используйте символ .You use the symbol for addition. Другие стандартные математические операции с целыми числами включают:Other common mathematical operations for integers include:
- — вычитание; for subtraction
- — умножение; for multiplication
- — деление. for division
Начните с ознакомления с различными операциями.Start by exploring those different operations. Добавьте следующие строки после строки, с помощью которой записывается значение :Add these lines after the line that writes the value of :
Чтобы выполнить этот код, введите в окно командной строки.Run this code by typing in your command window.
Можно также поэкспериментировать, написав несколько математических операций в одной строке.You can also experiment by writing multiple mathematics operations in the same line, if you’d like. Например, выполните .Try for example. Допускается сочетание переменных и постоянных чисел.Mixing variables and constant numbers is allowed.
Совет
Вероятнее всего, при изучении C# (как и любого другого языка программирования) вы будете допускать ошибки в коде.As you explore C# (or any programming language), you’ll make mistakes when you write code. Компилятор найдет эти ошибки и сообщит вам о них.The compiler will find those errors and report them to you. Если результат содержит сообщения об ошибках, внимательно просмотрите пример кода и код в окне, чтобы понять, что нужно исправить.When the output contains error messages, look closely at the example code and the code in your window to see what to fix.
Это упражнение поможет вам изучить структуру кода C#.That exercise will help you learn the structure of C# code.
Вы завершили первый этап.You’ve finished the first step. Прежде чем перейти к следующему разделу, переместим текущий код в отдельный метод.Before you start the next section, let’s move the current code into a separate method. Это упростит начало работы с новым примером.That makes it easier to start working with a new example. Переименуйте метод в и запишите новый метод , который вызывает .Rename your method to and write a new method that calls . В результате ваш код должен выглядеть примерно следующим образом:When you finish, your code should look like this:
Вещественные константы
Константа с плавающей точкой (вещественная константа) всегда представляется числом с плавающей точкой двойной точности, т. е. как имеющая тип double, и состоит из следующих частей:
- целой части — последовательности цифр;
- точки — разделителя целой и дробной части;
- дробной части — последовательности цифр;
- символа экспоненты е или E;
- экспоненты в виде целой константы (может быть со знаком).
Любая часть (но не обе сразу) из нижеследующих пар может быть опущена:
- целая или дробная часть;
- точка или символ е (Е) и экспонента в виде целой константы.
Примеры вещественных констант
- 345.
- 3.14159
- 2.1Е5
- .123ЕЗ
- 4037е-5
По умолчанию компилятор присваивает вещественному числу тип double. Если программиста не устраивает тип, который компилятор приписывает константе, то тип можно явно указать в записи константы с помощью следующих суффиксов:
- F (или f) — float для простых вещественных констант,
- L (или l) — long double для вещественных констант двойной расширенной точности.
Примеры:
- 3.14159F — константа типа float, занимающая 4 байта;
- 3.14L — константа типа long double, занимающая 10 байт.
Классы памяти
Переменные, независимо от их типа, имеют свою область видимости и время существования.
Классы памяти:
- auto;
- static;
- extern;
- register.
Все переменные в языке Си по умолчанию являются локальными. Они могут использоваться только внутри функции или блока. По завершении функции их значение уничтожается.
Статическая переменная также является локальной, но вне своего блока может иметь другое значение, а между вызовами функции значение сохраняется.
Внешняя переменная является глобальной. Она доступна в любой части кода и даже в другом файле.
Регистровая переменная рекомендует компилятору сохранять значение в оперативную память.
Спецификаторы типов данных в Си могут не указываться в таких случаях:
- Все переменные внутри блока не являются переменными, соответственно, если предполагается использование именно этого класса памяти, то спецификатор auto не указывается.
- Все функции, объявленные вне блока или функции, являются по умолчанию глобальными, поэтому спецификатор extern не обязателен.
Типы с плавающей точкой
Числа с плавающей точкой (иногда их называют действительными числами) применяются при вычислении выражений, в которых требуется точность до десятичного знака. Например, это может быть вычисление квадратного корня, значений синуса, косинуса и т.п. Существует два типа с плавающей точкой: float и double, которые представляют числа одинарной и двойной точности.
Слово «плавающая» означает, что десятичная точка может располагаться в любом месте (она «плавает»). Вот коты плавать не особенно любят, поэтому они не float и не double.
Тип float
Тип float определяет значение одинарной точности, которое занимает 32 бит. Переменные данного типа удобны, когда требуется дробная часть без особой точности, например, для денежных сумм.
Рекомендуется добавлять символ F или f для обозначения этого типа, иначе число будет считаться типом double.
Конвертируем из строки.
Класс Float является оболочкой для данного типа. Без необходимости не используйте в Android класс Float.
Также есть специальный класс BigDecimal для проведения арифметических действий повышенной точности (финансовые расчёты).
Тип double
Тип double обеспечивает двойную точность, что видно из его названия (double — двойная). Занимает 64 бит для хранения значений. Многие математические функции возвращают значения типа double. Кстати, современные процессоры оптимизированы под вычисления значений двойной точности, поэтому они предпочтительнее, чем тип float.
Тип double содержит не только числа, но и слова. Сейчас вам докажу. Разделим число типа double на ноль. Ошибки не произойдёт.
Пример вернёт значение Infinity (Бесконечность). Если разделить отрицательное число на ноль, то вернётся -Infinity.
А что произойдёт, если сложить две бесконечности? Если рассуждать логически, то сломается интернет, наступит конец света или можно вызвать Волдеморта. Я долго не решался, но потом набрался храбрости и попробовал.
Вернулось ещё одно слово — NaN. Что это вообще? Может должно вернуться Nyan — ну вы знаете, это странный котик, который летит бесконечно в космосе, оставляя за собой шлейф из радуги.
Умножать две бесконечности я побоялся. И вам не советую.
Класс Double является оболочкой для данного типа. Без необходимости не используйте в Android класс Double.
Конвертация double в строку
При работе с числами double следует держать ухо востро. Рассмотрим пример конвертации трёх чисел.
Первые два числа нормально преобразовались, а вот третье число преобразовалось в строку в странном виде (на самом деле это научное представление числа). И это может источником проблемы при передаче строки куда-нибудь, например, на сервер. Если сервер не ожидает от вас такой подлости, то будет генерировать ошибки из-за странной записи. Нужно найти другие способы конвертации.
Первый способ — используем String.format().
Последний пример самый подходящий для нас, но вам нужно знать, сколько знаков идёт после десятичной точки. Остальные два пригодятся, если число можно округлить.
Второй способ — метод Double.toString(). У меня метод превратил число в «непонятную» строку. А у некоторых этот пример возвращал строку в нормальном виде. Не заслуживает доверия.
Третий способ — добавить пустую строку. В Android не помогло, хотя тоже утверждается, что у кого-то выводится в нормальном виде. Врут, наверное.
Четвёртый экзотический способ, которым редко пользуются — DecimalFormat.
Таблицы
наиболее точной суммыабсолютного
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ~ | 4.86 21 |
0 0 |
0 0 |
| ↑ | 4.97 14 |
0 0 |
0 0 |
| ↓ | 4.50 19 |
0 0 |
0 0 |
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ±~ | 158.96 7936 |
0 0 |
0 0 |
| ±↑ | 86.35 2560 |
0 0 |
0 0 |
| ±↓ | 175.70 11776 |
0 0 |
0 0 |
6
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ~ | 143.00 562 |
0 0 |
0 0 |
| ↑ | 126.60 473 |
0 0 |
0 0 |
| ↓ | 161.91 482 |
0 0 |
0 0 |
| ±~ | 2015.41 38889 |
0 0 |
0 0 |
| ±↑ | 1520.84 33965 |
0 0 |
0 0 |
| ±↓ | 1672.76 36513 |
0 0 |
0 0 |
6
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ~ | 4277.17 4662 |
0 0 |
0 0 |
| ↑ | 29.17 111 |
0 0 |
0 0 |
| ↓ | 7508.68 7915 |
0 0 |
0 0 |
| ±~ | 475.68 8221 |
1.09 21 |
0 0 |
| ±↑ | 65.39 861 |
0.01 1 |
0 0 |
| ±↓ | 270.34 1736 |
0 0 |
0 0 |
о
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ~ | 4.84 19 |
0.01 1 |
0 0 |
| ↑ | 2.81 11 |
0.01 1 |
0 0 |
| ↓ | 6.53 26 |
0 0 |
0 0 |
| ±~ | 33.83 1650 |
1.26 23 |
0 0 |
| ±↑ | 12.76 422 |
0.31 6 |
0 0 |
| ±↓ | 18.54 548 |
0 0 |
0 0 |
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ~ | 17.77 483 |
1.46 61 |
0 0 |
| ↑ | 10.92 243 |
0.34 19 |
0 0 |
| ↓ | 19.71 734 |
0 0 |
0 0 |
| Порядок | Всё подряд | Отдельно + и – |
|---|---|---|
| ±~ | 78.65 2336 |
2121.61 50048 |
| ±↑ | 76.27 2496 |
2465.55 66432 |
| ±↓ | 52.74 480 |
2863.61 99200 |
6
| Порядок | Naive | Kahan | Rump–Ogita–Oishi |
|---|---|---|---|
| ~ | 210 | 522 | |
| ↑ | 410 | ||
| ↓ | 42 |
для себя
- Если нужно испортить сумму, получаемую наивным алгоритмом, то можно складывать отдельно положительные и отдельно отрицательные числа. Иногда, но не всегда, сортировка чисел по убыванию модуля также «ломает» наивный алгоритм, лучше сортировать по возрастанию, но и это в ряде случаев даёт более плохой результат, чем в случае хаотичного порядка.
- Если нужно получить ожидаемо хороший результат, следует взять алгоритм Rump–Ogita–Oishi, я не нашёл случайных тестов, при которых он выдавал бы не наиболее точную сумму. Недостаток алгоритма в том, что работать он будет медленнее наивного сложения. Ускорить такой алгоритм, вероятно, можно, пользуясь битовым представлением числа с плавающей запятой и кое-какими трюками, но у нас такой задачи на этот обзор не было.
- Алгоритм Кэхэна значительно лучше наивного суммирования и гораздо проще алгоритма Rump–Ogita–Oishi, поэтому наиболее целесообразен на практике, где точность наивного метода вам не подходит. Просто убедитесь заранее, что ваши числа не обладают какими-то экстраординарными свойствами, которые «завалят» данный алгоритм.
- Наивное суммирование в общем-то не такое страшное, как могло показаться. Ну, подумаешь, потеряли мы 5 десятичных цифр (если N не более миллиона). Много? Если их у вас 16, то вроде бы не страшно, а если 7 (для float), то вроде бы… хотя, друзья, неужели кто-то будет складывать миллион чисел в типе float? Вы серьёзно? Это допустимо только если вам нужна одна правильная цифра, либо если массив обладает какой-то особой спецификой, и то я бы не рискнул.
- Это творческий процесс, я создал свою субъективную схему тестирования и не считаю это научно-достоверным знанием, а потому не выношу на суд общественности. Коды алгоритмов я дал выше, если вам очень нужно, то не составит труда написать своё сравнение алгоритмов и получить свои данные.
- Мой код не автоматизирован, чтобы его запускать для получения разных тестов, нужно ковыряться в программе и менять какие-то параметры, это просто неприлично — давать такой код. А написание полноценной системы тестирования в задачи публикации не входило.
Строковые константы
Строковая константа — это последовательность символов, заключенная в кавычки, например:
«Это строковая константа»
Кавычки не входят в строку, а лишь ограничивают её. Технически строковая константа представляет собой массив символов, и по этому признаку может быть отнесена к разряду сложных объектов языка Си.
В конце каждой строковой константы компилятор помещает ‘\0’ (нуль-символ), чтобы программе было возможно определить конец строки. Такое представление означает, что размер строковой константы не ограничен каким-либо пределом, но для определения длины строковой константы её нужно полностью просмотреть.
Поскольку строковая константа состоит из символов, то она имеет тип char. Количество ячеек памяти, необходимое для хранения строковой константы на 1 больше количества символов в ней (1 байт используется для хранения нуль-символа).
Символьная константа ‘x’ и строка из одного символа «x» — не одно и то же. Символьная константа — это символ, используемый для числового представления буквы x, а строковая константа «x» содержит символ ‘x’ и нуль-символ ‘\0’ и занимает в памяти 2 байта. Если в программе строковые константы записаны одна за другой через разделители, то при выполнении программы они будут размещаться в последовательных ячейках памяти.
Таблица преобразования типов с плавающей запятойTable of conversions from floating-point types
| Исходный типFrom | КомуTo | МетодMethod |
|---|---|---|
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Представление в качестве значения .Represent as a . | ||
| Представление в качестве значения .Represent as a . | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Преобразование в ; преобразование в Convert to ; convert to | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Усечение до десятичной запятой.Truncate at decimal point. Если результат слишком велик для представления в качестве значения , результат не определен.If result is too large to be represented as , result is undefined. | ||
| Представление в качестве значения .Represent as a . Если значение невозможно точно представить с типом , происходит потеря точности.If value can’t be represented exactly as , loss of precision occurs. Если значение слишком велико для представления в качестве значения , результат не определен.If value is too large to be represented as , the result is undefined. | ||
| Значение рассматривается как .The value is treated as . |
Преобразования из типа производятся так же, как из типа .Conversions from follow the same method as conversions from .
Work with Exponential Numbers
As mentioned above, and can also be used to represent exponential numbers. For example,
C++ outputs exponential numbers and very large numbers in a format called the scientific format. The variable ex will be outputted in this format by default since it is a very large number.
In order to force C++ to display our floating-point numbers in the format regardless of the size of the number, we use the format specifier inside of .
In addition to this, there is another format specifier known as , which displays floating-point numbers in the decimal format.
It is similar to displaying floating-point numbers by only using without , except for the fact that displays numbers up to 6 decimal points.
On the other hand, only using displays digits according to the specific compiler (6 total digits in the case of MinGW compiler, including the digits before the decimal point).
Example 4: Fixed and Scientific Formats
Output
Displaying Output With fixed: Double Type Number 1 = 3.912348 Double Type Number 2 = 32500.000000 Float Type Number 1 = 3.912348 Float Type Number 2 = 32500.000000 Displaying Output With scientific: Double Type Number 1 = 3.912348e+000 Double Type Number 2 = 3.250000e+004 Float Type Number 1 = 3.912348e+000 Float Type Number 2 = 3.250000e+004
Вещественные типы данных
В языке C существует три типа чисел с плавающей точкой: float и double (двойной точности) и long double. Также существует три формата вывода вещественных чисел, причем они не связаны с типами, а связаны с удобством представления числа. Вещественные числа могут иметь высокую точность, очень маленькое или очень большое значение. Если выполнить функции printf() с такими параметрами:
double a = 0.0005;
printf("%f\n", a);
printf("%g\n", 0.0005);
printf("%g\n", 0.00005);
printf("%e\n", 0.0005);
, то на экране мы увидим следующее:
0.000500 0.0005 5e-05 5.000000e-04
В первом случае (%f) выводится число в обычном виде. По умолчанию точность представления числа равна шести знакам после точки.
Во втором случае (%g) число выводится как обычно, если количество значащих нулей не больше четырех. Если количество значащих нулей четыре и больше, то число выводится в нормализованном виде (третий случай). Запись 5e-5 означает 5 * 10-5, что равно 0.00005. А, например, запись 4.325e+3 является экспоненциальной записью 4.325 * 103, что равно 4325. Если с такой формой представления чисел вы сталкиваетесь первый раз, то почитайте дополнительные источники, например, статью в Википедии «Экспоненциальная запись».
Четвертый формат (%e) выведет число исключительно в нормализованном виде, каким бы это вещественное число ни было.
Если при выводе требуется округлить число до определенной точности, то перед буквой-форматом ставят точку и число-указатель точности. Например, printf(«%.2f», 0.23) выведет на экран 0.23, а не 0.230000. Когда требуется указать еще и поле, то его ширину прописывают перед точкой, например, %10.3f.
Целые типы фиксированной длины
Стандарт C99 включает определения нескольких новых целочисленных типов для повышения переносимости программ. Уже доступные целочисленные базовые типы были сочтены неудовлетворительными, так как их размер зависел от реализации. Новые типы находят широкое применение в встраиваемых системах. Все новые типы определены в заголовочном файле ( в C++) и также доступны в ( в C++). Типы можно разделить на следующие категории:
- Целые с точно заданным размером N бит в любой реализации. Включаются, только если доступны в реализации/платформе.
- Наименьшие целые, размер которых является минимальным в реализации, состоят минимум из N бит. Гарантируется что определены типы для N=8,16,32,64.
- Наибыстрейшие целые типы, которые являются гарантировано наиболее быстрыми в конкретной реализации, состоят минимум из N бит. Гарантируется что определены типы для N=8,16,32,64.
- Целые типы для указателей, которые гарантировано смогут хранить адрес в памяти. Включены, только если доступны на конкретной платформе.
- Наибольшие целые, размер которых является максимальным в реализации.
Следующая таблица показывает эти типы (N означает число бит):
| Категория типа | Знаковые типы | Беззнаковые типы | |||
|---|---|---|---|---|---|
| Тип | Минимальное значение | Максимальное значение | Тип | Минимальное значение | Максимальное значение |
| Точный размер | |||||
| Минимальный размер | |||||
| Наибыстрый | |||||
| Указатель | |||||
| Максимальный размер |
Спецификаторы формата для printf и scanf
Заголовочный файл ( в C++) расширяет возможности типов, определённых в . В них входят макросы, которые определяют спецификаторы типов для строки формата printf и scanf и несколько функций, которые работают с типами и . Этот заголовочный файл был добавлен в C99.
- Строка формата printf
Макросы определены в формате . Здесь {fmt} означает формат вывода и принадлежит (десятичный), (шестнадцатиричный), (восьмеричный), (беззнаковый) или (целый). {type} определяет тип аргумента и принадлежит к , , , либо , где означает число бит.
- Строка формата scanf
Макросы определены в формате . Здесь {fmt} означает формат вывода и принадлежит (десятичный), (шестнадцатиричный), (восьмиричный), (беззнаковый) или (целый). {type} определяет тип аргумента и принадлежит к , , , либо , где означает число бит.
- Функции
Структуры
Структура — такой тип данных в Си, который облегчает написание и понимание программ, помогает группировать данные.
Структура наподобие массива представляет совокупность данных, но ее элементы могут быть различного типа, а обращение производится по имени, а не по индексу.
Объявление структурной переменной происходит после закрывающих фигурных скобок.
Доступ к полям осуществляется с помощью оператора “.”. Чтобы обратиться к переменной title, пишем:
Таким образом, инициализируем переменную
Для обращения к указателям используется оператор “->”.
или оператор «.».
Вторая разновидность списков с данным — enum (перечисление). Он содержит целочисленные переменные.
В примере объявлено анонимное перечисление, содержащее три члена red, blue, green. Перед обращением к элементам объявляется перечислительная переменная.
В этом случае name1 является именем перечисления, а varname — имя переменной. В моменте создания структуры можно задать несколько переменных. Они перечисляются через запятую.
Доступ к членам перечисления задается при помощи оперетора «.».
Вывод информации
Функция printf() предназначена для форматированного вывода. Она переводит данные в символьное представление и выводит полученные изображения символов на экран. При этом у программиста имеется возможность форматировать данные, то есть влиять на их представление
на экране.
Общая форма записи функции printf():
printf(«СтрокаФорматов», объект1, объект2, …, объектn);
СтрокаФорматов
- управляющих символов;
- текста, представленного для непосредственного вывода;
- форматов, предназначенных для вывода значений переменных различных типов.
Объекты могут отсутствовать.Управляющие символы не выводятся на экран, а управляют расположением выводимых символов. Отличительной чертой управляющего символа является наличие обратного слэша ‘\’ перед ним.
Основные управляющие символы:
- ‘\n’ — перевод строки;
- ‘\t’ — горизонтальная табуляция;
- ‘\v’ — вертикальная табуляция;
- ‘\b’ — возврат на символ;
- ‘\r’ — возврат на начало строки;
- ‘\a’ — звуковой сигнал.
Форматы нужны для того, чтобы указывать вид, в котором информация будет выведена на экран. Отличительной чертой формата является наличие символа процент ‘%’ перед ним:
- %d — целое число типа int со знаком в десятичной системе счисления;
- %u — целое число типа unsigned int;
- %x — целое число типа int со знаком в шестнадцатеричной системе счисления;
- %o — целое число типа int со знаком в восьмеричной системе счисления;
- %hd — целое число типа short со знаком в десятичной системе счисления;
- %hu — целое число типа unsigned short;
- %hx — целое число типа short со знаком в шестнадцатеричной системе счисления;
- %ld — целое число типа long int со знаком в десятичной системе счисления;
- %lu — целое число типа unsigned long int;
- %lx — целое число типа long int со знаком в шестнадцатеричной системе счисления;
- %f — вещественный формат (числа с плавающей точкой типа float);
- %lf — вещественный формат двойной точности (числа с плавающей точкой типа double);
- %e — вещественный формат в экспоненциальной форме (числа с плавающей точкой типа float в экспоненциальной форме);
- %c — символьный формат;
- %s — строковый формат.
Строка форматов содержит форматы для вывода значений. Каждый формат вывода начинается с символа %. После строки форматов через запятую указываются имена переменных, которые необходимо вывести.
Количество символов % в строке формата должно совпадать с количеством переменных для вывода. Тип каждого формата должен совпадать с типом переменной, которая будет выводиться на это место. Замещение форматов вывода значениями переменных происходит в порядке их следования.Пример на Си
12345678910
#include <stdio.h>int main(){ int a = 5; float x = 2.78; printf(«a=%d\n», a); printf(«x=%f\n», x); getchar(); return 0;}
Результат работы программы
Тот же самый код может быть представлен с использованием одного вызова printf:
123456789
#include <stdio.h>int main(){ int a = 5; float x = 2.78; printf(«a=%d\nx=%f\n», a, x); getchar(); return 0;}
