Floating-point numeric types (c# reference)

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

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

Так, если под переменную какого-либо целочисленного типа выделяется 2 байта, что составляет 16 бит, и ей можно присваивать только положительные числа и ноль, то эти числа будут в диапазоне от 0 до 65535, т. к. 216 = 65536, но одна вариация забирается на нуль. Если же тип допускает отрицательные числа, то диапазон допустимых значений уже будет лежать в пределах от -32768 до +32767.

Часто в программах используется тип int. Вот пример, где происходит объявление и определение (присваивание значений) целочисленных переменных, а также вывод их значений на экран:

#include <stdio.h>
int main() {
    int lines, i;
    int count = ;

    lines = 100;
    i = -1;
    printf("%5d %5d %5d\n", i, count+10, lines);
}

Обратите внимание, что в языке C присваивать значение можно при объявлении переменных. Обычно под переменную типа int, которая может принимать как положительные так и отрицательные значения, отводится 4 байта, что равно 32-м битам

Отсюда допустимый диапазон значений будет лежать в пределах от -2 147 483 648 до 2 147 483 647. Если в исходном коде на C мы объявим переменную int max, присвоим ей максимально допустимое значение, а потом будем его увеличивать, то сообщений об ошибке не будет ни на этапе компиляции, ни на этапе выполнения

Обычно под переменную типа int, которая может принимать как положительные так и отрицательные значения, отводится 4 байта, что равно 32-м битам. Отсюда допустимый диапазон значений будет лежать в пределах от -2 147 483 648 до 2 147 483 647. Если в исходном коде на C мы объявим переменную int max, присвоим ей максимально допустимое значение, а потом будем его увеличивать, то сообщений об ошибке не будет ни на этапе компиляции, ни на этапе выполнения.

#include <stdio.h>

int main() {
    int max = 2147483647;

    printf("%d\n", max+1);
    printf("%d\n", max+2);
    printf("%d\n", max+10);
}

Результат будет таким:

-2147483648
-2147483647
-2147483639

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

То же самое с минимумом int. Если мы начнем из него вычитать, т. е. двигаться против часовой стрелки, то перескочим максимальную границу и будем идти в направлении уменьшения уже от нее:

#include <stdio.h>

int main() {
    int min = -2147483648;

    printf("%d\n", min-1);
    printf("%d\n", min-2);
    printf("%d\n", min-10);
}

Результат:

2147483647
2147483646
2147483638

Помимо типа int в языке программирования C существуют другие (модифицированные) целочисленные типы:

• short — отводится меньше байтов, чем на int;

• long — отводится больше байтов, чем на int (не всегда, зависит от системы);

• unsigned — столько же байт как у int, но без отрицательных чисел; в результате чего знаковый разряд освобождается, и количество положительных значений увеличивается;

• unsigned short;

• unsigned long.

При выводе длинных чисел следует дополнять спецификацию формата буквой l перед буквой формата. Например:

printf("%ld\n", i);
printf("%15ld\n", i);

Моя критика

Если вкратце, то знание и постоянное использование всех этих правил сильно нагружает мышление. Допущение же ошибки в их применении приводит к риску написания неверного или непортируемого кода. При этом такие ошибки могут как всплыть сразу, так и таиться в течение дней или даже долгих лет.
Сложности начинаются с битовой ширины базовых целочисленных типов, которая зависит от реализации. Например, может иметь 16, 32, 64 бита или другое их количество. Всегда нужно выбирать тип с достаточным диапазоном. Но иногда использование слишком обширного типа (например, необычного 128-битного ) может вызвать сложности или даже внести уязвимости. Усугубляется это тем, что такие типы из стандартных библиотек, как , не имеют связи с другими типами вроде беззнакового или ; стандарт позволяет им быть шире или уже.
Правила преобразования совершенно безумны. Что еще хуже, практически везде допускаются неявные преобразования, существенно затрудняющие аудит человеком. Беззнаковые типы достаточно просты, но знаковые имеют очень много допустимых реализаций (например, обратный код, создание исключений). Типы с меньшим рангом, чем , продвигаются автоматически, вызывая труднопонимаемое поведение с диапазонами и переполнение. Когда операнды отличаются знаковостью и рангами, они преобразуются в общий тип способом, который зависит от определяемой реализацией битовой ширины. Например, выполнение арифметики над двумя операндами, как минимум один из которых имеет беззнаковый тип, приведет к преобразованию их обоих либо в знаковый, либо в беззнаковый тип в зависимости от реализации.
Арифметические операции изобилуют неопределенным поведением: знаковое переполнение в , деление на нуль, битовые сдвиги. Несложно создать такие условия неопределенного поведения по случайности, но сложно вызвать их намеренно или обнаружить при выполнении, равно как выявить их причины. Необходима повышенная внимательность и усилия для проектирования и реализации арифметического кода, исключающего переполнение/UB. Стоит учитывать, что впоследствии становится сложно отследить и исправить код, при написании которого не соблюдались принципы защиты от переполнения/UB.
Присутствие и версии каждого целочисленного типа удваивает количество доступных вариантов. Это создает дополнительную умственную нагрузку, которая не особо оправдывается, так как типы со знаком способны выполнять практически все те же функции, что и беззнаковые.
Ни в одном другом передовом языке программирования нет такого числа правил и подводных камней касательно целочисленных типов, как в С и C++. Например:В Java целые числа ведут себя одинаково в любой среде. В этом языке определено конкретно 5 целочисленных типов (в отличие от C/C++, где их не менее 10). Они имеют фиксированную битовую ширину, практически все из них имеют знаки (кроме ), числа со знаком должны находиться в дополнительном коде, неявные преобразования допускают только их варианты без потерь, а вся арифметика и преобразования определяются точно и не вызывают неоднозначного поведения. Целочисленные типы в Java поддерживают быстрое вычисление и эффективное упаковывание массивов в сравнении с языками вроде Python, где есть только переменного размера.
Java в значительной степени опирается на 32-битный тип , особенно для перебора массивов. Это означает, что этот язык не может эффективно работать на малопроизводительных 16-битных ЦПУ (часто используемых во встраиваемых микроконтроллерах), а также не может непосредственно работать с большими массивами в 64-битных системах

К сравнению, C/C++ позволяет писать код, эффективно работающий на 16, 32 и/или 64-битных ЦПУ, но при этом требует от программиста особой осторожности.
В Python есть всего один целочисленный тип, а именно. В сравнении с C/C++ это сводит на нет все рассуждения на тему битовой ширины, знаковости и преобразований, так как во всем коде правит один тип

Тем не менее за это приходится платить низкой скоростью выполнения и несогласованным потреблением памяти.
В JavaScript вообще нет целочисленного типа. Вместо этого в нем все выражается через математику (в C/C++). Из-за этого битовая ширина и числовой диапазон оказываются фиксированными, числа всегда имеют знаки, преобразования отсутствуют, а переполнение считается нормальным.
Язык ассемблера для любой конкретной машинной архитектуры (x86, MIPS и т.д.) определяет набор целочисленных типов фиксированной ширины, арифметические операции и преобразования – с редкими случаями неопределенного поведения или вообще без них.

Типизация

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

Статическая типизация является противоположностью динамической. При объявлении переменная получает тип, который не меняется в дальнейшем. Языки Си и Си++ являются именно такими. Этот способ наиболее удобный для написания сложного кода, а на стадии компиляции исключается много ошибок.

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

Пример слабой типизации.

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

Общие понятия

Типом данных в программировании называют совокупность двух множеств: множество значений и множество операций, которые можно применять к ним. Например, к типу данных целых неотрицательных чисел, состоящего из конечного множества натуральных чисел, можно применить операции сложения (+), умножения (*), целочисленного деления (/), нахождения остатка (%) и вычитания (−).

Язык программирования, как правило, имеет набор примитивных типов данных — типы, предоставляемые языком программирования как базовая встроенная единица. В C++ такие типы создатель языка называет фундаментальными типами. Фундаментальными типами в C++ считаются:

• логический ();
• символьный (напр., );
• целый (напр., );
• с плавающей точкой (напр., );
• перечисления (определяется программистом);
• .

Поверх перечисленных строятся следующие типы:

• указательные (напр., );
• массивы (напр., );
• ссылочные (напр., );
• другие структуры.

Перейдём к понятию литерала (напр., 1, 2.4F, 25e-4, ‘a’ и др.): литерал — запись в исходном коде программы, представляющаясобой фиксированное значение. Другими словами, литерал — это просто отображение объекта (значение) какого-либо типа в коде программы. В C++ есть возможность записи целочисленных значений, значений с плавающей точкой, символьных, булевых, строковых.

Литерал целого типа можно записать в:

• 10-й системе счисления. Например, ;
• 8-й системе счисления в формате 0 + число. Например, ;
• 16-й системе счисления в формате 0x + число. Например, .

24, 030, 0x18 — это всё записи одного и того же числа в разных системах счисления.
Для записи чисел с плавающей точкой используют запись через точку: 0.1, .5, 4. — либо в
экспоненциальной записи — 25e-100. Пробелов в такой записи быть не должно.

Имя, с которым мы можем связать записанные литералами значения, называют переменной. Переменная — это поименованная либо адресуемая иным способом область памяти, адрес которой можно использовать для доступа к данным. Эти данные записываются, переписываются и стираются в памяти определённым образом во время выполнения программы. Переменная позволяет в любой момент времени получить доступ к данным и при необходимости изменить их. Данные, которые можно получить по имени переменной, называют значением переменной.
Для того, чтобы использовать в программе переменную, её обязательно нужно объявить, а при необходимости можно определить (= инициализировать). Объявление переменной в тексте программы обязательно содержит 2 части: базовый тип и декларатор. Спецификатор и инициализатор являются необязательными частями:

const int example = 3;
// здесь const — спецификатор
// int — базовый тип
// example — имя переменной
// = 3 — инициализатор.

Имя переменной является последовательностью символов из букв латинского алфавита (строчных и прописных), цифр и/или знака подчёркивания, однако первый символ цифрой быть не может. Имя переменной следует выбирать таким, чтобы всегда было легко догадаться о том, что она хранит, например, «monthPayment». В конспекте и на практиках мы будем использовать для правил записи переменных нотацию CamelCase. Имя переменной не может совпадать с зарезервированными в языке словами, примеры таких слов: if, while, function, goto, switch и др.

Декларатор кроме имени переменной может содержать дополнительные символы:

• — указатель; перед именем;
• — константный указатель; перед именем;
• — ссылка; перед именем;
• — массив; после имени;
• — функция; после имени.

Инициализатор позволяет определить для переменной её значение сразу после объявления. Инициализатор начинается с литерала равенства (=) и далее происходит процесс задания значения переменной. Вообще говоря, знак равенства в C++ обозначает операцию присваивания; с её помощью можно задавать и изменять значение переменной. Для разных типов он может быть разным.

Спецификатор задаёт дополнительные атрибуты, отличные от типа. Приведённый в примере спецификатор const позволяет запретить последующее изменение значение переменной. Такие неизменяемые переменные называют константными или константой.

Объявить константу без инициализации не получится по логичным причинам:

const int EMPTY_CONST; // ошибка, не инициализована константная переменная
const int EXAMPLE = 2; // константа со значением 2
EXAMPLE = 3; // ошибка, попытка присвоить значение константной переменной

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

Диапазоны значений и знак целочисленных типов данных

Как вы уже знаете из предыдущего урока, переменная с n-ным количеством бит может хранить 2n возможных значений. Но что это за значения? Это значения, которые находятся в диапазоне. Диапазон — это значения от и до, которые может хранить определенный тип данных. Диапазон целочисленной переменной определяется двумя факторами: её размером (измеряется в битах) и её знаком (который может быть signed или unsigned).

Целочисленный тип signed (со знаком) означает, что переменная может содержать как положительные, так и отрицательные числа. Чтобы объявить переменную как signed, используйте ключевое слово :

signed char c;
signed short s;
signed int i;
signed long l;
signed long long ll;

1 2 3 4 5

signedcharc; signedshorts; signedinti; signedlongl; signedlonglongll;

По умолчанию, ключевое слово пишется перед типом данных.

1-байтовая целочисленная переменная со знаком (signed) имеет диапазон значений от -128 до 127, т.е. любое значение от -128 до 127 (включительно) может храниться в ней безопасно.

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

Целочисленный тип unsigned (без знака) может содержать только положительные числа. Чтобы объявить переменную как unsigned, используйте ключевое слово :

unsigned char c;
unsigned short s;
unsigned int i;
unsigned long l;
unsigned long long ll;

1 2 3 4 5

unsignedcharc; unsignedshorts; unsignedinti; unsignedlongl; unsignedlonglongll;

1-байтовая целочисленная переменная без знака (unsigned) имеет диапазон значений от 0 до 255.

Обратите внимание, объявление переменной как unsigned означает, что она не сможет содержать отрицательные числа (только положительные). Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:

Теперь, когда вы поняли разницу между signed и unsigned, давайте рассмотрим диапазоны значений разных типов данных:

Размер/Тип	Диапазон значений
1 байт signed	от -128 до 127
1 байт unsigned	от 0 до 255
2 байта signed	от -32 768 до 32 767
2 байта unsigned	от 0 до 65 535
4 байта signed	от -2 147 483 648 до 2 147 483 647
4 байта unsigned	от 0 до 4 294 967 295
8 байтов signed	от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807
8 байтов unsigned	от 0 до 18 446 744 073 709 551 615

Для математиков: Переменная signed с n-ным количеством бит имеет диапазон от -(2n-1) до 2n-1-1. Переменная unsigned с n-ным количеством бит имеет диапазон от 0 до (2n)-1.

Для нематематиков: Используем таблицу

Начинающие программисты иногда путаются между signed и unsigned переменными. Но есть простой способ запомнить их различия. Чем отличается отрицательное число от положительного? Правильно! Минусом спереди. Если минуса нет, значит число — положительное. Следовательно, целочисленный тип со знаком (signed) означает, что минус может присутствовать, т.е. числа могут быть как положительными, так и отрицательными. Целочисленный тип без знака (unsigned) означает, что минус спереди отсутствует, т.е. числа могут быть только положительными.

Переполнение переменных

Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы «сбросим значение»

#include <conio.h>
#include <stdio.h>

void main() {
	unsigned a = 4294967295;
	int b = 2147483647;
	//Переполнение беззнакового типа
	printf("%u\n", a);
	a += 1;
	printf("%u", a);
	//Переполнение знакового типа
	printf("%d\n", b);
	b += 1;
	printf("%d", b);
	getch();
}

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

Список примитивных типов

В Java есть 8 базовых примитивных типов. Примитивными их называют потому, что значения этих типов не являются объектами и хранятся прямо внутри переменных.

Вот таблица, которая содержит краткую информацию по этим типам:

Тип	Размер, байт	Диапазон значений	Значение по умолчанию	Описание
	1	-128 .. 127	Самое маленькое целое — один байт
	2	-32,768 .. 32,767	Короткое целое, два байта
	4	-2*109 .. 2*109	Целое число, 4 байта
	8	-9*1018 .. 9*1018		Длинное целое, 8 байт
	4	-1038 .. 1038		Дробное, 4 байта
	8	-10308 .. 10308		Дробное, двойной длины, 8 байт
	1	,		Логический тип (только & )
	2	0 .. 65,535		Символы, 2 байта, все больше 0

Значение по умолчанию

Кстати, важный нюанс. Если вы объявили переменную-класса (поле класса) или статическую переменную-класса, и не присвоили ей никакого значения, она инициализируется значением по умолчанию. Список таких значений приведен в таблице.

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

Но давайте вернемся к примитивным типам и рассмотрим их подробнее

Битовые поля

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

 
тип имя: КоличествоБит

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

1234567891011121314151617181920212223

#define _CRT_SECURE_NO_WARNINGS#include <stdio.h>#include <stdlib.h>#define YEAR0 1980struct date{  unsigned short day : 5;  unsigned short month : 4;  unsigned short year : 7;};int main() {  struct date today;  system(«chcp 1251»);  system(«cls»);  today.day = 16;  today.month = 12;  today.year = 2013 — YEAR0; //today.year = 33  printf(«\n Сегодня %u.%u.%u \n», today.day, today.month, today.year + YEAR0);  printf(«\n Размер структуры today : %d байт», sizeof(today));  printf(«\n Значение элемента today = %hu = %hx шестн.», today, today);  getchar();  return 0;}

Форматированный ввод

Рассмотрим форматированный ввод функцией scanf.
Функция принимает строку формата ввода (она похожа на строку формата printf) и адреса, по которым необходимо записать считанные данные. Возвращает
количество успешно проинициализированных аргументов.
Формат спецификатора ввода

Как и в printf, ширина, заданная символом * ожидает аргумента, который будт задавать ширину. Флаг длина совпадает с таким флагом функции printf.

Примеры

#include <stdio.h>
#include <conio.h>

void main() {
	int year, month, day;
	char buffer;
	int count;
	//Требует форматированного ввода, например 2013:12:12
	printf("Enter data like x:x:x = ");
	scanf("%d:%d:%d", &year, &month, &day);
	printf("year = %d\nmonth = %d, day = %d\n", year, month, day);
	//Считываем строку, не более 127 символов. При считывании в массив писать & не надо,
	//так как массив подменяется указателем
	printf("Enter string = ");
	scanf("%127s", buffer);
	printf("%s", buffer);
	getch();
}

Кроме функций scanf и printf есть ещё ряд функций, которые позволяют получать вводимые данные

int getch()

#include <stdio.h>
#include <conio.h>

void main() {
	char c = 0;
	do {
		c = getch();
		printf("%c", c);
	} while (c != 'q');
}

char * fgets ( char * str, int num, FILE * stream ) — функция позволяет считывать строку с пробельными символами.
Несмотря на то, что она работает с файлом, можно с её помощью считывать и из стандартного потока ввода. Её преимущество относительно gets в
том, что она позволяет указать максимальный размер считываемой строки и заканчивает строку терминальным символом.

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

void main() {
	char buffer;
	//Считываем из стандартного потока ввода
	fgets(buffer, 127, stdin);
	printf("%s", buffer);
	//Этим можно заменить ожидание ввода символа
	scanf("1");
}

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

Характеристики целочисленных типовCharacteristics of the integral types

C# поддерживает следующие предварительно определенные целочисленные типы:C# supports the following predefined integral types:

Ключевое слово или тип C#C# type/keyword	ДиапазонRange	РазмерSize	Тип .NET.NET type
	От -128 до 127-128 to 127	8-разрядное целое число со знакомSigned 8-bit integer	System.SByte
	От 0 до 2550 to 255	8-разрядное целое число без знакаUnsigned 8-bit integer	System.Byte
	От -32 768 до 32 767-32,768 to 32,767	16-разрядное целое число со знакомSigned 16-bit integer	System.Int16
	От 0 до 65 5350 to 65,535	16-разрядное целое число без знакаUnsigned 16-bit integer	System.UInt16
	От -2 147 483 648 до 2 147 483 647-2,147,483,648 to 2,147,483,647	32-разрядное целое число со знакомSigned 32-bit integer	System.Int32
	От 0 до 4 294 967 2950 to 4,294,967,295	32-разрядное целое число без знакаUnsigned 32-bit integer	System.UInt32
	От -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807	64-разрядное целое число со знакомSigned 64-bit integer	System.Int64
	От 0 до 18 446 744 073 709 551 6150 to 18,446,744,073,709,551,615	64-разрядное целое число без знакаUnsigned 64-bit integer	System.UInt64
	Зависит от платформыDepends on platform	32- или 64-разрядное целое число со знакомSigned 32-bit or 64-bit integer	System.IntPtr
	Зависит от платформыDepends on platform	32- или 64-разрядное целое число без знакаUnsigned 32-bit or 64-bit integer	System.UIntPtr

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

Типы и в последних двух строках таблицы являются целыми числами собственного размера.The and types in the last two rows of the table are native-sized integers. В коде такие числа представлены определенными типами .NET, но в каждом случае ключевое слово и тип .NET не взаимозаменяемы.They are represented internally by the indicated .NET types, but in each case the keyword and the .NET type are not interchangeable. Для и компилятор предоставляет преобразования и операции, как для целочисленных типов. Они отличаются от преобразований и операций для типов указателей и .The compiler provides operations and conversions for and as integer types that it doesn’t provide for the pointer types and . Дополнительные сведения см. в статье о типах и .For more information, see and types.

Дополнительные сведения о целочисленных типах собственного размера см. в статье о и .For information about the native-sized integer types, see and .

По умолчанию все целочисленные типы имеют значение .The default value of each integral type is zero, . Все целочисленные типы, кроме целых чисел собственного размера, имеют константы и с минимальным и максимальным значением этого типа.Each of the integral types except the native-sized types has and constants that provide the minimum and maximum value of that type.

Используйте структуру System.Numerics.BigInteger, чтобы представить целое число со знаком без верхней и нижней границ.Use the System.Numerics.BigInteger structure to represent a signed integer with no upper or lower bounds.

Float ranges and precision

In order to find the value ranges of the floating-point number in your platform, you can use the header file. This header file defines macros such as  and that store the float value ranges and precision of the  type.

You can also find the corresponding macros for and with the prefixes  and

The following program illustrates the storage size and precision of floating-point numbers in your system.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

/* * File   : main.c * Author : zentut.com * Purpose: C float demo */   #include <stdio.h> #include <float.h>   intmain() { printf(«Storage size: %d bytes\n» «Minimum float value: %E\n» «Maximum float value: %E\n» «Precision: %d decimal digits\n», sizeof(float), FLT_MIN, FLT_MAX, FLT_DIG); puts(«\nExample of float precision:\n»); doubled=12345.6; floatf=(float)d; printf(«The floating-point number d  « «%18.10f\n»,d); printf(«Stored in a variable f\n» «of type float as the value   « «%18.10f\n»,f); return; }

The output of the program in our system is as follows:

1 2 3 4 5 6 7 8 9 10

Storage size4bytes Minimum floatvalue1.175494E-038 Maximum floatvalue3.402823E+038 Precision6decimal digits Example of floatprecision The floating-point numberd12345.6000000000 Stored inavariablef of type floatasthe value12345.5996093750

In this tutorial, we have introduced you various C float types and explained what precision means to each type of float in C.

• Was this tutorial helpful ?

Инициализация полей структуры

Инициализация полей структуры может осуществляться двумя способами:

• присвоение значений элементам структуры в процессе объявления переменной, относящейся к типу структуры;
• присвоение начальных значений элементам структуры с использованием функций ввода-вывода (например, 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 .