C 中的 size_t 是什么？

Question

我对 C 中的 size_t 感到困惑。我知道它是由 sizeof 运算符返回的。但它到底是什么？它是一种数据类型吗？

假设我有一个 for 循环：

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

我应该使用 int i; 还是 size_t i;？

Answer 1

来自维基百科：

根据1999年ISO C标准
(C99), size_t 是一个无符号整数
至少 16 位的类型（请参阅
7.17 和 7.18.3)。

size_t 是无符号数据类型
由多个 C/C++ 标准定义，
例如 C99 ISO/IEC 9899 标准，
在 stddef.h¹。它可以
通过纳入进一步进口
stdlib.h 作为此文件的内部子文件
包括 stddef.h。

该类型用于表示
物体的大小。库函数
接受或返回期望的大小
属于类型或具有返回类型
size_t。此外，最
常用的基于编译器的
运算符 sizeof 应计算为
与兼容的常数值
size_t。

这暗示着，size_t 是一种保证保存任何数组索引的类型。

Answer 2

size_t 是无符号类型。因此，它不能表示任何负值（<0）。当你计算某物并确定它不能为负数时，你会使用它。例如， strlen() 返回 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 s2 s2 s1 时也是如此。 s1，因为计算是使用无符号类型完成的。在这种情况下，根据您的用例，您可能最好对 s1 和 使用 int （或 long long） >s2。

C/POSIX 中有一些函数可以/应该使用 size_t，但由于历史原因没有这样做。例如，fgets 的第二个参数理想情况下应为 size_t，但实际上是 int。

Answer 3

size_t 是一种可以保存任何数组索引的类型。

根据实现的不同，它可以是以下任意一种：

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

这是在我的机器的 stddef.h 中定义 size_t 的方式：

typedef unsigned long size_t;

Answer 4

如果你是经验型，

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提供的，而不是src/gcc下的glibc GCC 4.2 中的 /ginclude/stddef.h。

有趣的 C99 外观

• malloc 将 size_t 作为参数，因此它确定可以分配的最大大小。

  由于它也是由 sizeof 返回的，我认为它限制了任何数组的最大大小。

  另请参阅：C 中数组的最大大小是多少?

Answer 5

要了解为什么 size_t 需要存在以及我们是如何实现这一点的：

用实用术语来说，size_t 和 ptrdiff_t 保证在 64 位上64 位实现，32 位实现上的 32 位宽，等等。他们无法在不破坏遗留代码的情况下，在每个编译器上强制任何现有类型表示这一点。

size_t 或 ptrdiff_t 不一定与 intptr_t 或 uintptr_t 相同。它们在 20 世纪 80 年代末将 size_t 和 ptrdiff_t 添加到标准时仍在使用的某些架构上有所不同，并在 C99 添加了许多新类型但尚未消失（例如 16 位 Windows）。 16 位保护模式下的 x86 具有分段内存，其中最大可能的数组或结构的大小只能是 65,536 字节，但 far 指针需要 32 位宽，比寄存器宽。对于这些，intptr_t 将是 32 位宽，但 size_t 和 ptrdiff_t 可能是 16 位宽并适合寄存器。谁知道将来会编写出什么样的操作系统呢？理论上，i386 架构提供了带有 48 位指针的 32 位分段模型，而操作系统从未实际使用过这种模型。

内存偏移量的类型不能是 long，因为太多遗留代码假设 long 正好是 32 位宽。这一假设甚至被内置到 UNIX 和 Windows API 中。不幸的是，许多其他遗留代码还假设 long 足够宽以容纳指针、文件偏移量、自 1970 年以来经过的秒数等。 POSIX 现在提供了一种标准化的方法来强制后一个假设而不是前一个假设为真，但这两个假设都不是可移植的。

它不可能是 int，因为在 90 年代只有极少数编译器将 int 设为 64 位宽。然后他们真的很奇怪，保持long 32位宽。标准的下一个修订版声明 int 比 long 更宽是非法的，但 int 在大多数 64 位上仍然是 32 位宽系统。

它不可能是 long long int，无论如何，它都是后来添加的，因为即使在 32 位系统上，它也被创建为至少 64 位宽。

因此，需要一种新的类型。即使不是，所有其他类型都意味着数组或对象内的偏移量以外的东西。如果从 32 位到 64 位迁移的惨败中有一个教训的话，那就是具体说明一种类型需要具有哪些属性，而不是使用在不同程序中意味着不同事物的属性。

Answer 6

types.h 的联机帮助页说：

size_t 应为无符号整数类型

Answer 7

由于尚未有人提及，size_t 的主要语言意义是 sizeof 运算符返回该类型的值。同样，ptrdiff_t 的主要意义是从一个指针减去另一个指针将产生该类型的值。接受它的库函数这样做是因为它将允许此类函数在可能存在此类对象的系统上处理大小超过 UINT_MAX 的对象，而不会迫使调用者浪费代码在较大类型的系统上传递大于“unsigned int”的值对于所有可能的对象就足够了。

Answer 8

size_t 和 int 不可互换。例如，在 64 位 Linux 上，size_t 的大小是 64 位（即 sizeof(void*)），但 int 是 32 位。

另请注意，size_t 是无符号的。如果您需要签名版本，那么某些平台上有 ssize_t ，它与您的示例更相关。

作为一般规则，我建议在一般情况下使用 int ，并且在计算内存偏移量时仅使用 size_t/ssize_t （使用 mmap( ） 例如）。

Answer 9

size_t 是一种无符号整数数据类型，只能分配 0 和大于 0 的整数值。它测量任何对象大小的字节，并由 sizeof 运算符返回。

const 是 size_t 的语法表示，但是没有 const 也可以运行该程序。

const size_t number;

size_t 经常用于数组索引和循环计数。如果编译器是32位，它将在unsigned int上工作。如果编译器是64位，它也可以在unsigned long long int上工作。最大大小为 size_t，具体取决于编译器类型。

size_t 已在 头文件中定义，但也可以由
、、、 ; 和 标头。

示例（使用 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);
}

输出：大小=800

Answer 10

size_t 是一个 typedef，用于表示任何对象的大小（以字节为单位）。 （Typedef 用于为另一种数据类型创建附加名称/别名，但不会创建新类型。）

在 stddef.h 中找到它的定义，如下所示：

typedef unsigned long long size_t;

size_t也在 中定义。

size_t 被 sizeof 运算符用作返回类型。

使用 size_t 与 sizeof 结合使用，定义数组大小参数的数据类型，如下所示：

#include <stdio.h>

void disp_ary(int *ary, size_t ary_size)
{
    for (int i = 0; i < ary_size; i++)
    {
        printf("%d ", ary[i]);
    }
}
 
int main(void)
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    int ary_size = sizeof(arr)/sizeof(int);
    disp_ary(arr, ary_size);
    return 0;
}

size_t 保证足够大以包含最大对象的大小主机系统可以处理。

请注意，数组的大小限制实际上是编译和执行此代码的系统堆栈大小限制的一个因素。您应该能够在链接时调整堆栈大小（请参阅 ld 命令的 --stack-size 参数）。

让您了解大概的堆栈大小：

• 嵌入式设备上为 4K
• Win10 上为 1M
• Linux 上为 7.4M

许多 C 库函数，例如 malloc、memcpy 和 strlen< /code> 声明它们的参数并返回类型为 size_t。

size_t 使程序员能够通过添加/减去所需元素的数量而不是使用字节偏移量来处理不同类型。

让我们通过检查它在 C 字符串和整数数组的指针算术运算中的用法来更深入地了解 size_t 可以为我们做些什么：

这是一个使用 C 字符串的示例：

const char* reverse(char *orig)
{
  size_t len = strlen(orig);
  char *rev = orig + len - 1;
  while (rev >= orig)
  {
    printf("%c", *rev);
    rev = rev - 1;  // <= See below
  }
  return rev;
}

int main() {
  char *string = "123";
  printf("%c", reverse(string));
}
// Output: 321

0x7ff626939004 "123"  // <= orig
0x7ff626939006 "3"    // <= rev - 1 of 3
0x7ff626939005 "23"   // <= rev - 2 of 3
0x7ff626939004 "123"  // <= rev - 3 of 3
0x7ff6aade9003 ""     // <= rev is indeterminant. This can be exploited as an out of bounds bug to read memory contents that this program has no business reading.

这对理解没有太大帮助使用 size_t 的好处，因为无论您的架构如何，字符都是一个字节。

当我们处理数字类型时，size_t 变得非常有用。

size_t 类型就像一个整数，优点是可以保存物理内存地址；该地址根据其执行平台的类型而改变其大小。

以下是我们在传递 int 数组时如何利用 sizeof 和 size_t：

void print_reverse(int *orig, size_t ary_size)
{
  int *rev = orig + ary_size - 1;
  while (rev >= orig)
  {
    printf("%i", *rev);
    rev = rev - 1;
  }
}

int main()
{
  int nums[] = {1, 2, 3};
  print_reverse(nums, sizeof(nums)/sizeof(*nums));

  return 0;
}

0x617d3ffb44 1  // <= orig
0x617d3ffb4c 3  // <= rev - 1 of 3
0x617d3ffb48 2  // <= rev - 2 of 3
0x617d3ffb44 1  // <= rev - 3 of 3

上面，我们看到 int 占用 4 个字节（并且由于每个字节有 8 位，因此 int 占用 32 位）。

如果我们要创建一个 long 数组，我们会发现在 linux64 操作系统上 long 需要 64 位，但只有 Win64 系统上的 32 位。因此，使用t_size将节省大量编码和潜在的错误，特别是在不同架构上运行执行地址算术的C代码时。

所以这个故事的寓意是“使用 size_t 并让你的 C 编译器完成容易出错的指针算术工作。”

Answer 11

size_t 是无符号整数数据类型。在使用 GNU C 库的系统上，这将为 unsigned int 或 unsigned long int。 size_t 通常用于数组索引和循环计数。

Answer 12

一般来说，如果从 0 开始向上，请始终使用无符号类型，以避免溢出导致负值情况。这非常重要，因为如果您的数组边界碰巧小于循环的最大值，但循环的最大值碰巧大于类型的最大值，您将环绕负数，并且可能会遇到 分段错误 (SIGSEGV)。因此，一般来说，切勿将 int 用于从 0 开始并向上的循环。使用无符号。

Answer 13

这是特定于平台的typedef。例如，在特定计算机上，它可能是 unsigned int 或 unsigned long。您应该使用此定义来提高代码的可移植性。

Answer 14

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

Answer 15

根据我的理解，size_t 是一个无符号整数，其位大小足以容纳本机体系结构的指针。

所以：

sizeof(size_t) >= sizeof(void*)