Что такое size_t в C?

Я запутался size_tв C. Я знаю, что он возвращается sizeofоператором. Но что именно это? Это тип данных?

Допустим, у меня есть forцикл:

for(i = 0; i < some_size; i++)

Я должен использовать int i;или size_t i;?

Из Википедии :

В соответствии со стандартом ISO C 1999 года (C99) size_tэто целочисленный тип без знака длиной не менее 16 бит (см. Разделы 7.17 и 7.18.3).

size_tтип данных без знака, определенный несколькими стандартами C / C ++, например, стандартом C99 ISO / IEC 9899, ​​который определен в stddef.h. 1 Он может быть дополнительно импортирован путем включения, stdlib.hпоскольку этот файл содержит внутреннюю подпрограмму stddef.h.

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

Как следствие, size_tэто тип, который гарантированно содержит любой индекс массива.

size_tэто тип без знака. Таким образом, он не может представлять отрицательные значения (<0). Вы используете это, когда вы рассчитываете что-то, и уверены, что это не может быть отрицательным. Например, strlen()возвращает a, size_tпотому что длина строки должна быть не менее 0.

В вашем примере, если ваш индекс цикла будет всегда больше 0, имеет смысл использовать size_tлюбой другой тип данных без знака.

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

size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

и вы хотите найти разницу длин str2и str1. Вы не можете сделать:

int diff = s2 - s1; /* bad */

Это связано с тем, что присвоенное значение diffвсегда будет положительным числом, даже когда s2 < s1, потому что вычисление выполняется с беззнаковыми типами. В этом случае, в зависимости от вашего варианта использования, вам может быть лучше использовать int(или long long) для s1и s2.

В C / POSIX есть некоторые функции, которые можно / нужно использовать size_t, но не по историческим причинам. Например, второй параметр в fgetsидеале должен быть size_t, но есть int.

size_t тип, который может содержать любой индекс массива

В зависимости от реализации это может быть любой из:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

Вот как size_tэто определено в stddef.hмоей машине:

typedef unsigned long size_t;

Если вы эмпирический тип ,

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

Выход для Ubuntu 14.04 64-битный GCC 4.8:

typedef long unsigned int size_t;

Обратите внимание, что stddef.hпредоставляется GCC, а не glibc src/gcc/ginclude/stddef.hв GCC 4.2.

Интересные появления C99

• mallocпринимает size_tв качестве аргумента, поэтому он определяет максимальный размер, который может быть выделен.

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

  Смотрите также: Каков максимальный размер массива в C?

Manpage для types.h говорит:

size_t должен быть целым типом без знака

Поскольку никто еще не упомянул об этом, основное лингвистическое значение в size_tтом, что sizeofоператор возвращает значение этого типа. Аналогично, основное значение этого ptrdiff_tсостоит в том, что вычитание одного указателя из другого приведет к значению этого типа. Библиотечные функции, которые принимают его, делают это, потому что это позволит таким функциям работать с объектами, размер которых превышает UINT_MAX в системах, где такие объекты могут существовать, не вынуждая вызывающих абонентов тратить код, передавая значение, большее, чем «unsigned int», в системах, где больший тип будет достаточно для всех возможных объектов.

Чтобы понять, почему size_tнужно существовать и как мы сюда попали:

С практической точки зрения, size_tи ptrdiff_tгарантированно будет иметь ширину 64 бита в 64-битной реализации, 32 бита в 32-битной реализации и так далее. Они не могли заставить любой существующий тип означать это на каждом компиляторе, не нарушая устаревший код.

А size_tили ptrdiff_tне обязательно совпадает с intptr_tили uintptr_t. Они отличались от определенных архитектур , которые до сих пор были в использовании , когда size_tи ptrdiff_tбыли добавлены к Стандарту в конце 80 - х годов, и становится устаревшим , когда C99 добавлено много новых типов , но еще не прошли (например, 16-разрядной Windows). Сервер x86 в 16-разрядном защищенном режиме имел сегментированную память, в которой максимальный размер массива или структуры мог составлять всего 65 536 байт, но farуказатель должен был иметь ширину 32 бита, шире регистров. На тех, intptr_tбыло бы 32-битной шириной, но size_tиptrdiff_tможет быть 16 бит в ширину и помещаться в регистр. И кто знал, какую операционную систему можно написать в будущем? Теоретически, архитектура i386 предлагает 32-битную модель сегментации с 48-битными указателями, которую никогда не использовала ни одна операционная система.

Тип смещения памяти не может быть, longпотому что слишком большой унаследованный код предполагает, что longего ширина составляет ровно 32 бита. Это предположение было даже встроено в API-интерфейсы UNIX и Windows. К сожалению, во многих других устаревших кодах также предполагается, что a longдостаточно широк, чтобы содержать указатель, смещение файла, количество секунд, прошедших с 1970 года, и так далее. POSIX теперь предоставляет стандартизированный способ заставить последнее предположение быть верным вместо первого, но ни одно из них не является переносимым.

Этого не может быть, intпотому что лишь крошечная горстка компиляторов в 90-х имела intширину 64 бита. Тогда они действительно стали странными, держа long32 бита в ширину. Следующая редакция Стандарта объявила его незаконным, поскольку intон шире long, но intпо-прежнему имеет ширину 32 бита в большинстве 64-битных систем.

Этого не может быть long long int, что в любом случае было добавлено позже, поскольку он был создан, чтобы иметь ширину не менее 64 бит даже в 32-битных системах.

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

size_tи intне являются взаимозаменяемыми. Например, в 64-битном Linux size_t- это 64-битный (т.е. sizeof(void*)), но int32-битный.

Также обратите внимание, что size_tэто без знака. Если вам нужна подписанная версия, то есть ssize_tна некоторых платформах, и это будет более подходящим для вашего примера.

Как общее правило, я бы предложил использовать intдля большинства общих случаев и использовать size_t/ только ssize_tкогда есть особая потребность в этом ( mmap()например, с).

В общем, если вы начинаете с 0 и идете вверх, всегда используйте тип без знака, чтобы избежать переполнения, приводящего к ситуации с отрицательным значением. Это критически важно, потому что если границы вашего массива оказываются меньше, чем максимум вашего цикла, но максимум вашего цикла оказывается больше, чем максимум вашего типа, вы обернетесь вокруг отрицательного значения и у вас может возникнуть ошибка сегментации (SIGSEGV ). Поэтому, вообще, никогда не используйте int для цикла, начинающегося с 0 и идущего вверх. Используйте без знака.

size_t - целочисленный тип данных без знака. В системах, использующих библиотеку GNU C, это будет unsigned int или unsigned long int. size_t обычно используется для индексации массива и подсчета циклов.

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

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

// C program to demonstrate that size_t or
// any unsigned int type should be used 
// carefully when used in a loop

#include<stdio.h>
int main()
{
const size_t N = 10;
int a[N];

// This is fine
for (size_t n = 0; n < N; ++n)
a[n] = n;

// But reverse cycles are tricky for unsigned 
// types as can lead to infinite loop
for (size_t n = N-1; n >= 0; --n)
printf("%d ", a[n]);
}

Output
Infinite loop and then segmentation fault

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

const size_t number;

size_tрегулярно используется для индексации массивов и подсчета циклов. Если компилятор 32-bitэто будет работать unsigned int. Если компилятор есть, 64-bitон также будет работать unsigned long long int. Там для максимального размера в size_tзависимости от типа компилятора.

size_tуже определяют в <stdio.h>файле заголовка, но он может также определить с помощью <stddef.h>, <stdlib.h>, <string.h>, <time.h>, <wchar.h>заголовки.

• Пример (с const)

#include <stdio.h>

int main()
{
    const size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Вывод -: size = 800

• Пример (без const)

#include <stdio.h>

int main()
{
    size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Вывод -: size = 800

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

Так:

sizeof(size_t) >= sizeof(void*)