Int в с: C# и .NET | Типы данных

Справочник по C#. Целочисленные типы



  • Чтение занимает 2 мин

В этой статье

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

Характеристики целочисленных типов

C# поддерживает следующие предварительно определенные целочисленные типы:

Ключевое слово или тип C#ДиапазонРазмерТип .NET
sbyteОт -128 до 1278-разрядное целое число со знакомSystem. SByte
byteОт 0 до 2558-разрядное целое число без знакаSystem.Byte
shortОт -32 768 до 32 76716-разрядное целое число со знакомSystem.Int16
ushortОт 0 до 65 53516-разрядное целое число без знакаSystem.UInt16
intОт -2 147 483 648 до 2 147 483 64732-разрядное целое число со знакомSystem.Int32
uintОт 0 до 4 294 967 29532-разрядное целое число без знакаSystem.UInt32
longОт -9 223 372 036 854 775 808 до 9 223 372 036 854 775 80764-разрядное целое число со знакомSystem.Int64
ulongОт 0 до 18 446 744 073 709 551 61564-разрядное целое число без знакаSystem.UInt64
nintЗависит от платформы32- или 64-разрядное целое число со знакомSystem. IntPtr
nuintЗависит от платформы32- или 64-разрядное целое число без знакаSystem.UIntPtr

Во всех строках таблицы, кроме двух последних, каждое ключевое слово типа C# из крайнего левого столбца является псевдонимом для соответствующего типа .NET. Ключевое слово и имя типа .NET являются взаимозаменяемыми. Например, следующие объявления объявляют переменные одного типа:

int a = 123;
System.Int32 b = 123;

Типы nint и nuint в последних двух строках таблицы являются целыми числами собственного размера. В коде такие числа представлены определенными типами .NET, но в каждом случае ключевое слово и тип .NET не взаимозаменяемы. Для nint и nuint компилятор предоставляет преобразования и операции, как для целочисленных типов. Они отличаются от преобразований и операций для типов указателей System.IntPtr и System. UIntPtr. Дополнительные сведения см. в статье о типах nint и nuint.

По умолчанию все целочисленные типы имеют значение 0. Все целочисленные типы, кроме целых чисел собственного размера, имеют константы MinValue и MaxValue с минимальным и максимальным значением этого типа.

Используйте структуру System.Numerics.BigInteger, чтобы представить целое число со знаком без верхней и нижней границ.

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

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

  • десятичным числом: без префикса;
  • шестнадцатеричным числом: с префиксом 0x или 0X;
  • двоичными: с префиксом 0b или 0B (доступно в C# 7.0 и более поздних версиях).

В приведенном ниже коде показан пример каждого из них.

var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;

В предыдущем примере также показано использование _ в качестве цифрового разделителя, который поддерживается, начиная с версии C# 7. 0. Цифровой разделитель можно использовать со всеми видами числовых литералов.

Тип целочисленного литерала определяется его суффиксом следующим образом:

  • Если литерал не имеет суффикса, его типом будет первый из следующих типов, в котором может быть представлено его значение: int, uint, long, ulong.

    Примечание

    Литералы интерпретируется как положительные значения. Например, литерал 0xFF_FF_FF_FF представляет число 4294967295 типа uint, хотя он имеет то же битовое представление, что и число -1 типа int. Если вам требуется значение определенного типа, приведите литерал к этому типу. Используйте оператор unchecked, если представить значение литерала в целевом типе невозможно. Например, unchecked((int)0xFF_FF_FF_FF) выдает -1.

  • Если у литерала есть суффикс U или u, его типом будет первый из следующих типов, в котором может быть представлено его значение: uint, ulong.

  • Если у литерала есть суффикс L или l, его типом будет первый из следующих типов, в котором может быть представлено его значение: long, ulong.

    Примечание

    Строчную букву l можно использовать в качестве суффикса. Однако при этом выдается предупреждение компилятора, так как букву l можно перепутать с цифрой 1. Для ясности используйте L.

  • Если у литерала есть суффикс UL, Ul, uL, ul, LU, Lu, lU или lu, его тип — ulong.

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, происходит ошибка компиляции CS1021.

Если определенный тип целочисленного литерала — int, а значение, представленное литералом, находится в диапазоне целевого типа, значение можно неявно преобразовать в sbyte, byte, short, ushort, uint, ulong, nint или nuint:

byte a = 17;
byte b = 300;   // CS0031: Constant value '300' cannot be converted to a 'byte'

Как показано в предыдущем примере, если значение литерала выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031.

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

var signedByte = (sbyte)42;
var longVariable = (long)42;

Преобразования

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

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

См. также

Есть ли типы больше, чем long long int в C++?

Есть ли типы больше, чем long long int в C++?

Мой компилятор — g++.

c++

types

Поделиться

Источник


Michael    

21 марта 2011 в 18:22

9 ответов

  • В чем разница между «long», «long long», «long int», and «long long int» в C++?

    Я перехожу с Java на C++, и у меня есть некоторые вопросы о типе данных long . В Java, чтобы удержать целое число больше 2 32 , вы просто напишете long x; . Однако в C++ кажется, что long — это и тип данных, и модификатор. Кажется, есть несколько способов использовать long : long x; long long x;…

  • Больше чем Unsigned Long Long

    Я работаю над приложением iOS Objective C, в котором вы накапливаете большое количество богатства. К концу приложения количество денег, которые пользователи могут накопить, больше, чем может справиться длинный длинный. Какой тип данных я должен использовать вместо этого? Я знаю, что мог бы…

Поделиться


Jon    

21 марта 2011 в 18:24


9

__int128

__uint128

​​​​​ ​​​​​​​​​​​​​​​

Поделиться


KitsuneYMG    

21 марта 2011 в 18:24


9

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

Поделиться


jho    

21 марта 2011 в 18:24

  • значение смещения больше long int в fseek

    мы знаем, что параметры fseek таковы : int fseek(FILE *stream, long int offset, int whence) я хочу использовать его со значением смещения больше, чем long int, каково решение и есть ли какие-либо другие функции для замены fseek ? Значение равно (512 * 29358080)

  • Является ли «long long» = «long long int» = «long int long» = «int long long»?

    Я обнаружил, что и long int long , и int long long могут компилироваться для типа переменной. Есть ли разница между long int long , int long long , long long и long long int ? В общем, является ли тип идентичным, если он имеет одинаковое число long ? 1 длинный : long l; int long il; long int li; 2…


9

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

#include <cstdint>

struct uint256_t
{
    std::uint64_t bits[4];
};

uint256_t x;

Поделиться


J T    

21 марта 2011 в 18:58


7

Стандарты

Расширенные целочисленные типы явно разрешены стандартами C и C++.

C++11

C++11 N3337 проект 3.9.1 «Fundamental types» пункт 3 гласит::

Существует пять стандартных типов целых подпись : “подпись Чара”, “короткий интервал”, “int”, “долгий интервал”, и “долгий интервал”. В этом списке каждый тип обеспечивает по крайней мере столько же памяти, сколько и предыдущие в списке. Также могут существовать определенные реализацией расширенные целочисленные типы со знаком. Стандартные и расширенные целочисленные типы со знаком в совокупности называются целочисленными типами со знаком. Простые int имеют естественный размер, предложенный архитектурой среды выполнения, другие целочисленные типы со знаком предоставляются для удовлетворения особых потребностей.

Вы также должны рассмотреть intmax_t, который 18.4.1 «Header synopsis» пункт 2 говорит:

Заголовок определяет все функции, типы и macros так же, как и 7.18 в стандарте C.

С99

Проект C99 N1256 прямо допускает их в пункте 4 6. 2.5 «Types»:

Есть пять стандартных знаковое целое число типов, места также подписал чар, на короткое инт, инт, инт долго, долго и Инт. (Эти и другие типы могут быть
обозначены несколькими дополнительными способами, как описано в 6.7.2.) Также может быть определено реализацией расширенное целое число со знаком types.28) Стандартные и расширенные целочисленные типы со знаком совместно называются целочисленными типами со знаком types.29)

и 7.18.1.5 «Greatest-width integer types» пункт 1 гласит::

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

intmax_t

Поделиться


Ciro Santilli 郝海东冠状病六四事件法轮功    

19 мая 2015 в 10:01


4

Подведение…

Если вам нужно хранить точные целочисленные значения, которые не поместятся в ‘long long’, gcc предлагает тип _ _ int128 . Это расширение gcc, а не часть стандарта C++ (на момент написания этой статьи).

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

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

И конечно, если вы просто хотите занять больше памяти, объявите массив 😉

Поделиться


Spike0xff    

23 января 2013 в 15:06


1

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

int myNum; // Range is from –2,147,483,648 to 2,147,483,647

unsigned int myNum; // Range is from 0 to 4,294,967,295

Поделиться


Gunner Stone    

01 марта 2017 в 10:32

Поделиться


TCS    

21 марта 2011 в 18:29


0

Вы можете использовать

#include <boost/multiprecision/cpp_int. hpp>  
using namespace boost::multiprecision;

для работы с типом данных больше long long int и типом данных cpp_int Ref

Поделиться


Kapil    

19 ноября 2019 в 02:40

Похожие вопросы:

В чем разница между long long и long int

Я знаю разницу между long и int Но в чем разница между long long и long int

‘long long int’ интерпретируется как ‘long int’. Как мне обойти это?

Я работаю над проектом, связанным с программированием c для моего курса математики в университете. Мне нужно уметь обрабатывать большие целые числа, большие, чем те, которые могут быть сохранены в…

Является ли int быстрее, чем long?

Значения a и b имеют одинаковый выход: int a = 0xEFEFEFEF; long b = 0xEFEFEFEF; cout << a << endl << b << endl; Я слышал, что тип long имеет больше времени обработки для. ..

В чем разница между «long», «long long», «long int», and «long long int» в C++?

Я перехожу с Java на C++, и у меня есть некоторые вопросы о типе данных long . В Java, чтобы удержать целое число больше 2 32 , вы просто напишете long x; . Однако в C++ кажется, что long — это и…

Больше чем Unsigned Long Long

Я работаю над приложением iOS Objective C, в котором вы накапливаете большое количество богатства. К концу приложения количество денег, которые пользователи могут накопить, больше, чем может…

значение смещения больше long int в fseek

мы знаем, что параметры fseek таковы : int fseek(FILE *stream, long int offset, int whence) я хочу использовать его со значением смещения больше, чем long int, каково решение и есть ли какие-либо…

Является ли «long long» = «long long int» = «long int long» = «int long long»?

Я обнаружил, что и long int long , и int long long могут компилироваться для типа переменной. Есть ли разница между long int long , int long long , long long и long long int ? В общем, является ли…

Недопустимые типы ‘long int[long int]’ для индекса массива

В настоящее время я пишу двоично-десятичный конвертер и застреваю на нескольких ошибках. Мне нужна помощь, чтобы починить их. Ошибка 1: assignment 1.c:10:23: error: invalid types ‘long int[long…

long long to int и int to long long преобразование

Интересно, нравится ли конверсия: int to long int to long long long to int long long to int long long to long long to long long и long double to double double to long double (и аналогично для…

Есть ли что-нибудь длиннее, чем unsigned long long int в C?

Я использую unsigned long long int для хранения количества символов в файле. И я боюсь, что его диапазон скоро будет обойден. Является ли therr другим типом данных, который может содержать значения…

Преобразование типов при присваивании | Программирование на C и C++

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

int х;
char ch;
float f;

void func(void)
{
ch = х; /*    1    */
х = f;    /*    2    */
f = ch;  /*    3    */
f = x;    /*    4    */
}

В строке 1 левые, старшие, биты целочисленной переменной х обрубаются, оставляя в ch младшие 8 битов. Если х содержит число между 256 и 0, то ch и х будут иметь одинаковое значение Иначе значение ch будет содержать только младший набор битов переменной х. В строке 2 х получает целую часть переменной f. В строке 3 f получает 8-битное целое число, хранящееся в ch преобразованное к формату с плавающей точкой. В строке 4 f получает значение целочисленной переменной х, преобразованное к формату с плавающей точкой.

Когда происходит преобразование из целого числа к символу, из длинного целого — к целому и из целого — к короткому целому, то старшие биты будут потеряны. Когда используется 16-битное целое, это означает, что 8 бит будут потеряны при преобразовании от целого к символу и 16 бит будут потеряны при преобразовании от длинного целого к целому.

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

Таблица: Обычные результаты преобразования типов
Целевой тип Исходный тип Возможные потери информации
signed char unsigned char Если значение > 127, то результат станет отрицательным числом
char short int Старшие 8 бит
char int (16 бит) Старшие 8 бит
char int (32 бита) Старшие 24 бита
short int int (16 бит) Нет
short int int (32 бита) Старшие 16 бит
int (16 бит) long int Старшие 16 бит
int (32 бита) long int Нет
float double Точность, результат округляется
double long double Точность, результат округляется

  1.  Преобразование из int в float или из float в double и тому подобное не добавляет точности. Такого рода преобразования только изменяют формат представления значения.
  2. Некоторые компиляторы С (и процессоры) всегда трактуют переменные типа char как положительные, независимо от того, какое значение было при преобразовании к целому или плавающему типам. Другие компиляторы могут трактовать переменную типа char как знаковую, где числа, большие, чем 127, трактуются как отрицательные (как делает Borland С++). В целом следует использовать переменные типа char для символов, a int, short int или signed char когда необходимо избежать проблем с переносимостью.

Для получения преобразования, не указанного в таблице, надо просто пошагово преобразовывать типы, пока не получится нужный тип. Например, для преобразования из double в int сначала следует преобразовать double в float, а затем float в int.

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

В Чем Разница Между Int И Long На С++?

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

Большинство поставщиков компиляторов предоставляют файл заголовка, который определяет примитивные типы с
вывести размеры типоразмеров.
Эти примитивные типы должны использоваться, когда когда-либо код может быть потенциально перенесен
другому компилятору (читайте это как ВСЕГДА в КАЖДОМ примере).
Например, большинство компиляторов UNIX имеют int8_t uint8_t int16_t int32_t uint32_t.
Microsoft имеет INT8 UINT8 INT16 UINT16 INT32 UINT32.
Я предпочитаю Borland/CodeGear INT8 UINT8 INT16 UINT16 INT32 UINT32.
Эти имена также дают небольшое напоминание о размере/диапазоне предполагаемого значения.

В течение многих лет я использовал явные примитивные имена Borland
и #include следующий заголовочный файл C/С++ (primitive.h)
который предназначен для определения явных примитивных типов с этими именами для любого компилятора C/С++
(этот заголовочный файл, возможно, не распространяется на каждый компилятор, но он охватывает несколько компиляторов, которые я использовал в Windows, UNIX и Linux, но еще не определяет 64-битные типы).

#ifndef primitiveH
#define primitiveH
// Header file primitive.h
// Primitive types
// For C and/or C++
// This header file is intended to define a set of primitive types
// that will always be the same number bytes on any operating operating systems
// and/or for several popular C/C++ compiler vendors.
// Currently the type definitions cover:
// Windows (16 or 32 bit)
// Linux
// UNIX (HP/US, Solaris)
// And the following compiler vendors
// Microsoft, Borland/Imprise/CodeGear, SunStudio,  HP/UX
// (maybe GNU C/C++)
// This does not currently include 64bit primitives. 
#define float64 double
#define float32 float
// Some old C++ compilers didn't have bool type
// If your compiler does not have bool then add   emulate_bool
// to your command line -D option or defined macros.
#ifdef emulate_bool
#   ifdef TVISION
#     define bool int
#     define true 1
#     define false 0
#   else
#     ifdef __BCPLUSPLUS__
//BC++ bool type not available until 5.0
#        define BI_NO_BOOL
#        include <classlib/defs.h>
#     else
#        define bool int
#        define true 1
#        define false 0
#     endif
#  endif
#endif
#ifdef __BCPLUSPLUS__
#  include <systypes.h>
#else
#  ifdef unix
#     ifdef hpux
#        include <sys/_inttypes.h>
#     endif
#     ifdef sun
#        include <sys/int_types.h>
#     endif
#     ifdef linux
#        include <idna.h>
#     endif
#     define int8 int8_t
#     define uint8 uint8_t
#     define int16 int16_t
#     define int32 int32_t
#     define uint16 uint16_t
#     define uint32 uint32_t
#  else
#     ifdef  _MSC_VER
#        include <BaseTSD. h>
#        define int8 INT8
#        define uint8 UINT8
#        define int16 INT16
#        define int32 INT32
#        define uint16 UINT16
#        define uint32 UINT32
#     else
#        ifndef OWL6
//          OWL version 6 already defines these types
#           define int8 char
#           define uint8 unsigned char
#           ifdef __WIN32_
#              define int16 short int
#              define int32 long
#              define uint16 unsigned short int
#              define uint32 unsigned long
#           else
#              define int16 int
#              define int32 long
#              define uint16 unsigned int
#              define uint32 unsigned long
#           endif
#        endif
#      endif
#  endif
#endif
typedef int8   sint8;
typedef int16  sint16;
typedef int32  sint32;
typedef uint8  nat8;
typedef uint16 nat16;
typedef uint32 nat32;
typedef const char * cASCIIz;    // constant null terminated char array
typedef char *       ASCIIz;     // null terminated char array
#endif
//primitive. h

Типы byte, short, int, long — Java программирование

Целочисленные числа представлены в языке Java четырьмя типами — byte, short, int и long.

int — основной целочисленный тип, используемый в Java по умолчанию. Любое целое число будет рассматриваться компилятором как число типа int. Используется в качестве счётчика циклов, индексов массивов и индексов символов в строках.

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

byte — используется для передачи данных по сети, записи и чтения из файла. В математических операциях, как правило, не используется.

short — самый редко используемый тип в Java, может использоваться только в целях экономии памяти.






ТипРазмер в байтахРазмер в битахВозможные значения (от..до)Значение по умолчанию
byte1 8 -128..1270
short2 16 -32,768..32,7670
int432 -2,147,483,648..2,147,483,6470
long864-9,223,372,036,854,775,808..9,223,372,036,854,775,8070

Пример объявления целочисленных типов:

byte b = 4;
short s1 = 7, s2 = 5;
int i1 = 56, i2;
i2 = 78;
long a1 = 456;

Функции int() | Python

В языке программирования Python встроенная функция int() возвращает целое число в десятичной системе счисления (класс int).

Если вызвать функцию int() без аргументов, она вернет 0.

>>> int()
0

Чаще всего функции int() передают только один аргумент, который может быть либо строкой, либо числом. Строки должны быть символьными представлениями целого числа, иначе будет сгенерирована ошибка ValueError.

>>> int('4')
4
>>> int('3a')
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    int('3a')
ValueError: invalid literal for int() with base 10: '3a'

Если передать функции целое число, то она вернет его же. Если передать вещественное число, то оно будет округлено до целого в сторону нуля (т. е. дробная часть будет отброшена).

>>> int(87)
87
>>> int(-103)
-103
>>> int(234.879)
234
>>> int(-0.3)
0
>>> int(-0.9)
0

Попытка преобразовать строку, содержащую вещественное число, в целое число с помощью функции int() вызывает ошибку.

>>> int('101.1')
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    int('101.1')
ValueError: invalid literal for int() with base 10: '101.1'

Отсюда следует, что если требуется преобразовать дробное число в строковом представлении в целое число, сначала надо использовать функцию float(), а затем int().

>>> a = '15.76'
>>> a = float(a)
>>> a
15.76
>>> a = int(a)
>>> a
15

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

>>> int('12',8)
10
>>> int('13h',20)
477
>>> int('111001',2)
57

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

>>> int(0b11)
3
>>> int('0b11')
Traceback (most recent call last):
  File "<pyshell#48>", line 1, in <module>
    int('0b11')
ValueError: invalid literal for int() with base 10: '0b11'
>>> int('0b11',2)
3
>>> int(0o10)
8
>>> int(0x15)
21
>>> int(0xA5)
165

Итак, функция int() всегда возвращает десятичное целое число. Если преобразовать первый аргумент в десятичное число не удается, то генерируется ошибка.

int в Python

Тип представляет целое число.

Целые имеют неограниченную точность.

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

    int(x, base=10)

Если первый аргумент является строкой, то должен представлять число. Такая строка может содержать знак числа, а также пробельные символы (как ведущие так и заключительные).
Если передано целое, «длинное» целое, либо число с плавающей запятой) будет возвращено целое с тем же значением.
Приведение числа с плавающей запятой к целому усекает его в сторону нуля.

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

    my_int = 1
my_int = 0x1  # Шестнадцатеричный вид
my_int = 0o1  # Восьмеричный вид
my_int = 0b1  # Двоичный вид
my_int = int('1')
my_int = int(1.1)  # 1
my_int = int(' 1')  # 1
my_int = int()  # 0
my_int = int(10, 2)  # TypeError: int() can't convert non-string with explicit base
my_int = int('10', 2)  # 2

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

Python 2

Обычные целые (или просто «целые») реализованы при помощи типа long из Си, что даёт им не менее 32 бит точности (sys. maxint всегда установлен в максимум для обычных целых на данной платформе; минимальное значение — -sys.maxint - 1). «Длинные» — long — целые имеют неограниченную точность (в Python 3 все целые являются «длинными»).Логический Булев тип является подтипом целого.

bool

Логический (булев) тип данных.

Что означает Int в C, C ++ и C #?

Int, сокращение от integer, является фундаментальным типом переменной, встроенным в компилятор и используемым для определения числовых переменных, содержащих целые числа. Другие типы данных включают float и double.

C, C ++, C # и многие другие языки программирования распознают int как тип данных.

В C ++ целочисленная переменная объявляется следующим образом:

int a = 7;

Int Ограничения

В переменных типа int могут храниться только целые числа, но поскольку они могут хранить как положительные, так и отрицательные числа, они также считаются знаковыми.

Например, 27, 4908 и -6575 являются допустимыми записями типа int, а 5.6 и b — нет. Для чисел с дробными частями требуется переменная типа float или double, обе из которых могут содержать десятичные точки.

Размер числа, которое может быть сохранено в int, обычно не определяется в языке, а зависит от компьютера, на котором выполняется программа. В C # int — 32 бита, поэтому диапазон значений составляет от -2 147 483 648 до 2 147 483 647. Если требуются большие значения, можно использовать тип double.

Что такое Nullable Int?

Nullable int имеет тот же диапазон значений, что и int, но может хранить null в дополнение к целым числам. Вы можете присвоить значение nullable int так же, как и int, а также можете присвоить значение null.

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

Int vs.Поплавок и двойной

Int похож на типы float и double, но служат разным целям.

Инт:

  • Занимает меньше места, чем другие типы
  • Имеет более быструю арифметику
  • Использует только целые числа
  • Более эффективно использует кеши и пропускную способность передачи данных

Поплавковые и двойные типы :

  • Использует вдвое больше памяти
  • Может содержать десятичную точку
  • Может содержать больше символов

Разница между типами float и double заключается в диапазоне значений.Диапазон double вдвое больше, чем у float, и он вмещает больше цифр.

Примечание. INT также используется в качестве формулы в Microsoft Excel для округления чисел в меньшую сторону, но не имеет ничего общего с int, как описано на этой странице.

Пределы целых чисел C и C ++

  • 2 минуты на чтение

В этой статье

Специально для Microsoft

Пределы для целочисленных типов в C и C ++ перечислены в следующей таблице.Эти ограничения определены в стандартном заголовочном файле C . Заголовок стандартной библиотеки C ++ включает , который включает .

Microsoft C также позволяет объявлять целочисленные переменные размера, которые являются целочисленными типами размером 8, 16, 32 или 64 бита. Для получения дополнительной информации о размерных целых числах в C, см. Размерные целочисленные типы.

Пределы целочисленных констант

Константа Значение Значение
CHAR_BIT Число битов в наименьшей переменной, не являющейся битовым полем. 8
SCHAR_MIN Минимальное значение для переменной типа signed char . -128
SCHAR_MAX Максимальное значение для переменной типа знаковый символ . 127
UCHAR_MAX Максимальное значение для переменной типа unsigned char . 255 (0xff)
CHAR_MIN Минимальное значение для переменной типа char . -128; 0, если используется опция / J
СИМВОЛ_МАКС Максимальное значение для переменной типа char . 127; 255, если используется опция / J
MB_LEN_MAX Максимальное количество байтов в многосимвольной константе. 5
SHRT_MIN Минимальное значение для переменной типа short .-32768
SHRT_MAX Максимальное значение для переменной типа short . 32767
USHRT_MAX Максимальное значение для переменной типа unsigned short . 65535 (0xffff)
INT_MIN Минимальное значение для переменной типа int . -2147483647 — 1
INT_MAX Максимальное значение для переменной типа int . 2147483647
UINT_MAX Максимальное значение для переменной типа unsigned int . 4294967295 (0xffffffff)
LONG_MIN Минимальное значение для переменной типа long . -2147483647 — 1
LONG_MAX Максимальное значение для переменной типа long . 2147483647
ULONG_MAX Максимальное значение для переменной типа длинное без знака . 4294967295 (0xffffffff)
LLONG_MIN Минимальное значение для переменной типа long long . -9 223 372 036 854 775 807 — 1
LLONG_MAX Максимальное значение для переменной типа long long . 9 223 372 036 854 775 807
ULLONG_MAX Максимальное значение для переменной типа unsigned long long . 18,446,744,073,709,551,615 (0xffffffffffffffff)

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

END Спецификация Microsoft

См. Также

Целочисленные константы C

В чем разница между unsigned int и signed int в C?

ISO C указывает, в чем заключаются различия.

Тип данных int подписан и имеет минимальный диапазон от -32767 до 32767 включительно.Фактические значения приведены в пределах . h как INT_MIN и INT_MAX соответственно.

Тип unsigned int имеет минимальный диапазон от 0 до 65535 включительно с фактическим максимальным значением UINT_MAX из того же файла заголовка.

Кроме того, стандарт не требует записи с дополнением до двух для кодирования значений, это лишь одна из возможностей. Три разрешенных типа будут иметь следующие кодировки для 5 и -5 (с использованием 16-битных типов данных):

  двойное дополнение | дополнение | знак / величина
    + --------------------- + --------------------- + ----- ---------------- +
 5 | 0000 0000 0000 0101 | 0000 0000 0000 0101 | 0000 0000 0000 0101 |
-5 | 1111 1111 1111 1011 | 1111 1111 1111 1010 | 1000 0000 0000 0101 |
    + --------------------- + --------------------- + ----- ---------------- +
  • В дополнении до двух вы получаете отрицательное значение числа, инвертируя все биты и добавляя 1.
  • В дополнении до единиц вы получаете отрицательное число, инвертируя все биты.
  • В знаке / величине верхний бит является знаком, поэтому вы просто инвертируете его, чтобы получить отрицательное значение.

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

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

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

Кстати, в настоящее время ведутся работы как в стандартах C, так и в C ++, чтобы назначить дополнение до двух в качестве единственной кодировки для отрицательных целых чисел.

Список всех спецификаторов формата в программировании на C

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

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

Подробнее — Список всех типов данных в C

unsigned char % d ничего
Спецификатор формата Описание Поддерживаемые типы данных
% c Символ char
unsigned char
Целое число со знаком short
unsigned short
int
long
% e or% E Научное представление значений с плавающей запятой float
double
% f Float
% g или% G Аналогично% e или% E float
double
% hi Целое число со знаком (короткое) короткое
% huns Целое число

 Uns Short) unsigned short
% i Signed Integer short
unsigned short
int
long 9011 1
% l или% ld или% li Целое число со знаком long
% lf Floating point double
% Lf Floating point double double % lu Целое число без знака Целое число без знака
Длинное число без знака
% lli,% lld Целое число со знаком long long
% llu% Целое число без знака

 long

 o Восьмеричное представление целого числа. short
unsigned short
int
unsigned int
long
% p Адрес указателя на void void * void *
% s% String char *

11

% String char *

11

 String u Unsigned Integer unsigned int
unsigned long
% x or% X Шестнадцатеричное представление целого числа без знака short
unsigned short
int
unsigned int
long		 n

%% Печатает% character

О Панкай

Панкадж Пракаш — основатель, редактор и блогер Codeforwin.Он любит изучать новые технологии и писать статьи по программированию, особенно для начинающих. Он работает в Vasudhaika Software Sols. как инженер-разработчик программного обеспечения и управляет Codeforwin. Короче говоря, Панкадж — веб-разработчик, блоггер, ученик, любитель технологий и музыки.

Подписаться на: Twitter | Google | Веб-сайт или все сообщения Pankaj

Руководство по программированию на C 21 — Типы данных Int, Float и Double

Не забудьте прочитать последний блог о типах данных! Ты здесь новенький? Начните с самого начала, Введение в C!

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

Существует множество числовых типов данных, но большинство из них представляют собой просто модифицированные версии трех основных числовых типов данных: integer, float и double.

int означает целое число. Целые числа — это целые числа, то есть любое число без дробной части. Целые числа = {…, -2, -1, 0, 1, 2,…}.

Плавающие и двойные числа используются для хранения чисел с числами после десятичной точки. Так что подумайте .5, или .2342, или 1.2, или 430.0. Эти два типа данных вместе называются типами данных с плавающей запятой. Это может сбивать с толку, потому что один из них называется float, но на самом деле они оба называются с плавающей запятой. Тип данных с плавающей запятой называется с плавающей запятой одинарной точности, а тип данных double — с плавающей запятой двойной точности.

Итак, допустим, вы хотели сохранить, сколько собак у вас было… Вы хотите использовать int, float или double? Наверное, int, потому что у вас не должно быть доли собаки для домашнего животного.Это просто лажа.

Итак, если есть два типа данных для хранения чисел с дробными частями, как вы должны знать, какой из них использовать? Все дело в точности.

По сути, когда вы объявляете переменную типа double, она занимает вдвое больше памяти, чем float, но обеспечивает примерно вдвое большую точность. Итак, если вы хотите сохранить что-то вроде квадратного корня из двух, использование числа с плавающей запятой даст вам только определенное количество цифр, а использование double даст примерно вдвое больше цифр.

В общем, я предпочитаю использовать дубли для всего.

Итак, мы попрактикуемся в создании некоторых переменных и выводе их на экран.

Для начала выведем целое число. Это очень просто. Вы можете использовать % d или % i . Оба они работают одинаково. Вы думаете, что % i — это сокращение от целого числа, если это вам поможет.

Как видите, объявление и вывод целого числа — это несложно.

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

Супер просто.

Теперь вам нужно знать кое-что важное о типах данных float и double. Из-за способа хранения этих типов данных они не могут точно представлять каждое значение. Например:

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

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

Я все же думаю, что нам следует немного поговорить о том, как хранятся числа. На самом деле они хранятся в научных обозначениях. Мы обсудим, как это работает, в следующем блоге! Пошли!

Вопросы для собеседования по языку C — Типы и размеры данных — AppLabs, Apple, AppNexus

1. Что будет на выходе следующего кода C?

  1.  #include  
  2.  int main () 
  3.  {
  4.  int a [5] = {1, 2, 3, 4, 5}; 
  5.  int i; 
  6.  for (i = 0; i <5; i ++) 
  7.  if ((char) a [i] == '5') 
  8.  printf ("% d \ n", a [ я]); 
  9.  else 
  10.  printf ("FAIL \ n"); 
  11. }

a) Компилятор отметит ошибку
b) Программа скомпилирует и распечатает результат 5
c) Программа скомпилирует и напечатает значение ASCII 5
d) Программа скомпилирует и 5 раз выведет FAIL
Просмотр Ответ

Ответ: d
Объяснение: Значение ASCII 5 - 53, целочисленное значение 5 с преобразованием типа char - только 5.
Вывод:
$ cc pgm1.c
$ a.out
FAIL
FAIL
FAIL
FAIL
FAIL

2. Идентификатор формата «% i» также используется для типа данных _____.
a) char
b) int
c) float
d) double
Просмотреть ответ

Ответ: b
Объяснение: И% d, и% i могут использоваться в качестве идентификатора формата для типа данных int.

3. Какой тип данных больше всего подходит для хранения числа 65000 в 32-битной системе?
a) короткое со знаком
b) короткое без знака
c) длинное
d) int
Посмотреть ответ

Ответ: b
Пояснение: 65000 входит в диапазон коротких (16 бит), которые занимают меньше всего памяти.Знаковые короткие диапазоны от -32768 до 32767 и, следовательно, мы должны использовать беззнаковые короткие.

4. Что из перечисленного является типом данных, определяемым пользователем?
а) typedef int Boolean;
б) typedef enum {Пн, Вт, Среда, Чт, Пт} по рабочим дням;
c) struct {char name [10], int age};
d) все упомянутые
Посмотреть ответ

Ответ: d
Объяснение: typedef и struct используются для определения определяемых пользователем типов данных.

5. Каков размер типа данных int?
a) 4 байта
b) 8 байтов
c) Зависит от системы / компилятора
d) Не может быть определено
Посмотреть ответ

Ответ: c
Объяснение: Размер типов данных зависит от системы.

6. Что будет на выходе следующего кода C?

  1.  #include  
  2.  int main () 
  3.  {
  4.  подписанный char chr; 
  5.  chr = 128; 
  6.  printf ("% d \ n", chr); 
  7.  возврат 0; 
  8. }

a) 128
b) -128
c) Зависит от компилятора
d) Ни один из упомянутых
Посмотреть ответ

Ответ: b
Объяснение: знаковый символ будет отрицательным числом.
Выход:
$ cc pgm2.c
$ a.out
-128

7. Что будет на выходе следующего кода C?

  1.  #include  
  2.  int main () 
  3.  {
  4.  char c; 
  5.  int i = 0; 
  6.  ФАЙЛ * файл; 
  7.  файл = fopen ("test. txt", "w +"); 
  8.  fprintf (файл, «% c», 'a'); 
  9.  fprintf (файл, «% c», -1); 
  10.  fprintf (файл, «% c», 'b'); 
  11.  fclose (файл); 
  12.  file = fopen ("test.txt "," r "); 
  13.  while ((c = fgetc (file))! = -1) 
  14.  printf ("% c ", c); 
  15.  return 0; 
  16. }

a) a
b) Бесконечный цикл
c) Зависит от того, что возвращает fgetc
d) Зависит от компилятора
Посмотреть ответ

Ответ: a
Объяснение: Нет.
Выход:
$ cc pgm3.c
$ a.out
a

8. Что такое short int в программировании на C?
a) Базовый тип данных C
b) Квалификатор
c) Short - квалификатор, а int - базовый тип данных
d) Все упомянутые
Просмотреть ответ

Ответ: c
Объяснение: Нет.

Sanfoundry Global Education & Learning Series - Язык программирования C.

Добавить комментарий

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