c - 由于无效分配而导致 SegFault？

Question

我有一个在公共(public)结构中声明的数组，如下所示:

uint16_t *registers;

在一个函数中，我正在检索一个字符字符串(存储在缓冲区中，请参阅下面的代码)，其中包含以逗号分隔的数值(例如“1,12,0,136,5,76,1243”)。我的目标是获取每个单独的数值并将其依次存储在数组中。

i = 0;
const char delimiter[] = ",";
char *end;

tmp.vals = strtok(buffer, delimiter);
while (tmp.vals != NULL) {
    tmp.registers[i] = strtol(tmp.vals, &end, 10);
    tmp.vals = strtok(NULL, delimiter);
    i++;
}

问题是包含 strtol 的行产生段错误(核心转储)错误。我很确定这是由于尝试将无符号长值放入 uint16_t 数组槽引起的，但无论我尝试什么，我都无法修复它。

<小时/>

按如下方式更改代码似乎已经解决了问题:

unsigned long num = 0;
size_t size = 0;
i = 0;

size = 1;
tmp.vals = (char *)calloc(strlen(buffer) + 1, sizeof(char));
tmp.registers = (uint16_t *)calloc(size, sizeof(uint16_t));
tmp.vals = strtok(buffer, delimiter);
while (tmp.vals != NULL) {
    num = strtoul(tmp.vals, &end, 10);
    if (0 <= num && num < 65536) {
        tmp.registers = (uint16_t *)realloc(tmp.registers, size + i);
        tmp.registers[i] = (uint16_t)num;
    } else {
        fprintf(stderr, "==> %lu is too large to fit in register[%d]\n", num, i);
    }
    tmp.vals = strtok(NULL, delimiter);
    i++;
}

Answer 1

A long integer is at least 32 bits ，所以是的，尝试将有符号 32 位整数插入无符号 16 位整数时，您将丢失信息。如果您有编译器警告(我使用 -Wall -Wshadow -Wwrite-strings -Wextra -Wconversion -std=c99 -pedantic)，它应该会告诉您这一点。

test.c:20:28: warning: implicit conversion loses integer precision: 'long' to 'uint16_t'
      (aka 'unsigned short') [-Wconversion]
        tmp.registers[i] = strtol(tmp.vals, &end, 10);
                         ~ ^~~~~~~~~~~~~~~~~~~~~~~~~~

但是，这不会导致段错误。您将丢失 16 位，并且符号的变化会产生有趣的事情。

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

int main() {
    long big = 1234567;
    uint16_t small = big;
    printf("big = %ld, small = %" PRIu16 "\n", big, small);
}

如果您知道您正在读取的内容适合 16 位，您可以先使用 strtoul 读取，让事情变得更安全一些>unsigned long，验证它是否足够小以适合，并显式转换它。

    unsigned long num = strtoul(tmp.vals, &end, 10);
    if( 0 <= num && num < 65536 ) {
        tmp.registers[i] = (uint16_t)num;
    }
    else {
        fprintf(stderr, "%lu is too large to fit in the register\n", num);
    }

<小时/>

更有可能的是tmp.registers(也可能是buffer)没有正确初始化并分配了垃圾点。如果您只是像这样在堆栈上声明 tmp:

Registers tmp;

这只为tmp分配内存，而不是它指向的东西。而且里面会含有垃圾。 tmp.registers 将指向内存中的某个随机位置。当你尝试写入它时，它最终会出现段错误。

需要分配寄存器数组。

size_t how_many = 10;
uint16_t *registers = malloc( sizeof(uint16_t) * how_many );
Thing tmp = {
    .registers = registers,
    .vals = NULL
};

<小时/>

只要你的循环只运行 how_many 次就可以了。但在读取输入时您无法确定这一点。您的循环可能会读取无限数量的寄存器。如果它超过了我们分配的 10 个，它将再次开始写入其他人的内存并出现段错误。

动态内存对于这里来说是一个太大的话题，但我们至少可以通过跟踪寄存器的最大大小及其长度来将循环限制为数组的大小。我们可以在循环中完成它，但它确实属于结构体。

typedef struct {
    uint16_t *registers;
    char *vals;
    size_t max;
    size_t size;
} Registers;

当我们这样做时，将初始化放入一个函数中，这样我们就可以确保它每次都可靠地完成。

void Registers_init( Registers *registers, size_t size ) {
    registers->registers = malloc( sizeof(uint16_t) * size );
    registers->max = size;
    registers->size = 0;
}

与我们的边界检查相同。

void Registers_push( Registers *registers, uint16_t num ) {
    if( registers->size == registers->max ) {
        fprintf(stderr, "Register has reached its limit of %zu\n", registers->max);
        exit(1);
    }
    registers->registers[ registers->size ] = (uint16_t)num;
    registers->size++;
}

现在我们可以安全地添加寄存器了。或者至少它会很好地出错。

Registers registers;
Registers_init( &registers, 10 );

tmp.vals = strtok(buffer, delimiter);
while (tmp.vals != NULL) {
    unsigned long num = strtoul(tmp.vals, &end, 10);
    if( 0 <= num && num < 65536 ) {
        Registers_push( &tmp, (uint16_t)num );
    }
    else {
        fprintf(stderr, "%lu is too large to fit in the register\n", num);
    } 
    tmp.vals = strtok(NULL, delimiter);
    i++;
}

此时我们正在重新实现一个大小限制数组。这是一个很好的练习，但对于生产代码 use an existing library such as GLib 来说，它提供了自增长数组和更多功能。