c语言中的sizeof运算符有什么用如何用sizeof计算数组长度

来源：这里教程网时间：2026-02-21 17:00:36 作者：

sizeof运算符在c语言中用于确定变量、数据类型或表达式在内存中所占的字节数。1. 它在编译时求值，适用于变量、数据类型和表达式，返回size_t类型的值；2. 可计算数组长度，通过整个数组大小除以单个元素大小实现；3. 用于指针时返回指针本身的大小，而非指向数据的大小；4. 在函数中对数组使用sizeof会退化为指针，导致无法正确计算数组长度；5. 处理结构体时考虑内存对齐，联合体大小等于最大成员的大小；6. 常用于动态内存分配，确保分配正确的字节数；7. 支持类型安全编程，避免硬编码数组长度；8. c99标准中支持可变长数组（vla），其大小在运行时计算。理解sizeof的特性和注意事项有助于编写高效可靠的c代码。

sizeof运算符在C语言中主要用于确定变量或数据类型在内存中占用的字节数。它在编译时求值，而非运行时，这使得它在某些情况下非常有用，比如动态内存分配或处理不同数据类型的数组。

sizeof运算符能帮助你理解数据结构在内存中的布局，以及在进行内存操作时确保正确的字节对齐。

sizeof运算符的基本用法

sizeof

可以应用于变量、数据类型或表达式。它返回一个

size_t

类型的值，表示所求对象的大小（以字节为单位）。

立即学习“C语言免费学习笔记（深入）”；

sizeof(变量): 返回变量所占用的内存大小。 sizeof(数据类型): 返回该数据类型所占用的内存大小。 sizeof(表达式): 返回表达式结果的数据类型所占用的内存大小，表达式本身不会被求值。

例如：

#include <stdio.h>
int main() {
    int a = 10;
    float b = 3.14;
    char c = 'A';
    printf("Size of int: %zu bytes\n", sizeof(int));
    printf("Size of variable a: %zu bytes\n", sizeof(a));
    printf("Size of float: %zu bytes\n", sizeof(float));
    printf("Size of variable b: %zu bytes\n", sizeof(b));
    printf("Size of char: %zu bytes\n", sizeof(char));
    printf("Size of variable c: %zu bytes\n", sizeof(c));
    return 0;
}

这段代码会输出

int

、

float

和

char

类型以及相应变量的大小。注意

%zu

是用来打印

size_t

类型的值的格式说明符。

如何使用sizeof计算数组长度

计算数组长度是

sizeof

的一个常见用途。对于静态数组，可以在编译时确定其长度。

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    size_t array_size = sizeof(arr); // 整个数组的大小
    size_t element_size = sizeof(arr[0]); // 数组中一个元素的大小
    size_t array_length = array_size / element_size; // 数组长度
    printf("Array size: %zu bytes\n", array_size);
    printf("Element size: %zu bytes\n", element_size);
    printf("Array length: %zu\n", array_length);
    return 0;
}

这段代码中，

sizeof(arr)

返回整个数组占用的总字节数，而

sizeof(arr[0])

返回数组中一个元素占用的字节数。两者相除即可得到数组的长度。

sizeof用于指针时的注意事项

当

sizeof

应用于指针时，它返回的是指针本身占用的内存大小，而不是指针指向的数据的大小。指针的大小通常是固定的，取决于系统架构（例如，32位系统上指针通常是4字节，64位系统上是8字节）。

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int *ptr = arr;
    printf("Size of pointer: %zu bytes\n", sizeof(ptr)); // 指针的大小
    printf("Size of int: %zu bytes\n", sizeof(int));     // int的大小
    return 0;
}

这段代码会输出指针

ptr

的大小，这通常是4或8字节，取决于你的系统。注意，即使

ptr

指向一个整数数组，

sizeof(ptr)

返回的仍然是指针本身的大小，而不是整个数组的大小。

这意味着，如果你将数组传递给一个函数，并在函数内部使用

sizeof

来计算数组长度，你会得到错误的结果，因为数组会退化为指针。

为什么在函数内部使用sizeof计算数组长度会出错？

当数组作为参数传递给函数时，它会退化为指向数组首元素的指针。这意味着在函数内部，你只能获取到指针的大小，而无法获取到整个数组的大小。

#include <stdio.h>
void print_array_length(int arr[]) {
    size_t array_size = sizeof(arr); // 实际上是指针的大小
    size_t element_size = sizeof(arr[0]); // 数组元素的大小
    size_t array_length = array_size / element_size; // 错误的数组长度
    printf("Array size in function: %zu bytes\n", array_size);
    printf("Element size in function: %zu bytes\n", element_size);
    printf("Array length in function: %zu\n", array_length);
}
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    print_array_length(arr);
    return 0;
}

在这个例子中，

print_array_length

函数接收一个整数数组作为参数。然而，在函数内部，

sizeof(arr)

返回的是指针的大小，而不是整个数组的大小。因此，计算得到的数组长度是错误的。

要解决这个问题，你需要显式地将数组的长度传递给函数：

#include <stdio.h>
void print_array_length(int arr[], size_t length) {
    printf("Array length in function: %zu\n", length);
}
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    size_t array_length = sizeof(arr) / sizeof(arr[0]);
    print_array_length(arr, array_length);
    return 0;
}

这样，函数就能正确地获取到数组的长度。

sizeof与结构体和联合体的关系

sizeof

在处理结构体和联合体时，会考虑到内存对齐。结构体的大小可能大于其成员大小之和，这是因为编译器可能会在成员之间插入填充字节，以确保每个成员都按照其对齐要求存储。

联合体的大小等于其最大成员的大小。

#include <stdio.h>
struct MyStruct {
    char a;
    int b;
    char c;
};
union MyUnion {
    int a;
    double b;
};
int main() {
    printf("Size of MyStruct: %zu bytes\n", sizeof(struct MyStruct));
    printf("Size of MyUnion: %zu bytes\n", sizeof(union MyUnion));
    return 0;
}

在这个例子中，

MyStruct

的大小可能大于

char + int + char

的大小之和，因为编译器可能会为了对齐

int

类型而在

char a

后面插入填充字节。

MyUnion

的大小等于

double

的大小，因为

double

是其中最大的成员。

sizeof在动态内存分配中的作用

在动态内存分配中，

sizeof

用于确定需要分配的内存大小。例如，在使用

malloc

函数分配内存时，你需要指定要分配的字节数。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *arr = (int *)malloc(5 * sizeof(int)); // 分配5个整数的空间
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    free(arr); // 释放内存
    return 0;
}

在这个例子中，

malloc(5 * sizeof(int))

分配了可以存储5个整数的内存空间。

sizeof(int)

确保分配的内存大小与整数类型的大小相匹配。

使用sizeof进行类型安全编程

sizeof

可以帮助你编写类型安全的代码，尤其是在处理不同数据类型的数组或结构体时。通过使用

sizeof

，你可以确保你的代码能够正确地处理不同大小的数据类型，而不会出现内存访问错误。

#include <stdio.h>
int main() {
    int int_array[] = {1, 2, 3, 4, 5};
    float float_array[] = {1.1, 2.2, 3.3, 4.4, 5.5};
    size_t int_length = sizeof(int_array) / sizeof(int_array[0]);
    size_t float_length = sizeof(float_array) / sizeof(float_array[0]);
    printf("Integer array length: %zu\n", int_length);
    printf("Float array length: %zu\n", float_length);
    return 0;
}

这段代码展示了如何使用

sizeof

来计算不同数据类型的数组的长度，从而避免了硬编码数组长度可能导致的错误。

sizeof与可变长数组（VLA）

C99 标准引入了可变长数组（VLA），其大小可以在运行时确定。

sizeof

也可以用于 VLA，但在这种情况下，

sizeof

的值是在运行时计算的。

#include <stdio.h>
int main() {
    int n;
    printf("Enter the size of the array: ");
    scanf("%d", &n);
    int arr[n]; // 可变长数组
    printf("Size of VLA: %zu bytes\n", sizeof(arr));
    return 0;
}

在这个例子中，数组