Диапазон значений в C Int и Long 32 - 64 бит

Я запутался с диапазоном значений переменной Int в C.

Я знаю, что 32-битный unsigned int имеет диапазон от 0 до 65535. Так долго есть от 0 до 4 294 967 295

Это нормально в 32-битной машине. Но теперь в 64-битных машинах все вещи сохраняются одинаково? Или, может быть, моя int-емкость отличается?

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

unsigned long long int atomicAdd(unsigned long long int* address, unsigned long long int val);

ОТВЕТЫ

Ответ 1

В C и С++ у вас есть эти минимальные требования (то есть фактические реализации могут иметь большие величины)

signed char: -2^07+1 to +2^07-1
short:       -2^15+1 to +2^15-1
int:         -2^15+1 to +2^15-1
long:        -2^31+1 to +2^31-1
long long:   -2^63+1 to +2^63-1

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

Ответ 2

Нет, int в C не определено как 32 бит. int и long не определяются каким-либо конкретным размером вообще. Единственное, что гарантирует язык, это sizeof(char)<=sizeof(short)<=sizeof(long).

Теоретически компилятор может сделать short, char и long все одинаковое количество бит. Я знаю, что действительно сделал это для всех этих типов save char.

Вот почему C теперь определяет такие типы, как uint16_t и uint32_t. Если вам нужен определенный размер, вы должны использовать один из них.

Ответ 3

Выдержка из K & R:

short часто бывает 16 бит, long 32 бит и int либо 16 бит, либо 32 бит. Каждый компилятор может выбирать подходящие размеры для своих собственных аппаратное обеспечение, подлежащее только ограничению, которое short и int являются не менее 16 бит, long - не менее 32 бит, а short - нет длиннее int, которое больше, чем long.

Вы можете использовать limits.h, который содержит определение пределов для типов decimal/float:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>


int main(int argc, char** argv) {

    printf("CHAR_BIT    :   %d\n", CHAR_BIT);
    printf("CHAR_MAX    :   %d\n", CHAR_MAX);
    printf("CHAR_MIN    :   %d\n", CHAR_MIN);
    printf("INT_MAX     :   %d\n", INT_MAX);
    printf("INT_MIN     :   %d\n", INT_MIN);
    printf("LONG_MAX    :   %ld\n", (long) LONG_MAX);
    printf("LONG_MIN    :   %ld\n", (long) LONG_MIN);
    printf("SCHAR_MAX   :   %d\n", SCHAR_MAX);
    printf("SCHAR_MIN   :   %d\n", SCHAR_MIN);
    printf("SHRT_MAX    :   %d\n", SHRT_MAX);
    printf("SHRT_MIN    :   %d\n", SHRT_MIN);
    printf("UCHAR_MAX   :   %d\n", UCHAR_MAX);
    printf("UINT_MAX    :   %u\n", (unsigned int) UINT_MAX);
    printf("ULONG_MAX   :   %lu\n", (unsigned long) ULONG_MAX);
    printf("USHRT_MAX   :   %d\n", (unsigned short) USHRT_MAX);
    printf("FLT_MAX     :   %g\n", (float) FLT_MAX);
    printf("FLT_MIN     :   %g\n", (float) FLT_MIN);
    printf("-FLT_MAX    :   %g\n", (float) -FLT_MAX);
    printf("-FLT_MIN    :   %g\n", (float) -FLT_MIN);
    printf("DBL_MAX     :   %g\n", (double) DBL_MAX);
    printf("DBL_MIN     :   %g\n", (double) DBL_MIN);
    printf("-DBL_MAX     :  %g\n", (double) -DBL_MAX);

    return (EXIT_SUCCESS);
}

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

Ответ 4

Нет ответа. Стандарт определяет минимальные диапазоны. Int должен иметь возможность удерживать не менее 65535. Большинство современных компиляторов, однако, позволяют ints быть 32-битными значениями. Кроме того, ничего не мешает нескольким типам иметь одинаковую емкость (например, int и long).

При этом стандарт говорит в вашем конкретном случае:

0 → +18446744073709551615

как диапазон для unsigned long long int.

Дополнительная литература: http://en.wikipedia.org/wiki/C_variable_types_and_declarations#Size

Ответ 5

Фактически, unsigned int на большинстве современных процессоров (ARM, Intel/AMD, Alpha, SPARC, Itanium, PowerPC) будет иметь диапазон от 0 до 2 ^ 32 - 1, что составляет 4 294 967 295 = 0xffffffff потому что int (как подписанный, так и unsigned) будет длиной 32 бита, а наибольший - как указано.

(unsigned short будет иметь максимальное значение 2 ^ 16 - 1 = 65 535)

(без знака) long long int будет иметь длину 64 бит (длинный int будет достаточным в большинстве 64-разрядные Linux и т.д., Но стандартный promises 64 бит для long long int). Следовательно, они имеют диапазон от 0 до 2 ^ 64 - 1 = 18446744073709551615

Ответ 6

В C и С++ требования к памяти некоторой переменной:

signed char: -2^07 to +2^07-1
short: -2^15 to +2^15-1
int: -2^15 to +2^15-1
long: -2^31 to +2^31-1
long long: -2^63 to +2^63-1

signed char: -2^07 to +2^07-1
short: -2^15 to +2^15-1
int: -2^31 to +2^31-1
long: -2^31 to +2^31-1
long long: -2^63 to +2^63-1

зависит от компилятора и архитектуры аппаратного обеспечения

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

Ответ 7

Взгляните на limits.h. Вы можете найти конкретные значения для своего компилятора. INT_MIN и INT_MAX будут представлять интерес.

Ответ 8

Посмотрите на файл limits.h в вашей системе, он сообщит системные ограничения. Или отметьте man limits.h и перейдите в раздел "Численные пределы".

Ответ 9

32-разрядный unsigned int имеет диапазон от 0 до 4 294 967 295. От 0 до 65535 будет 16-разрядная без знака.

Беззнаковый длинный длинный (и в 64-битной реализации, возможно, также улунг и, возможно, uint) имеет диапазон (по крайней мере) от 0 до 18 446 744 073 709 551 615 (2 64 -1), Теоретически это может быть больше, чем это, но, по крайней мере, на данный момент это редко встречается.

Ответ 10

Лучше включить stdlib.h. Поскольку без stdlibg требуется длительный срок