C int размер: C2017/Типы данных в c — iRunner Wiki

Размер C «int» 2 байта или 4 байта?

Переменная Integer в C занимает 2 байта или 4 байта?

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

От каких факторов это зависит?

Лучше всего рассмотреть диапазон , а не размер . И то, и другое будет отличаться на практике, хотя гораздо более надежно выбирать типы переменных по диапазону, чем по размеру, как мы увидим. Также важно отметить, что стандарт побуждает нас рассмотреть возможность выбора целочисленных типов на основе диапазона, а не размера , но сейчас давайте проигнорируем стандартную практику и позволим нашему любопытству исследовать sizeofбайты CHAR_BITи целочисленное представление … кроличью нору и сами все увидим …

sizeof, байтов и CHAR_BIT

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

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

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

Давайте подведем итоги:

• sizeof => размер в байтах и
• CHAR_BIT => количество бит в байте

Таким образом, в зависимости от вашей системы, sizeof (unsigned int)может быть любое значение больше нуля (а не только 2 или 4), как если бы CHAR_BITэто было 16, то один (шестнадцатиразрядный) байт содержит достаточно битов, чтобы представить шестнадцатибитовое целое число, описываемое стандарты (цитируется ниже). Это не обязательно полезная информация, не так ли? Давайте углубляться глубже …

Целочисленное представление

В C стандарт устанавливает минимальные точности / дальность для всех стандартных целочисленных типов (и CHAR_BIT, тоже, FWIW) здесь . Из этого мы можем получить минимум для того, сколько бит требуется для хранения значения , но мы можем также просто выбрать наши переменные на основе диапазонов . Тем не менее, огромная часть деталей, необходимых для этого ответа, находится здесь. Например, следующее, что стандарт unsigned intтребует (по крайней мере) шестнадцать бит хранения:

UINT_MAX                                65535 // 2¹⁶ - 1

Таким образом, мы можем видеть, что unsigned intтребуется ( как минимум ) 16 битов , и именно здесь вы получаете два байта (предполагая, что CHAR_BITэто 8) … и позже, когда этот предел увеличился до 2³² - 1, люди указали вместо этого 4 байта. Это объясняет явления, которые вы наблюдали:

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

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

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

Подписывать биты … В приведенном выше примере я указал UINT_MAXверхний предел, unsigned intпотому что это тривиальный пример извлечения значения 16из комментария. Для типов со знаком, чтобы различать положительные и отрицательные значения (это знак), мы также должны включить бит знака.

INT_MIN                                -32768 // -(2¹⁵)
INT_MAX                                +32767 // 2¹⁵ - 1

Биты заполнения … Хотя встречаться с компьютерами, у которых биты заполнения являются целыми числами, нечасто, стандарт C допускает это; некоторые машины (т.е. этот ) реализуют большие целочисленные типы, комбинируя два меньших (знаковых) целочисленных значения вместе … и когда вы объединяете целые числа со знаком, вы получаете потерянный знаковый бит. Этот потерянный бит считается заполнением в C. Другие примеры битов заполнения могут включать биты четности и биты прерывания .

Как вы можете видеть, стандарт, кажется, поощряет учитывать диапазоны, такие как INT_MIN… INT_MAXи другие минимальные / максимальные значения из стандарта, при выборе целочисленных типов, и не рекомендует полагаться на размеры, так как есть другие тонкие факторы, которые могут быть забыты, такие как CHAR_BITбиты заполнения, которые может повлиять на значение sizeof (int)(то есть распространенные заблуждения о двухбайтовых и четырехбайтовых целых числах игнорируют эти детали).

c++ — внешняя константа c ++ int для размера массива

У меня есть следующие три файла в моем коде (большая часть кода удалена. Это просто, чтобы изолировать проблему).

Global. h :

//global.h
#ifndef GLOBAL_H
#define GLOBAL_H
extern const int ARRAYSIZEX;
extern const int ARRAYSIZEY;
extern const int ARRAYSIZEZ;
#endif //GLOBAL_H

Global.cpp :

//global.cpp
#include "global.h"
const int ARRAYSIZEX = 5;
const int ARRAYSIZEY = 2;
const int ARRAYSIZEZ = 4;

Основной:

//main
#include "global.h"
using namespace std;

someType mySomeTypeArray[ARRAYSIZEX][ARRAYSIZEY][ARRAYSIZEZ];

int main(int argc, char **argv)
{
//...
}

Компиляция дает мне три ошибки при объявлении mySomeTypeArray.

ошибка: привязка массива не является целочисленной константой перед токеном ‘]’

Я хочу сохранить мои определения глобальной переменной и размера массива в global.h / cpp для этого приложения, просто для организации, чтобы все мои параметры конфигурации были в одном месте. Как правильно добиться того, что я пытаюсь сделать?

Благодарность

3

boxcartenant

21 Авг 2018 в 02:25

4 ответа

Лучший ответ

Ваше объявление терпит неудачу, потому что размеры массива нужно оценивать во время компиляции, а ваша схема инкапсуляции фактически скрывает значения от компилятора. Это правда, потому что компиляторы работают с отдельными единицами перевода. При компиляции main.cpp ваш компилятор видит только extern const int ARRAYSIZEX благодаря выражению include, но не значение, которое видно в отдельном модуле перевода, поэтому он не может понять макет памяти.

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

global.h

constexpr int ARRAYSIZEX = ...;
constexpr int ARRAYSIZEY = ...;
constexpr int ARRAYSIZEZ = ...;

main.cpp

#include "global.h"
someType mySomeTypeArray[ARRAYSIZEX][ARRAYSIZEY][ARRAYSIZEZ];

3

patatahooligan
29 Авг 2018 в 23:15

Проблема в том, что extern int x означает, что x определен в другом файле, но не беспокойтесь о деталях, все, что вам нужно знать, это int «. Обычно это достаточно хорошо, за исключением случаев, когда компилятор должен знать прямо здесь, а затем, что x.

Поскольку это определено в другом файле, оно не может. Этот файл должен быть скомпилирован до того, как он узнает, и результат этой компиляции из-за того, как работает C ++, не может повлиять на компиляцию этого файла.

Вам нужно объявить это как const int в заголовке, если вы хотите поделиться этими значениями. extern int не будет сокращать это.

Хотя это тривиальный пример, на самом деле нет никакой причины идти по пути extern. Просто определите значения в заголовочном файле как обычные const int.

3

tadman
20 Авг 2018 в 23:46

Размер массива должен быть указан целочисленным константным выражением. const int объект может использоваться в выражении целочисленной константы тогда и только тогда, когда он объявлен с помощью инициализатора, и этот инициализатор также является выражением целочисленной константы. Ваши ARRAYSIZE... переменные не удовлетворяют этому требованию. В main они объявлены без инициализатора. Вы не можете использовать переменные ARRAYSIZE... в качестве размеров массива в main.

Если у вас нет конкретного требования дать этим переменным внешнюю связь, просто объявите (и определите) их в заголовке как

const int ARRAYSIZEX = 5;
const int ARRAYSIZEY = 2;
const int ARRAYSIZEZ = 4;

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

Если вы действительно хотите дать им внешнюю связь, объявите их как inline extern const в заголовке

inline extern const int ARRAYSIZEX = 5;
inline extern const int ARRAYSIZEY = 2;
inline extern const int ARRAYSIZEZ = 4;

Поскольку inline сам по себе не позволяет const навязать внутреннюю связь, extern совершенно необязателен в этих объявлениях. А поскольку комбинацию inline const можно заменить на constexpr (как заметил @MM в комментариях), вы можете добиться того же эффекта, просто

constexpr int ARRAYSIZEX = 5;
constexpr int ARRAYSIZEY = 2;
constexpr int ARRAYSIZEZ = 4;

2

AnT
21 Авг 2018 в 00:28

Проблема в том, что ARRAYSIZEX, ARRAYSIZEY и ARRAYSIZEZ не являются константами времени компиляции. Они являются константами — поэтому их значения нельзя изменить, но их значения не известны компилятору.

В C ++ процесс компиляции состоит из 3 основных этапов.

1. Предварительная обработка всех исходных файлов выполняется препроцессором.
2. Компиляция для каждой единицы перевода (файл .cpp) выполняется компилятором. Для каждого модуля перевода компилятор создает объектный файл.
3. Связывание всех объектных файлов осуществляется компоновщиком. Вывод представляет собой исполняемый файл.

В C ++ ключевое слово extern для компилятора означает, что переменная «где-то» определена. Компилятор не знает реального адреса переменной, но, поместив ключевое слово extern, он уверен, что переменная действительно существует, и компоновщик сможет найти ее адрес по имени при создании исполняемого файла.

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

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

0

Timmy_A
21 Авг 2018 в 01:52

51939692

какие существуют int, float, char, double, wchar_t, bool и void, как определить, таблица

В этом руководстве мы узнаем об основных типах данных, таких как int, float, char и т.д. в программировании на C++, с помощью примеров.

Что такое типы данных в C++?

Типа данных в C++ – это объявления переменных. Они определяют тип и размер данных, связанных с переменными. 12

3. char

• Ключевое слово char используется для символов.
• Его размер составляет 1 байт.
• В C++ символы заключаются в одинарные кавычки ».
• Например:

char test = 'h';

Примечание. В С++ целочисленное значение хранится в переменной типа char, а не в самом символе.

4. wchar_t

• Широкий символ wchar_t похож на тип данных char, за исключением того, что его размер составляет 2 байта вместо 1.
• Он используется для представления символов, для использования которых требуется больше памяти, чем для одного символа.
• Например:

wchar_t test = L'ם'  // storing Hebrew character;

Обратите внимание на букву L перед кавычками.

Примечание. В C++ 11 также представлены два других типа символов фиксированного размера — char16_t и char32_t.

5. bool

• Тип данных bool имеет одно из двух возможных значений: true или false.
• Логические значения используются в условных операторах и циклах.
• Например:

bool cond = false;

6. void

• Ключевое слово void указывает на отсутствие данных. Это означает «ничего» или «не имеет значения».
• Мы будем использовать void, когда узнаем о функциях и указателях.

Примечание. Мы не можем объявлять переменные типа void.

Модификаторы типа

Мы можем дополнительно изменить некоторые из основных типов данных с помощью модификаторов типов. В C++ есть 4 модификатора типа:

• signed;
• unsigned;
• short;
• long.

Мы можем изменить следующие типы данных с помощью вышеуказанных модификаторов:

Список измененных типов данных

Посмотрим на несколько примеров.

long b = 4523232;
long int c = 2345342;
long double d = 233434.56343;
short d = 3434233; // Error! out of range
unsigned int a = -5;    // Error! can only store positive numbers or 0

Производные типы данных

Типы данных, производные от основных типов данных, являются производными типами. Например: массивы, указатели, типы функций, структуры и т.д.

c: C — int и long имеют одинаковый размер и максимальное значение

Стандарт C разрешает intи longимеет тот же размер и диапазон. Проще всего объяснить правила для беззнаковых типов, которые имеют минимальные максимумы : каждый целочисленный тип без знака должен иметь возможность представлять от 0 до хотя бы некоторого числа. Это таблица:

type                             minimum maximum
unsigned char                                255   (2**8  - 1)
unsigned short                            65,535   (2**16 - 1)
unsigned int                              65,535   (2**16 - 1)
unsigned long                      4,294,967,295   (2**32 - 1)
unsigned long long    18,446,744,073,709,551,615   (2**64 - 1)

Таким образом, вы можете видеть, что конфигурация, в которой unsigned intи unsigned longимеют одинаковый диапазон, является абсолютно допустимой, при условии, что этот диапазон по меньшей мере такой же большой, как и минимальный диапазон unsigned long. В Подписанные типы должны иметь один и тот же общий диапазон значений , как их беззнаковых аналоги, но сдвинуты так , что почти ровно половина значений отрицательны — к сожалению , это не так просто , как «-2 ^п-1 … 2 ^п-1 — 1» потому что стандарт по-прежнему допускает реализации без дополнения до двух, хотя никто не производил процессор, который делает это в течение многих лет.

Возможно, вы думали, longчто сможете представить до 2 ⁶³  — 1, потому что это верно для большинства «64-битных» операционных систем. Но «64-битная» Windows — исключение. Почти все операционные системы, которые называют себя «64-разрядными», используют так называемый «LP64 ABI », в котором целочисленные типы void *имеют следующие размеры:

sizeof(short)     == 2
sizeof(int)       == 4
sizeof(long)      == 8
sizeof(long long) == 8
sizeof(void *)    == 8

Windows вместо этого использует ABI «LLP64», с

sizeof(short)     == 2
sizeof(int)       == 4
sizeof(long)      == 4
sizeof(long long) == 8
sizeof(void *)    == 8

Это для обратной совместимости с 32-битной Windows, в котором longи intтакже тот же самый размер; Microsoft думала, что слишком много существующего кода сломалось бы, если бы они изменили размер long.

(Обратите внимание, что sizeof(void*) > sizeof(long)по причинам, слишком сложным для того, чтобы сюда входить, это запрещено оригинальным стандартом 1989 г. C. Поскольку они решили использовать LLP64 для 64-битной Windows, Microsoft протолкнула изменение в C99, чтобы разрешить его, буквально у всех остальных. явные возражения. И затем, в течение более десяти лет после выхода C99, они не удосужились реализовать функции C99 (например, uintptr_tи %zu), которые должны были заменить смягченное требование, что привело к совокупным человеческим годам дополнительной работы для людей, пытающихся писать программы, которые работают как на Windows, так и не на Windows. Not That I’m Bitter ™.)

Автор: zwol
Размещён: 16.03.2018 12:44

Как выбрать размер

Таблица размеров

Женские размеры

Верхняя одежда

Брюки и юбки

Джемперы и рубашки

Нижнее бельё

Обувь

Перчатки

Мужские размеры

Верхняя одежда

Брюки и шорты

Рубашки

Нижнее бельё

Обувь

Перчатки

Детские размеры

Одежда

Обувь (размеры 16-30)

Обувь (размеры 31-44)

Размер C «int» 2 байта или 4 байта?

Целочисленная переменная в C занимает 2 или 4 байта?

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

От каких факторов это зависит?

Лучше всего рассмотреть диапазон , а не размер .На практике оба варианта будут отличаться, хотя, как мы увидим, гораздо безопаснее выбирать типы переменных по диапазону, а не по размеру. Также важно отметить, что стандарт побуждает нас рассмотреть вопрос о выборе наших целочисленных типов на основе диапазона , а не размера , но пока давайте проигнорируем стандартную практику и дадим нашему любопытству изучить размером байтов и CHAR_BIT , и целочисленное представление … давайте закопаем кроличью нору и посмотрим сами…

размер , байтов и CHAR_BIT

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

Оператор sizeof дает размер (в байтах) его операнда, который может быть выражением или заключенным в скобки именем типа. Размер определяется типом операнда.

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

Давайте подведем итоги:

• sizeof => размер в байтах, а
• CHAR_BIT => количество бит в байте

Таким образом, в зависимости от вашей системы, sizeof (unsigned int) может быть любым значением больше нуля (не только 2 или 4), как если бы CHAR_BIT было 16, тогда одиночным (шестнадцатибитным) байт имеет достаточно битов для представления шестнадцатибитового целого числа, описанного стандартами (цитируется ниже). Это не обязательно полезная информация, не так ли? Давайте углубимся …

Целочисленное представление

Стандарт C определяет здесь минимальную точность / диапазон для всех стандартных целочисленных типов (а также CHAR_BIT , fwiw). Из этого мы можем вывести минимум для того, сколько битов требуется для хранения значения , но мы также можем просто выбрать наши переменные на основе диапазонов . Тем не менее, большая часть деталей, необходимых для этого ответа, находится здесь.Например, для стандартного unsigned int требуется (как минимум) шестнадцать бит памяти:

  UINT_MAX 65535 // 2¹⁶ - 1
  

Таким образом, мы видим, что unsigned int требует ( не менее ) 16 бит , где вы получаете два байта (при условии, что CHAR_BIT равно 8) … и позже, когда этот предел увеличился до 2³² - 1 , вместо этого люди указывали 4 байта.Это объясняет наблюдаемые вами явления:

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

Вы используете древний учебник и компилятор, который обучает вас непереносимому C; автор, написавший ваш учебник, может даже не знать о CHAR_BIT . Вам следует обновить свой учебник (и компилятор) до и постараться помнить, что I.T. — это постоянно развивающаяся область, и вам нужно оставаться на впереди , чтобы конкурировать … Впрочем, об этом хватит; давайте посмотрим, какие еще непереносимые секреты хранятся в этих базовых целочисленных байтах …

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

Знаковые биты … В приведенном выше примере я процитировал UINT_MAX как верхний предел для unsigned int , потому что это тривиальный пример извлечения значения 16 из комментария.Для знаковых типов, чтобы различать положительные и отрицательные значения (это знак), нам также необходимо включить знаковый бит.

  INT_MIN -32768 // - (2¹⁵)
INT_MAX +32767 // 2¹⁵ - 1
  

Биты заполнения … Хотя нечасто можно встретить компьютеры, у которых есть биты заполнения в целых числах, стандарт C допускает это; некоторые машины (то есть эта) реализуют более крупные целочисленные типы путем объединения двух меньших (знаковых) целочисленных значений вместе… и когда вы комбинируете целые числа со знаком, вы получаете потерянный знаковый бит. Этот потерянный бит считается заполнением в C. Другие примеры битов заполнения могут включать в себя биты четности и биты ловушки.

Как видите, стандарт, кажется, поощряет рассмотрение диапазонов, таких как INT_MIN .. INT_MAX и других минимальных / максимальных значений из стандарта при выборе целочисленных типов, а не рекомендует полагаться на размеры, поскольку есть другие тонкие факторы вероятно, будут забыты, такие как CHAR_BIT и биты заполнения, которые могут повлиять на значение sizeof (int) (т.е. распространенное заблуждение двухбайтовых и четырехбайтовых целых чисел ( игнорирует эти детали).

Каковы критерии выбора между типами данных short / int / long ?, C ++ FAQ

Другие вопросы по теме: Если короткое int того же размера, что и
int в моей конкретной реализации, зачем выбирать тот или иной? Если
Я начинаю учитывать фактический размер переменных в байтах, не так ли?
сделать мой код непереносимым (поскольку размер в байтах может отличаться от
реализация к реализации)? Или я должен просто выбрать размер
больше, чем мне действительно нужно, как своего рода буфер безопасности?

Ответ: Обычно рекомендуется писать код, который можно перенести на
другая операционная система и / или компилятор. В конце концов, если вы добьетесь успеха
в том, что вы делаете, кто-то другой может захотеть использовать это где-нибудь еще. Это может быть
немного сложно со встроенными типами, такими как int и short, поскольку
C ++ не дает гарантированных размеров. Однако C ++ дает вам две вещи, которые
может помочь: гарантировано минимальных размеров , и обычно это все, что вам нужно
необходимо знать, и стандартный заголовок C, который предоставляет typedef для размера
целые числа.

C ++ гарантирует, что char составляет ровно один байт
который составляет не менее 8 бит, short не менее 16 бит, int равен
не менее 16 бит, а long — не менее 32 бит.Это также гарантирует
беззнаковая версия каждого из них того же размера, что и оригинал,
например, sizeof (короткое без знака) == sizeof (короткое).

При написании переносимого кода не следует делать дополнительных предположений о
эти размеры. Например, не предполагайте, что int имеет 32 бита. Если у вас есть
интегральная переменная, которая требует как минимум 32 бита, используйте длинную или
unsigned long, даже если sizeof (int) == 4 в вашем конкретном
выполнение. С другой стороны, если у вас есть целочисленная переменная величина
который всегда будет соответствовать 16 битам и , если вы хотите минимизировать
использование памяти данных, используйте короткие или беззнаковые короткие, даже если вы
знать sizeof (int) == 2 в вашей конкретной реализации.

Другой вариант — использовать следующий стандартный заголовок C (который может или может
не предоставляется поставщиком компилятора C ++):

#include  / *  не является частью стандарта C ++  * /
 

Этот заголовок определяет определения типов для таких вещей, как int32_t и
uint16_t, которые представляют собой 32-битное целое число со знаком и 16-битное беззнаковое
целое число соответственно. Там есть и другие вкусности. Мой
рекомендуется использовать эти целочисленные типы «размера» только там, где они
действительно нужны. Некоторые люди преклоняются перед последовательностью, и они очень
соблазн использовать эти целые числа везде просто потому, что они
были нужны где то . Последовательность хорошая, но это не
очень хорошо, и использование этих typedef повсюду может вызвать некоторые головные боли
и даже возможные проблемы с производительностью. Лучше использовать здравый смысл, который часто
заставляет вас использовать обычные ключевые слова, например, int, unsigned,
и т. д., где вы можете, и использование целочисленных типов с явно заданным размером, например,
int32_t и т. д.где ты должен.

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

Обратите внимание, что стандарт C не гарантирует , что
определяет int n _t и uint n _t
специально для n = 8, 16, 32 или 64. Однако если базовый
реализация предоставляет целые числа любого из этих размеров,
требуется, чтобы содержать соответствующие определения типов. Кроме того, вы
гарантированно будет typedef для размеров n = 8, 16 и 32, если ваш
реализация соответствует стандарту POSIX. Сложите все это вместе, и будет справедливо сказать
что подавляющее большинство реализаций, хотя и не все,
будет иметь typedef для этих типичных размеров.

Типы данных и модификаторы в C

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

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

C имеет различные типы данных для хранения данных в программе. Программа на C может хранить целое, десятичное число, символ (алфавиты), строку (слова или предложение), список и т. Д. С использованием различных типов данных.

Нам нужно указать тип данных переменной (идентификатора) для хранения в ней любых данных.

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

Существует 2 категории типов данных в C:

1. Примитивные (первичные) типы данных

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

1. int

Используется для хранения целочисленных значений. Программа на C, скомпилированная с помощью компилятора GCC (32-разрядная версия), может хранить целые числа от -2147483648 до 2147483647. Размер int зависит от компилятора.В 32-битном компиляторе, таком как GCC, требуется 4 байта.

  int myIntegerValue = 100;  

2. char

Он хранит одиночный символ, такой как «a», «Z», «@» и т. Д., Включая число, символ или специальный символ. Для хранения каждого символа требуется 1 байт (8 бит).

  char myCharacter = 'A';  

Примечание : Каждый символ имеет соответствующее значение ASCII в диапазоне от -128 до 127. Числа как символ имеют соответствующие значения ASCII.Например, «1», поскольку char имеет значение ASCII 49, «A» имеет значение ASCII 65.

3. float

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

  float myFloatingValue = 100.6543;  

4. double

Хранит действительные числа с точностью до 15 знаков после запятой. Требуется 8 байт памяти.

  двойной myDoubleValue = 180,715586;  

2.

Производные и определяемые пользователем типы данных

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

• Массив
• Структура
• Union
• Enum
• Указатель

Модификаторы в C

Это ключевые слова в C для изменения свойств по умолчанию Типы данных int и char. В C есть 4 следующих модификатора.

Модификаторы в C

1. short

Ограничивает пользователя хранить небольшие целочисленные значения от -32768 до 32767. Его можно использовать только с типом данных int .

  short int myShortIntegerValue = 18;  

2. long

Это позволяет пользователю хранить очень большое количество (что-то вроде 9 миллионов триллионов ) от —

72036854775808 до

72036854775807 . Синтаксис long long используется вместо long int.

  long long myLongIntegerValue = 827337203685421584;  

3. signed

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

 
подписанный int myNegativeIntegerValue = -544;
подписанный int mypositiveIntegerValue = 544;
/ * Оба оператора имеют одинаковое значение даже без модификатора "signed" * /
  

4. без знака

Когда пользователь намеревается хранить только положительные значения в данном типе данных (int и char).

  беззнаковое int myIntegerValue = 486;  

Резюме

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

Целочисленные объекты — документация Python 3.9.2

Все целые числа реализованы как «длинные» целочисленные объекты произвольного размера.

При ошибке большинство API PyLong_As * возвращают (тип возврата) -1 , что не может быть
отличается от числа.Используйте PyErr_Occurred () для устранения неоднозначности.

PyLongObject

Этот подтип PyObject представляет собой целочисленный объект Python.

PyTypeObject PyLong_Type

Этот экземпляр PyTypeObject представляет собой целочисленный тип Python.
Это тот же объект, что и int в слое Python.

интервал PyLong_Check (PyObject * p )

Вернуть истину, если его аргумент — PyLongObject или подтип
PyLongObject .Эта функция всегда успешна.

интервал PyLong_CheckExact (PyObject * p )

Вернуть истину, если его аргумент — PyLongObject , но не подтип
PyLongObject . Эта функция всегда успешна.

PyObject * PyLong_FromLong (длинный v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из v или NULL в случае ошибки.

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

PyObject * PyLong_FromUnsignedLong (длинный беззнаковый v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из C unsigned long , или
NULL в случае сбоя.

PyObject * PyLong_FromSsize_t (Py_ssize_t v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из C Py_ssize_t , или
NULL в случае сбоя.

PyObject * PyLong_FromSize_t (size_t v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из C size_t , или
NULL в случае сбоя.

PyObject * PyLong_FromLongLong (длинный длинный v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из C long long или NULL
при неудаче.

PyObject * PyLong_FromUnsignedLongLong (unsigned long long v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из C unsigned long long ,
или NULL в случае сбоя.

PyObject * PyLong_FromDouble (двойной v )

Возвращаемое значение: Новая ссылка.

Вернуть новый объект PyLongObject из целой части v , или
NULL в случае сбоя.

PyObject * PyLong_FromString (const char * str , char ** pend , int base )

Возвращаемое значение: Новая ссылка.

Вернуть новый PyLongObject на основе строкового значения в str , которое
интерпретируется в соответствии с основанием системы счисления .Если pend не NULL ,
* pend будет указывать на первый символ в str , который следует за
представление числа. Если base — 0 , str интерпретируется с использованием
определение целочисленных литералов; в этом случае ведущие нули в
ненулевое десятичное число вызывает ValueError . Если base не равно 0 ,
он должен находиться в диапазоне от 2 до 36 включительно. Ведущие пространства и одиночные
подчеркивания после спецификатора основания и между цифрами игнорируются.Если здесь
нет цифр, будет выдано ValueError .

PyObject * PyLong_FromUnicode (Py_UNICODE * u , Py_ssize_t длина , int база )

Возвращаемое значение: Новая ссылка.

Преобразует последовательность цифр Unicode в целочисленное значение Python.

PyObject * PyLong_FromUnicodeObject (PyObject * u , int base )

Возвращаемое значение: Новая ссылка.

Преобразование последовательности цифр Unicode в строке u в целое число Python
ценить.

PyObject * PyLong_FromVoidPtr (недействительный * p )

Возвращаемое значение: Новая ссылка.

Создайте целое число Python из указателя p . Значение указателя может быть
извлекается из полученного значения с помощью PyLong_AsVoidPtr () .

длинный PyLong_AsLong (PyObject * obj )

Вернуть C long представление obj .Если obj не является
экземпляр PyLongObject , сначала вызовите его __index __ () или
__int __ () метод (если есть) для преобразования его в
PyLongObject .

Вызов OverflowError , если значение obj выходит за пределы допустимого диапазона
длинный .

В случае ошибки возвращает -1 . Используйте PyErr_Occurred () для устранения неоднозначности.

Устарело, начиная с версии 3.8: Использование __int __ () устарело.

длинный PyLong_AsLongAndOverflow (PyObject * obj , int * переполнение )

Вернуть C long представление obj . Если obj не является
экземпляр PyLongObject , сначала вызовите его __index __ () или
__int __ () метод (если есть) для преобразования его в
PyLongObject .

Если значение obj больше LONG_MAX или меньше
LONG_MIN , установите * overflow на 1 или -1 , соответственно, и
возврат -1 ; в противном случае установите * переполнение на 0 .Если любое другое исключение
происходит установка * переполнение на 0 и возврат -1 как обычно.

В случае ошибки возвращает -1 . Используйте PyErr_Occurred () для устранения неоднозначности.

Устарело, начиная с версии 3.8: Использование __int __ () устарело.

длинный длинный PyLong_AsLongLong (PyObject * obj )

Вернуть C long long представление obj .Если obj не является
экземпляр PyLongObject , сначала вызовите его __index __ () или
__int __ () метод (если есть) для преобразования его в
PyLongObject .

Вызов OverflowError , если значение obj выходит за пределы допустимого диапазона
длинный длинный .

В случае ошибки возвращает -1 . Используйте PyErr_Occurred () для устранения неоднозначности.

Устарело, начиная с версии 3.8: Использование __int __ () устарело.

long long PyLong_AsLongLongAndOverflow (PyObject * obj , int * overflow )

Вернуть C long long представление obj . Если obj не является
экземпляр PyLongObject , сначала вызовите его __index __ () или
__int __ () метод (если есть) для преобразования его в
PyLongObject .

Если значение obj больше LLONG_MAX или меньше
LLONG_MIN , установите * overflow на 1 или -1 соответственно,
и возвращаем -1 ; в противном случае установите * переполнение на 0 .Если любой другой
возникает исключение, установите * переполнение на 0 и верните -1 как обычно.

В случае ошибки возвращает -1 . Используйте PyErr_Occurred () для устранения неоднозначности.

Устарело, начиная с версии 3.8: Использование __int __ () устарело.

Py_ssize_t PyLong_AsSsize_t (PyObject * pylong )

Вернуть C Py_ssize_t представление пилонга . пилонг ​​ сусло
быть экземпляром PyLongObject .

Вызов OverflowError , если значение пилонга выходит за пределы допустимого диапазона
Py_ssize_t .

В случае ошибки возвращает -1 . Используйте PyErr_Occurred () для устранения неоднозначности.

беззнаковый длинный PyLong_AsUnsignedLong (PyObject * pylong )

Вернуть C unsigned long представление пилонга . пилонга
должен быть экземпляром PyLongObject .

Вызов OverflowError , если значение пилонга выходит за пределы допустимого диапазона
беззнаковое длинное .

Возвращает (длинное без знака) -1 в случае ошибки.
Используйте PyErr_Occurred () для устранения неоднозначности.

size_t PyLong_AsSize_t (PyObject * pylong )

Вернуть C size_t представление пилонга . пилонг ​​ должен быть
экземпляр PyLongObject .

Вызов OverflowError , если значение пилонга выходит за пределы допустимого диапазона
размер_т .

Возвращает (size_t) -1 при ошибке.
Используйте PyErr_Occurred () для устранения неоднозначности.

беззнаковый длинный длинный PyLong_AsUnsignedLongLong (PyObject * pylong )

Вернуть C unsigned long long представление пилонга . пилонга
должен быть экземпляром PyLongObject .

Вызов OverflowError , если значение пилонга выходит за пределы допустимого диапазона
беззнаковое длинное длинное .

Возвращает (unsigned long long) -1 в случае ошибки.
Используйте PyErr_Occurred () для устранения неоднозначности.

беззнаковый длинный PyLong_AsUnsignedLongMask (PyObject * obj )

Вернуть C unsigned long представление obj .Если obj
не является экземпляром PyLongObject , сначала вызовите его
__index __ () или __int __ () метод (если есть) для преобразования
это в PyLongObject .

Если значение obj выходит за пределы диапазона unsigned long ,
вернуть уменьшение этого значения по модулю ULONG_MAX + 1 .

Возвращает (длинное без знака) -1 в случае ошибки. Используйте PyErr_Occurred () для
устранять неоднозначность.

Не рекомендуется, начиная с версии 3.8: Использование __int __ () устарело.

беззнаковый длинный длинный PyLong_AsUnsignedLongLongMask (PyObject * obj )

Вернуть C unsigned long long представление obj . Если obj
не является экземпляром PyLongObject , сначала вызовите его
__index __ () или __int __ () метод (если есть) для преобразования
это в PyLongObject .

Если значение obj выходит за пределы диапазона unsigned long long ,
вернуть уменьшение этого значения по модулю ULLONG_MAX + 1 .

Возвращает (unsigned long long) -1 в случае ошибки. Используйте PyErr_Occurred ()
чтобы устранить неоднозначность.

Устарело, начиная с версии 3.8: Использование __int __ () устарело.

двойной PyLong_AsDouble (PyObject * пилонг ​​)

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

Вызов OverflowError , если значение пилонга выходит за пределы допустимого диапазона
двойной .

Возвращает -1,0 в случае ошибки. Используйте PyErr_Occurred () для устранения неоднозначности.

void * PyLong_AsVoidPtr (PyObject * pylong )

Преобразует целое число Python pylong в указатель C void .
Если пилонга не может быть преобразовано, будет вызвана ошибка OverflowError . Этот
гарантируется только создание полезного указателя void для созданных значений
с PyLong_FromVoidPtr () .

Возвращает NULL в случае ошибки. Используйте PyErr_Occurred () для устранения неоднозначности.

EXP14-C. Остерегайтесь целочисленного продвижения при выполнении побитовых операций с целыми типами меньше int — SEI CERT C Coding Standard

Устарело

Это руководство устарело

Целочисленные типы меньше int продвигаются, когда над ними выполняется операция.Если все значения исходного типа могут быть представлены как int , значение меньшего типа преобразуется в int ; в противном случае он преобразуется в unsigned int (см. INT02-C. Общие сведения о правилах преобразования целых чисел). Если преобразование осуществляется в более широкий тип, исходное значение расширяется нулем для значений без знака или расширяется знаком для типов со знаком. Следовательно, побитовые операции с целочисленными типами меньше int могут иметь неожиданные результаты.

Этот пример несовместимого кода демонстрирует, как выполнение побитовых операций с целыми типами меньше int может привести к неожиданным результатам.

 uint8_t порт = 0x5a;
uint8_t result_8 = (~ порт) >> 4;
 

В этом примере сначала вычисляется поразрядное дополнение порта , а затем выполняется сдвиг на 4 бита вправо. Если обе эти операции выполняются с 8-битовым целым числом без знака, тогда result_8 будет иметь значение 0x0a . Однако порт сначала повышается до подписанного int со следующими результатами (в типичной архитектуре, где тип int имеет ширину 32 бита):

ff 9000ff4

912ff4 отрицательное значение равно

912ff4

912ff4 определяется реализацией.

битовое дополнение, совместимое с портом , в этом совместимом решении является побитовое дополнение. Следовательно, result_8 присваивается ожидаемое значение 0x0aU .

 uint8_t порт = 0x5a;
uint8_t result_8 = (uint8_t) (~ порт) >> 4;
 

Побитовые операции с короткими строками и символами могут привести к неверным данным.

9124

9124

9124

обнаружено автоматически этого правила на сайте CERT.

Вопросы для собеседования по языку

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.  еще 

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;
b) 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) Ни один из упомянутых
View Answer

Answer: b
Объяснение: signed char будет отрицательным числом.
Вывод:
$ 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.

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

[CX] Некоторые функции, описанные на этой справочной странице, расширяют стандарт ISO C. Заявления должны определять
соответствующий макрос тестирования функций (см. том Системные интерфейсы IEEE Std 1003.1-2001, Раздел 2.2, Среда компиляции), чтобы эти символы были видны в этом
заголовок.

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

Примечание:

«Ширина» целочисленного типа - это количество битов, используемых для хранения его значения в чистой двоичной системе; фактический тип может использовать
больше битов, чем это (например, 28-битный тип может храниться в 32-битном фактическом хранилище).Тип N -бит со знаком имеет
значения в диапазоне -2 N -1 или 1-2 N -1 до
2 N -1 -1, в то время как N -битный беззнаковый тип имеет значения в диапазоне от 0 до
2 N -1.

Типы определены в следующих категориях:

• Целочисленные типы, имеющие определенную точную ширину

• Целочисленные типы, имеющие хотя бы определенную заданную ширину

• Самые быстрые целочисленные типы, имеющие хотя бы определенную заданную ширину

• Целочисленные типы, достаточно широкие для хранения указателей на объекты

• Целочисленные типы с наибольшей шириной

(Некоторые из этих типов могут обозначать один и тот же тип.)

Соответствующие макросы определяют пределы объявленных типов и создают подходящие константы.

Для каждого описанного здесь типа, который предоставляет реализация, заголовок должен объявлять, что
typedef имя и определение связанных макросов. И наоборот, для каждого типа, описанного здесь, реализация не
предоставить, заголовок не должен объявлять имя typedef и не определять связанные макросы.Реализация должна предоставлять те типы, которые описаны как требуемые, но не должна предоставлять какие-либо другие (описанные как
необязательный).

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

Если определено typedef имен, отличающихся только отсутствием или наличием начального u , они должны обозначать
соответствующие типы со знаком и без знака, как описано в стандарте ISO / IEC 9899: 1999, раздел 6. 2.5; реализация
предоставление одного из этих соответствующих типов должно также обеспечивать другой.

В следующих описаниях символ N представляет собой десятичное целое число без знака без ведущих нулей (например, 8
или 24, но не 04 или 048).

• Целочисленные типы точной ширины

  typedef name int N _t обозначает целочисленный тип со знаком шириной N , без битов заполнения и
представление с двумя дополнениями. Таким образом, int8_t обозначает целочисленный тип со знаком шириной ровно 8 бит.

  typedef name uint N _t обозначает беззнаковый целочисленный тип шириной N . Таким образом,
uint24_t обозначает беззнаковый целочисленный тип шириной ровно 24 бита.

  [CX] The
требуются следующие типы:

  int8_t
int16_t
int32_t
uint8_t
uint16_t
uint32_t

  Если реализация предоставляет целочисленные типы шириной 64, удовлетворяющие этим требованиям, то требуются следующие типы:
int64_t uint64_t

  [CX] дюйм
В частности, это будет так, если выполняется одно из следующих условий:

  • Реализация поддерживает среду программирования _POSIX_V6_ILP32_OFFBIG, и приложение создается в
_POSIX_V6_ILP32_OFFBIG среда программирования (см. Том Оболочка и служебные программы IEEE Std 1003.1-2001, c99 , Среды программирования).

  • Реализация поддерживает среду программирования _POSIX_V6_LP64_OFF64, и приложение создается в
Среда программирования _POSIX_V6_LP64_OFF64.

  • Реализация поддерживает среду программирования _POSIX_V6_LPBIG_OFFBIG, и приложение создается в
Среда программирования _POSIX_V6_LPBIG_OFFBIG.

  Все остальные типы этой формы не являются обязательными.

• Целочисленные типы минимальной ширины

  typedef name int_least N _t обозначает целочисленный тип со знаком шириной не менее N ,
так что ни один знаковый целочисленный тип меньшего размера не имеет по крайней мере указанной ширины. Таким образом, int_least32_t обозначает подписанный
целочисленный тип шириной не менее 32 бит.

  typedef name uint_least N _t обозначает беззнаковый целочисленный тип с шириной не менее
N , так что ни один целочисленный тип без знака с меньшим размером не имеет по крайней мере указанной ширины.Таким образом, uint_least16_t обозначает
беззнаковый целочисленный тип шириной не менее 16 бит.

  Требуются следующие типы: int_least8_t int_least16_t int_least32_t int_least64_t
uint_least8_t uint_least16_t uint_least32_t uint_least64_t

  Все остальные типы этой формы не являются обязательными.

• Самые быстрые целочисленные типы минимальной ширины

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

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

  typedef name int_fast N _t обозначает самый быстрый знаковый целочисленный тип с шириной не менее
№ . typedef name uint_fast N _t обозначает самый быстрый целочисленный тип без знака с шириной
не менее N .

  Требуются следующие типы: int_fast8_t int_fast16_t int_fast32_t int_fast64_t
uint_fast8_t uint_fast16_t uint_fast32_t uint_fast64_t

  Все остальные типы этой формы не являются обязательными.

• Целочисленные типы, способные содержать указатели на объекты

  Следующий тип обозначает целочисленный тип со знаком со свойством, что любой действительный указатель на void может быть преобразован в
этот тип, затем преобразуется обратно в указатель на void , и результат будет сравниваться с исходным указателем:
интптр_т

  Следующий тип обозначает беззнаковый целочисленный тип со свойством, что любой действительный указатель на void может быть преобразован
к этому типу, затем преобразуется обратно в указатель на void , и результат будет сравниваться с исходным указателем:
uintptr_t

  [XSI]
В XSI-совместимых системах требуются типы intptr_t и uintptr_t ; в противном случае они необязательны.

• Целочисленные типы наибольшей ширины

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

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

  Эти типы обязательны.

Примечание:

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

Пределы целочисленных типов с заданной шириной

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

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

• Пределы целочисленных типов точной ширины

  • Минимальные значения целочисленных типов точной ширины со знаком:

    {INT N _MIN}

    Ровно - (2 N-1 )

  • Максимальные значения целочисленных типов точной ширины со знаком:

    {INT N _MAX}

    Ровно 2 N-1 -1

  • Максимальные значения целочисленных типов точной ширины без знака:

    {UINT N _MAX}

    Ровно 2 N -1

• Пределы целочисленных типов минимальной ширины

  • Минимальные значения целочисленных типов со знаком минимальной ширины:

    {INT_LEAST N _MIN}

    - (2 Н-1 -1)

  • Максимальные значения целочисленных типов со знаком минимальной ширины:

    {INT_LEAST N _MAX}

    2 Н-1 -1

  • Максимальные значения целочисленных типов без знака минимальной ширины:

    {UINT_LEAST N _MAX}

    2 N -1

• Пределы самых быстрых целочисленных типов минимальной ширины

  • Минимальные значения самых быстрых целочисленных типов со знаком минимальной ширины:

    {INT_FAST N _MIN}

    - (2 Н-1 -1)

  • Максимальные значения самых быстрых целочисленных типов минимальной ширины со знаком:

    {INT_FAST N _MAX}

    2 Н-1 -1

  • Максимальные значения самых быстрых целочисленных типов минимальной ширины без знака:

    {UINT_FAST N _MAX}

    2 N -1

• Пределы целочисленных типов, способных содержать указатели на объекты

  • Минимальное значение целочисленного типа со знаком, содержащего указатель:

    {INTPTR_MIN}

    - (2 15 -1)

  • Максимальное значение целочисленного типа со знаком, содержащего указатель:

    {INTPTR_MAX}

    2 15 -1

  • Максимальное значение целочисленного типа без знака, содержащего указатель:

    {UINTPTR_MAX}

    2 16 -1

• Пределы целочисленных типов наибольшей ширины

  • Минимальное значение целочисленного типа со знаком наибольшей ширины:

    {INTMAX_MIN}

    - (2 63 -1)

  • Максимальное значение целочисленного типа со знаком наибольшей ширины:

    {INTMAX_MAX}

    2 63 -1

  • Максимальное значение целочисленного типа без знака наибольшей ширины:

    {UINTMAX_MAX}

    2 64 -1

Пределы других целочисленных типов

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

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

• Пределы ptrdiff_t :

  {PTRDIFF_MIN}

  -65535

  {PTRDIFF_MAX}

  +65535

• Пределы sig_atomic_t :

  {SIG_ATOMIC_MIN}

  См. Ниже.

  {SIG_ATOMIC_MAX}

  См. Ниже.

• Предел size_t :

  {SIZE_MAX}

  65535

• Пределы wchar_t :

  {WCHAR_MIN}

  См. Ниже.

  {WCHAR_MAX}

  См. Ниже.

• Пределы wint_t :

  {WINT_MIN}

  См. Ниже.

  {WINT_MAX}

  См. Ниже.

Если sig_atomic_t (см. Заголовок ) определяется как подписанный
целочисленный тип, значение {SIG_ATOMIC_MIN} не должно быть больше, чем -127, а значение {SIG_ATOMIC_MAX} должно быть не меньше, чем
127; в противном случае sig_atomic_t должен быть определен как целочисленный тип без знака, а значение {SIG_ATOMIC_MIN} должно быть 0 и
значение {SIG_ATOMIC_MAX} должно быть не менее 255.

Если wchar_t (см. заголовок) определяется как подписанный
целочисленный тип, значение {WCHAR_MIN} не должно быть больше -127, а значение {WCHAR_MAX} должно быть не меньше 127;
в противном случае wchar_t должен быть определен как целочисленный тип без знака, а значение {WCHAR_MIN} должно быть 0, а значение
{WCHAR_MAX} должно быть не менее 255.

Если wint_t (см. Заголовок ) определяется как целое число со знаком
type, значение {WINT_MIN} не должно быть больше -32767, а значение {WINT_MAX} должно быть не меньше 32767; иначе,
wint_t должен быть определен как целочисленный тип без знака, значение {WINT_MIN} должно быть 0, а значение {WINT_MAX}
должно быть не менее 65535.

Макросы для целочисленных постоянных выражений

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

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

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

• Макросы для целочисленных постоянных выражений минимальной ширины

  Макрос INTN_C ( значение ) должен расширяться до целочисленного константного выражения, соответствующего типу int_least
N _t .Макрос UINTN_C (значение ) должен расширяться до целочисленного константного выражения, соответствующего
введите uint_least N _t . Например, если uint_least64_t - это имя для типа unsigned long long ,
тогда UINT64_C (0x123) может расшириться до целочисленной константы 0x123ULL.

  No related posts.