如何消除分割错误？ #包括 #包括 #包括 #包括 #包括 int getCharNum（int a）{返回a/（8*sizeof（char））；} int getBitNum（int a）{返回一个%（8*sizeof（char））；} intfromCharnum（inta）{返回一个*8*sizeof（char）；} int get2DimI（int a）{return getCharNum（a）/187500；} int get2DimJ（int a）{return getCharNum（a）%187500；} void rle_压缩（char*src，char*dst，int ls，int*ld）{ uint8_t t[129]； int i，j=0，k=0，保持； char out[187500]； t[0]=src[j]； while（j++

如何修复此代码？

---

我正在尝试压缩字节数组（由于

n

应该是

代码不清楚，但存在一些主要问题：


void rle_extract（char*src，char*dst，int ls）
不会从调用方获取输出缓冲区，也不会返回指向它的指针：
dst=out；
只更新参数值，而不是作为参数传递的调用方变量。此外，
返回0；
来自
void
函数的
也不正确

在任何情况下，
rle_extract
都不应返回其本地
out
缓冲区，因为它仅在函数执行期间定义，并在函数返回时立即丢弃

您应该将缓冲区作为参数传递，或者在本地分配它并将指针返回给调用方

可能还有其他问题，没有解释代码应该做什么。
使用调试器。它会立即准确地告诉您哪行代码触发seg故障。这是您应该为自己和堆栈重叠收集的最低信息。调试器还可以用于单步执行代码并在代码运行时检查它。此外，建议您应用良好的编码实践，使代码可调试（对您和其他人）-使用注释，使用有意义的变量名（而不是单个字母），使用
#定义
值而不是幻数。chrqlie提到的问题是关于
dst/out
。或者将arg名称从
dst
更改为
out
[并移除本地缓冲区]或者：改为：
char*out=dst；
。似乎压缩和解压缩函数都有这个问题。在
main
中，堆栈上有
char-dst[187500]
。在
main
中，您可以添加
static
[或者按注释执行
malloc
]。这只是为了消除segfault是由堆栈溢出引起的可能性。代码运行后，如果您选择，您可以还原此值。@CraigEstey程序不应该使用与以前相同的压缩量（如果按此方式编辑）？而且这不是唯一的问题，因为它仍然会给出segfault，而是根据另一行上的gdb。代码用于从输入中输出唯一值，假设只有3个，则所有其他值都显示两次。主要思想：第i位表示第i个自然数（仅显示0到1.5*10^9的数字），每次数字出现时，对应位都会反转，所以答案是所有1位的数字。由于数字数量的限制（少于1500000）和内存限制（64MiB）我必须使用运行长度编码压缩字节数组。我尝试注释代码并修复所述问题，但仍然存在segfault（但根据gdb在其他地方）。
#include <stdio.h>
#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>

int getCharNum(int a) { return a / (8 * sizeof(char)); }
int getBitNum(int a) { return a % (8 * sizeof(char)); }
int fromCharNum(int a) { return a * 8 * sizeof(char); }
int get2DimI(int a) { return getCharNum(a) / 187500; }
int get2DimJ(int a) { return getCharNum(a) % 187500; }

void rle_compress(char *src, char *dst, int ls, int *ld) {
    uint8_t t[129];
    int i, j = 0, k = 0, keep;
    char out[187500];
    t[0] = src[j];
    while (j++ < ls) {
        t[1] = src[j];
        if (t[0] != t[1]) {
            i = 1;
            if (j < ls)
                do
                    t[++i] = src[++j];
                while (j < ls && i < 128 && t[i] != t[i - 1]);
            if ((keep = t[i] == t[i - 1]))
                --i;
            out[k++] = (char)i;
            t[0] = t[i];
            if (!keep)
                continue;
        }
        i = 2;
        do
            t[1] = src[++j];
        while (++i < 130 && t[0] == t[1]);
        out[k++] = i + 125;
        out[k++] = t[0];
        t[0] = t[1];
    }
    ld = &k;
    dst = out;
}

void rle_extract(char *src, char *dst, int ls) {
    int i, j, l = 0, k = 0, max;
    char out[187500];
    j = 0;
    while (k + 2 < ls) {
        i = src[k++];  //segfault
        j = src[k++];
        max = i + (i < 128 ? 1 : -126);
        while (max--)
            out[l++] = j;
    }
    dst = out;
    return 0;
}

int main(void) {
    int32_t n = 0;

    scanf("%d", &n);
    int32_t a[n];
    int32_t b[] = { -1, -1, -1 };
    char **count;
    count = (char**)malloc(1000 * sizeof(char*));
    int count_l[] = { [999] = 0 };
    for (int i = 0; i < 1000; ++i) {
        count[i] = (char*)malloc(187500 * sizeof(char));
        char *temp = NULL;
        rle_compress(count[i], temp, 187500, &count_l[i]);
        free(count[i]);
        count[i] = temp;
    }
    for (int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    for (int i = 0; i < n; i++) {
        char *src = count[get2DimI(a[i]) / 187500];
        char dst[187500];
        rle_extract(src, dst, count_l[i / 187500]);
        dst[get2DimJ(a[i])] ^= 1 << (getBitNum(a[i]));
        rle_compress(dst, count[get2DimI(a[i]) / 187500], 187500, &count_l[i]);
    }
    int32_t mv = 187500000 / (8 * sizeof(char));
    int j = 0;
    for (int i = 0; i < mv; i++) {
        char *src = count[i / 187500];
        char dst[187500];
        rle_extract(src, dst, count_l[i / 187500]);
        int32_t x = dst[i % 187500];
        if (x == 0)
            continue;
        for (int k = 0; k < 8 * sizeof(char); k++) {
            if ((x >> (k)) & 1) {
                b[j++] = fromCharNum(i) + k;
            }
        }
        //free(dst);
    }
    int m1 = min(b[0], min(b[1], b[2])),
        m3 = max(b[0], max(b[1], b[2])),
        m2 = b[0] + b[1] + b[2] - m1 - m3;
    printf("%d %d %d", m1, m2, m3);
    for (int i = 0; i < 1000; ++i)
        free(count[i]);
    free(count);
    return 0;
}