Question

我正在尝试为无限制的整数操作构建一个简单的库（我知道GMP的存在，仅仅是为了我自己的利益）。我这样做是通过教电脑用小学数组做小学算术。我知道这是一种效率很低的方式，但这是我能想到的，也是最重要的。我已成功为所有四个+ - * /操作编写C代码，但不知何故仅在调试模式下。代码在GDB和Visual Studio 2013调试模式下都可以正常工作;我已经测试了足够多。但是，它在发布模式下的正常执行期间不断吐出错误。我已经搜索过很多关于在调试过程中未检测到发布模式问题的主题，但我发现的解决方案似乎不符合我的情况，至少在我能看到的内容中。

编辑：我的意思是'错误'是我的代码会执行'goto error;'，这意味着计算结果很乱，所以它没有通过我在main中给出的随机整数计算测试（）。这种错误并不总是发生，而是在发布模式下大约10~20次成功操作之后。调试期间不会发生单个（任何常规）错误。

这是我在代码中犯的一个非常简单的错误，一个简短的解决方法会让一切都这么好吗？也许我的整个代码只是一个糟糕的混乱？这是我的Windows 7系统中的一些问题吗？或其他任何可能的？我已经做了我能做的一切来处理这个问题，但现在我只是无能为力。任何帮助都会感激不尽。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define A_PLUS -1
#define A_MINUS -2
#define INT_LEN 10

typedef struct{
    int sign;
    int start;
    char *num;
} abn;

void initABN(abn *n);
void sInitABN(abn *n, char *cs);
void iInitABN(abn *n, int num);
void sReInitABN(abn *n, char *cs);
void iReInitABN(abn *n, int num);
void delABN(abn *n);
int aBigger(const abn *king, const abn *slave);
void aPlus(abn *t, const abn *a, const abn *b);
void aMinus(abn *t, const abn *a, const abn *b);
void printABN(const abn *a);
int abnToInt(const abn *a);
int iPow(int base, int exp);

int fromElse = 0;

int main(){
    srand((unsigned)time(NULL));
    printf("number of tests for each operation: ");
    int testN;
    scanf("%d", &testN);
    printf("\n");
    abn a, b;
    initABN(&a); initABN(&b);
    int i, t1, t2;
    for (i = 0; i < testN; ++i){
        t1 = rand()*(2*(rand() % 2) - 1);
        t2 = rand()*(2*(rand() % 2) - 1);
        iReInitABN(&a, t1);
        iReInitABN(&b, t2);
        printABN(&a);
        printf(" + ");
        printABN(&b);
        printf(" = ");
        aPlus(&a, &a, &b);
        printABN(&a);
        if (t1 + t2 == abnToInt(&a)){
            printf(" TRUE\n");
        }else{
            goto error;
        }
    }
    for (i = 0; i < testN; ++i){
        t1 = rand()*(2*(rand() % 2) - 1);
        t2 = rand()*(2*(rand() % 2) - 1);
        iReInitABN(&a, t1);
        iReInitABN(&b, t2);
        printABN(&a);
        printf(" - ");
        printABN(&b);
        printf(" = ");
        aMinus(&a, &a, &b);
        printABN(&a);
        if (t1 - t2 == abnToInt(&a)){
            printf(" TRUE\n");
        }else{
            goto error;
        }
    }
    delABN(&a); delABN(&b);
    printf("Test Complete!\n");
    return 0;
    error:
    printf("\nERROR\n");
    system("pause");
    return 1;
}

void initABN(abn *n){
    n->num = NULL;
}

void sInitABN(abn *n, char *cs){
    int i;
    for (i = 0; cs[i] != 0; ++i); --i;
    if (cs[0] == '-'){
        n->sign = A_MINUS;
        n->start = i - 1;
        n->num = (char*)malloc(i);
        for (; i > 0; --i){
            n->num[n->start - i + 1] = cs[i] - '0';
        }
    }else{
        n->sign = A_PLUS;
        n->start = i;
        n->num = (char*)malloc(i + 1);
        for (; i >= 0; --i){
            n->num[n->start - i] = cs[i] - '0';
        }
    }
}

void iInitABN(abn *n, int num){
    char *tempCs = (char*)malloc(INT_LEN + 1);
    sprintf(tempCs, "%d", num);
    sInitABN(n, tempCs);
    free(tempCs);
}

void sReInitABN(abn *n, char *cs){
    free(n->num);
    sInitABN(n, cs);
}

void iReInitABN(abn *n, int num){
    char *tempCs = (char*)malloc(INT_LEN + 1);
    sprintf(tempCs, "%d", num);
    sReInitABN(n, tempCs);
    free(tempCs);
}

void delABN(abn *n){
    free(n->num);
    n->num = NULL;
}

int aBigger(const abn *king, const abn *slave){
    int kingSize = king->start, slaveSize = slave->start;
    if (kingSize > slaveSize){
        return 1;
    }
    if (kingSize < slaveSize){
        return 0;
    }
    int i;
    for (i = kingSize; i >= 0; --i){
        if (king->num[i] > slave->num[i]){
            return 1;
        }
        if (king->num[i] < slave->num[i]){
            return 0;
        }
    }
    return 0;
}

void aPlus(abn *t, const abn *a, const abn *b){
    int aSign = a->sign, bSign = b->sign;
    if (!fromElse){
        if (aSign != bSign){
            fromElse = 1;
            aMinus(t, a, b);
            fromElse = 0;
            return;
        }
    }
    char *temp;
    int aStart = a->start, bStart = b->start;
    if (aStart > bStart){
        t->start = aStart + 1;
        temp = (char*)calloc(aStart + 2, 1);
    }else{
        t->start = bStart + 1;
        temp = (char*)calloc(bStart + 2, 1);
    }
    int i, j;
    for (i = 0; i <= aStart; ++i){
        temp[i] += a->num[i];
    }
    for (i = 0; i <= bStart; ++i){
        temp[i] += b->num[i];
        if (temp[i] >= 10){
            temp[i] -= 10;
            ++temp[i + 1];
            for (j = i + 1; ; ++j){
                if (temp[j] >= 10){
                    temp[j] -= 10;
                    ++temp[j + 1];
                }else{
                    break;
                }
            }
        }
    }
    if (temp[t->start] == 0){
        --t->start;
    }
    if (aSign == A_PLUS){
        t->sign = A_PLUS;
    }else{
        t->sign = A_MINUS;
    }
    free(t->num);
    t->num = temp;
}

void aMinus(abn *t, const abn *a, const abn *b){
    int aSign = a->sign, bSign = b->sign;
    if (!fromElse){
        if (aSign != bSign){
            fromElse = 1;
            aPlus(t, a, b);
            fromElse = 0;
            return;
        }
    }
    char *temp;
    int aStart = a->start, bStart = b->start;
    if (aStart > bStart){
        t->start = aStart;
        temp = (char*)calloc(aStart + 1, 1);
    }else{
        t->start = bStart;
        temp = (char*)calloc(bStart + 1, 1);
    }
    int i;
    #define MIN_CALC(A, B)\
        for (i = 0; i <= A##Start; ++i){\
            temp[i] += A->num[i];\
        }\
        for (i = 0; i <= B##Start; ++i){\
            temp[i] -= B->num[i];\
            if (temp[i] < 0){\
                temp[i] += 10;\
                temp[i + 1] -= 1;\
            }\
        }
    if (aBigger(a, b)){
        MIN_CALC(a, b);
        if (aSign == A_PLUS){
            t->sign = A_PLUS;
        }else{
            t->sign = A_MINUS;
        }
    }else{
        MIN_CALC(b, a);
        if (aSign == A_PLUS){
            t->sign = A_MINUS;
        }else{
            t->sign = A_PLUS;
        }
    }
    for (i = t->start; i > 0; --i){
        if (temp[i] == 0){
            --t->start;
        }else{
            break;
        }
    }
    free(t->num);
    t->num = temp;
}

void printABN(const abn *a){
    if (a->start == 0 && a->num[0] == 0){
        printf("0");
        return;
    }
    if (a->sign == A_MINUS){
        printf("-");
    }
    int i;
    for (i = a->start; i >= 0; --i){
        printf("%d", a->num[i]);
    }
}

int abnToInt(const abn *a){
    int i, n = 0;
    for (i = 0; i <= a->start; ++i){
        n += a->num[i]*iPow(10, i);
    }
    if (a->sign == A_MINUS){
        n *= -1;
    }
    return n;
}

int iPow(int base, int exp){
    int n = 1;
    int i;
    for (i = 0; i < exp; ++i){
        n *= base;
    }
    return n;
}

Answer 1

这是因为t和a指向相同的值。修改t指向的值时，它还会修改a指向的值。

在aMinus函数中，您在a->start的调用中间接使用aBigger的值。但是，您之前已在函数中更改了t->start的值，因此更改了a->start。

以下是解决问题的三种方法：

更改代码以便稍后在函数中对t->start进行修改（将值保存到新的局部变量并在需要之前进行设置）可以解决该问题。我认为这是最好的方式。
更改aBigger函数以将长度作为参数，并使用aStart和bstart作为值，但仍然意味着您已更改a->start和可能忘记并更改代码以便将来使用a->start。
更改调用以将加法或减法的结果放入另一个变量中。这有效，但它仍然意味着您的功能存在潜在的漏洞。

我无法解释为什么它在调试模式下工作或者在调试发布模式时，我会尝试单步执行并查看是否可以进一步跟踪它。

c：调试和发布模式的区别？

1 个答案: