C语言教程

Appearance

C 标准库 - <stdint.h> ​

概述 ​

<stdint.h> 头文件定义了精确宽度的整数类型，确保在不同平台上具有相同的大小。这是 C99 标准引入的头文件，对于跨平台编程非常重要。

精确宽度整数类型 ​

int8_t ​

8 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int8_t value = 127;
    printf("int8_t 值: %d\n", value);
    printf("int8_t 大小: %zu 字节\n", sizeof(int8_t));
    
    return 0;
}

int16_t ​

16 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int16_t value = 32767;
    printf("int16_t 值: %d\n", value);
    printf("int16_t 大小: %zu 字节\n", sizeof(int16_t));
    
    return 0;
}

int32_t ​

32 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int32_t value = 2147483647;
    printf("int32_t 值: %d\n", value);
    printf("int32_t 大小: %zu 字节\n", sizeof(int32_t));
    
    return 0;
}

int64_t ​

64 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int64_t value = 9223372036854775807LL;
    printf("int64_t 值: %lld\n", value);
    printf("int64_t 大小: %zu 字节\n", sizeof(int64_t));
    
    return 0;
}

uint8_t ​

8 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint8_t value = 255;
    printf("uint8_t 值: %u\n", value);
    printf("uint8_t 大小: %zu 字节\n", sizeof(uint8_t));
    
    return 0;
}

uint16_t ​

16 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint16_t value = 65535;
    printf("uint16_t 值: %u\n", value);
    printf("uint16_t 大小: %zu 字节\n", sizeof(uint16_t));
    
    return 0;
}

uint32_t ​

32 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint32_t value = 4294967295U;
    printf("uint32_t 值: %u\n", value);
    printf("uint32_t 大小: %zu 字节\n", sizeof(uint32_t));
    
    return 0;
}

uint64_t ​

64 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint64_t value = 18446744073709551615ULL;
    printf("uint64_t 值: %llu\n", value);
    printf("uint64_t 大小: %zu 字节\n", sizeof(uint64_t));
    
    return 0;
}

最小宽度整数类型 ​

int_least8_t ​

至少 8 位的有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_least8_t value = 127;
    printf("int_least8_t 值: %d\n", value);
    printf("int_least8_t 大小: %zu 字节\n", sizeof(int_least8_t));
    
    return 0;
}

int_least16_t ​

至少 16 位的有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_least16_t value = 32767;
    printf("int_least16_t 值: %d\n", value);
    printf("int_least16_t 大小: %zu 字节\n", sizeof(int_least16_t));
    
    return 0;
}

int_least32_t ​

至少 32 位的有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_least32_t value = 2147483647;
    printf("int_least32_t 值: %d\n", value);
    printf("int_least32_t 大小: %zu 字节\n", sizeof(int_least32_t));
    
    return 0;
}

int_least64_t ​

至少 64 位的有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_least64_t value = 9223372036854775807LL;
    printf("int_least64_t 值: %lld\n", value);
    printf("int_least64_t 大小: %zu 字节\n", sizeof(int_least64_t));
    
    return 0;
}

uint_least8_t ​

至少 8 位的无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_least8_t value = 255;
    printf("uint_least8_t 值: %u\n", value);
    printf("uint_least8_t 大小: %zu 字节\n", sizeof(uint_least8_t));
    
    return 0;
}

uint_least16_t ​

至少 16 位的无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_least16_t value = 65535;
    printf("uint_least16_t 值: %u\n", value);
    printf("uint_least16_t 大小: %zu 字节\n", sizeof(uint_least16_t));
    
    return 0;
}

uint_least32_t ​

至少 32 位的无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_least32_t value = 4294967295U;
    printf("uint_least32_t 值: %u\n", value);
    printf("uint_least32_t 大小: %zu 字节\n", sizeof(uint_least32_t));
    
    return 0;
}

uint_least64_t ​

至少 64 位的无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_least64_t value = 18446744073709551615ULL;
    printf("uint_least64_t 值: %llu\n", value);
    printf("uint_least64_t 大小: %zu 字节\n", sizeof(uint_least64_t));
    
    return 0;
}

最快最小宽度整数类型 ​

int_fast8_t ​

最快的至少 8 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_fast8_t value = 127;
    printf("int_fast8_t 值: %d\n", value);
    printf("int_fast8_t 大小: %zu 字节\n", sizeof(int_fast8_t));
    
    return 0;
}

int_fast16_t ​

最快的至少 16 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_fast16_t value = 32767;
    printf("int_fast16_t 值: %d\n", value);
    printf("int_fast16_t 大小: %zu 字节\n", sizeof(int_fast16_t));
    
    return 0;
}

int_fast32_t ​

最快的至少 32 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_fast32_t value = 2147483647;
    printf("int_fast32_t 值: %d\n", value);
    printf("int_fast32_t 大小: %zu 字节\n", sizeof(int_fast32_t));
    
    return 0;
}

int_fast64_t ​

最快的至少 64 位有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int_fast64_t value = 9223372036854775807LL;
    printf("int_fast64_t 值: %lld\n", value);
    printf("int_fast64_t 大小: %zu 字节\n", sizeof(int_fast64_t));
    
    return 0;
}

uint_fast8_t ​

最快的至少 8 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_fast8_t value = 255;
    printf("uint_fast8_t 值: %u\n", value);
    printf("uint_fast8_t 大小: %zu 字节\n", sizeof(uint_fast8_t));
    
    return 0;
}

uint_fast16_t ​

最快的至少 16 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_fast16_t value = 65535;
    printf("uint_fast16_t 值: %u\n", value);
    printf("uint_fast16_t 大小: %zu 字节\n", sizeof(uint_fast16_t));
    
    return 0;
}

uint_fast32_t ​

最快的至少 32 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_fast32_t value = 4294967295U;
    printf("uint_fast32_t 值: %u\n", value);
    printf("uint_fast32_t 大小: %zu 字节\n", sizeof(uint_fast32_t));
    
    return 0;
}

uint_fast64_t ​

最快的至少 64 位无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uint_fast64_t value = 18446744073709551615ULL;
    printf("uint_fast64_t 值: %llu\n", value);
    printf("uint_fast64_t 大小: %zu 字节\n", sizeof(uint_fast64_t));
    
    return 0;
}

指针宽度整数类型 ​

intptr_t ​

能够保存指针的有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int value = 42;
    int* ptr = &value;
    
    intptr_t ptr_value = (intptr_t)ptr;
    printf("指针值: %td\n", ptr_value);
    printf("intptr_t 大小: %zu 字节\n", sizeof(intptr_t));
    
    return 0;
}

uintptr_t ​

能够保存指针的无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int value = 42;
    int* ptr = &value;
    
    uintptr_t ptr_value = (uintptr_t)ptr;
    printf("指针值: %tu\n", ptr_value);
    printf("uintptr_t 大小: %zu 字节\n", sizeof(uintptr_t));
    
    return 0;
}

最大宽度整数类型 ​

intmax_t ​

最大宽度的有符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    intmax_t value = 9223372036854775807LL;
    printf("intmax_t 值: %jd\n", value);
    printf("intmax_t 大小: %zu 字节\n", sizeof(intmax_t));
    
    return 0;
}

uintmax_t ​

最大宽度的无符号整数类型。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    uintmax_t value = 18446744073709551615ULL;
    printf("uintmax_t 值: %ju\n", value);
    printf("uintmax_t 大小: %zu 字节\n", sizeof(uintmax_t));
    
    return 0;
}

限制宏 ​

INT8_MIN, INT8_MAX ​

int8_t 的最小值和最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("INT8_MIN: %d\n", INT8_MIN);
    printf("INT8_MAX: %d\n", INT8_MAX);
    
    return 0;
}

UINT8_MAX ​

uint8_t 的最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("UINT8_MAX: %u\n", UINT8_MAX);
    
    return 0;
}

INT16_MIN, INT16_MAX ​

int16_t 的最小值和最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("INT16_MIN: %d\n", INT16_MIN);
    printf("INT16_MAX: %d\n", INT16_MAX);
    
    return 0;
}

UINT16_MAX ​

uint16_t 的最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("UINT16_MAX: %u\n", UINT16_MAX);
    
    return 0;
}

INT32_MIN, INT32_MAX ​

int32_t 的最小值和最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("INT32_MIN: %d\n", INT32_MIN);
    printf("INT32_MAX: %d\n", INT32_MAX);
    
    return 0;
}

UINT32_MAX ​

uint32_t 的最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("UINT32_MAX: %u\n", UINT32_MAX);
    
    return 0;
}

INT64_MIN, INT64_MAX ​

int64_t 的最小值和最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("INT64_MIN: %lld\n", INT64_MIN);
    printf("INT64_MAX: %lld\n", INT64_MAX);
    
    return 0;
}

UINT64_MAX ​

uint64_t 的最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("UINT64_MAX: %llu\n", UINT64_MAX);
    
    return 0;
}

INTMAX_MIN, INTMAX_MAX ​

intmax_t 的最小值和最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("INTMAX_MIN: %jd\n", INTMAX_MIN);
    printf("INTMAX_MAX: %jd\n", INTMAX_MAX);
    
    return 0;
}

UINTMAX_MAX ​

uintmax_t 的最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("UINTMAX_MAX: %ju\n", UINTMAX_MAX);
    
    return 0;
}

PTRDIFF_MIN, PTRDIFF_MAX ​

ptrdiff_t 的最小值和最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("PTRDIFF_MIN: %td\n", PTRDIFF_MIN);
    printf("PTRDIFF_MAX: %td\n", PTRDIFF_MAX);
    
    return 0;
}

SIZE_MAX ​

size_t 的最大值。

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("SIZE_MAX: %zu\n", SIZE_MAX);
    
    return 0;
}

实际应用示例 ​

1. 网络协议 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint8_t version;
    uint8_t type;
    uint16_t length;
    uint32_t sequence;
} PacketHeader;

void print_header(const PacketHeader* header) {
    printf("版本: %u\n", header->version);
    printf("类型: %u\n", header->type);
    printf("长度: %u\n", header->length);
    printf("序列号: %u\n", header->sequence);
}

int main() {
    PacketHeader header = {
        .version = 1,
        .type = 2,
        .length = 1024,
        .sequence = 12345
    };
    
    print_header(&header);
    
    return 0;
}

2. 文件格式 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint8_t signature[4];
    uint16_t width;
    uint16_t height;
    uint8_t bits_per_pixel;
    uint32_t data_size;
} ImageHeader;

void print_image_info(const ImageHeader* header) {
    printf("签名: %c%c%c%c\n", 
           header->signature[0], header->signature[1],
           header->signature[2], header->signature[3]);
    printf("宽度: %u\n", header->width);
    printf("高度: %u\n", header->height);
    printf("每像素位数: %u\n", header->bits_per_pixel);
    printf("数据大小: %u 字节\n", header->data_size);
}

int main() {
    ImageHeader header = {
        .signature = {'B', 'M', 'P', '\0'},
        .width = 800,
        .height = 600,
        .bits_per_pixel = 24,
        .data_size = 800 * 600 * 3
    };
    
    print_image_info(&header);
    
    return 0;
}

3. 哈希值 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint32_t hash[5];
} SHA1Hash;

void print_hash(const SHA1Hash* hash) {
    printf("SHA1: ");
    for (int i = 0; i < 5; i++) {
        printf("%08x", hash->hash[i]);
    }
    printf("\n");
}

int main() {
    SHA1Hash hash = {
        .hash = {0xda39a3ee, 0x5e6b4b0d, 0x3255bfef, 0x95601890, 0xafd80709}
    };
    
    print_hash(&hash);
    
    return 0;
}

4. 时间戳 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint32_t seconds;
    uint32_t microseconds;
} Timestamp;

void print_timestamp(const Timestamp* ts) {
    printf("时间戳: %u.%06u 秒\n", ts->seconds, ts->microseconds);
}

int main() {
    Timestamp ts = {
        .seconds = 1704067200,
        .microseconds = 123456
    };
    
    print_timestamp(&ts);
    
    return 0;
}

5. 内存地址 ​

c
#include <stdio.h>
#include <stdint.h>

void print_pointer_address(void* ptr) {
    uintptr_t address = (uintptr_t)ptr;
    printf("指针地址: 0x%016lx\n", address);
}

int main() {
    int value = 42;
    int* ptr = &value;
    
    print_pointer_address(ptr);
    
    return 0;
}

6. 大整数计算 ​

c
#include <stdio.h>
#include <stdint.h>

uint64_t factorial(uint8_t n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    for (uint8_t i = 0; i <= 20; i++) {
        printf("%u! = %llu\n", i, factorial(i));
    }
    
    return 0;
}

7. 位操作 ​

c
#include <stdio.h>
#include <stdint.h>

void print_bits(uint32_t value) {
    for (int i = 31; i >= 0; i--) {
        printf("%d", (value >> i) & 1);
        if (i % 8 == 0 && i != 0) {
            printf(" ");
        }
    }
    printf("\n");
}

int main() {
    uint32_t value = 0x12345678;
    
    printf("原始值: 0x%08x\n", value);
    printf("二进制: ");
    print_bits(value);
    
    return 0;
}

8. 跨平台数据结构 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    int32_t x;
    int32_t y;
} Point2D;

typedef struct {
    int32_t x;
    int32_t y;
    int32_t z;
} Point3D;

void print_point2d(const Point2D* point) {
    printf("Point2D: (%d, %d)\n", point->x, point->y);
}

void print_point3d(const Point3D* point) {
    printf("Point3D: (%d, %d, %d)\n", point->x, point->y, point->z);
}

int main() {
    Point2D p2d = {10, 20};
    Point3D p3d = {10, 20, 30};
    
    print_point2d(&p2d);
    print_point3d(&p3d);
    
    return 0;
}

9. 颜色值 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    uint8_t alpha;
} RGBAColor;

void print_color(const RGBAColor* color) {
    printf("RGBA: (%u, %u, %u, %u)\n", 
           color->red, color->green, color->blue, color->alpha);
}

int main() {
    RGBAColor red = {255, 0, 0, 255};
    RGBAColor green = {0, 255, 0, 255};
    RGBAColor blue = {0, 0, 255, 255};
    
    print_color(&red);
    print_color(&green);
    print_color(&blue);
    
    return 0;
}

10. 版本号 ​

c
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint16_t major;
    uint16_t minor;
    uint16_t patch;
} Version;

void print_version(const Version* version) {
    printf("版本: %u.%u.%u\n", 
           version->major, version->minor, version->patch);
}

int main() {
    Version version = {1, 2, 3};
    
    print_version(&version);
    
    return 0;
}

注意事项 ​

1. 溢出检查 ​

c
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

bool will_add_overflow(uint32_t a, uint32_t b) {
    return a > UINT32_MAX - b;
}

int main() {
    uint32_t a = 4000000000U;
    uint32_t b = 500000000U;
    
    if (will_add_overflow(a, b)) {
        printf("加法会溢出\n");
    } else {
        printf("加法不会溢出\n");
    }
    
    return 0;
}

2. 类型转换 ​

c
#include <stdio.h>
#include <stdint.h>

int main() {
    int32_t signed_value = -1;
    uint32_t unsigned_value = (uint32_t)signed_value;
    
    printf("有符号值: %d\n", signed_value);
    printf("无符号值: %u\n", unsigned_value);
    
    return 0;
}

3. 平台兼容性 ​

c
#include <stdio.h>
#include <stdint.h>

int main() {
    printf("int8_t 大小: %zu\n", sizeof(int8_t));
    printf("int16_t 大小: %zu\n", sizeof(int16_t));
    printf("int32_t 大小: %zu\n", sizeof(int32_t));
    printf("int64_t 大小: %zu\n", sizeof(int64_t));
    
    return 0;
}

4. 格式化输出 ​

c
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main() {
    int32_t value = 123456789;
    uint64_t large_value = 18446744073709551615ULL;
    
    printf("int32_t: %" PRId32 "\n", value);
    printf("uint64_t: %" PRIu64 "\n", large_value);
    
    return 0;
}

总结 ​

<stdint.h> 提供的精确宽度整数类型对于跨平台编程非常重要：

  1. 精确控制 - 确保整数类型在不同平台上具有相同的大小
  2. 可移植性 - 提高代码的可移植性和兼容性
  3. 类型安全 - 明确的整数类型定义
  4. 广泛应用 - 适用于网络协议、文件格式、哈希值等场景

记住：

  • 使用精确宽度类型确保跨平台一致性
  • 注意整数溢出问题
  • 使用合适的格式化输出宏
  • 在需要指针操作时使用 intptr_t 或 uintptr_t
  • 选择合适的整数类型以满足性能和存储需求

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1