c++ - c: 调试和 Release模式的区别？

Question

我正在尝试为不受限制的整数运算构建一个简单的库(我知道 GMP 的存在，只是为了我自己的兴趣)。我通过教计算机用 char 数组做小学算术来做到这一点。我知道这是一种非常低效的方式，但这是我能想到的并且正在努力做到的。我已经成功地为所有四个 +-*/操作编写了 C 代码，但不知何故只在 Debug模式下。该代码在 GDB 和 Visual Studio 2013 Debug模式下都运行良好；我已经测试了足够多的。但是，它在 Release模式下正常执行期间不断吐出错误。我在调试期间未检测到 Release模式问题这个主题上进行了很多搜索，但我发现的解决方案似乎不适合我的情况，至少在我所看到的范围内。

编辑:我所说的“错误”是指我的代码会执行“goto error;”，这意味着计算结果一团糟，所以它没有通过我在 main 中给出的随机整数计算测试().这种错误并不总是发生，而是在 Release模式下大约 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 函数中，您在调用 aBigger 时间接使用了 a->start 的值。但是，您已经更改了 t->start 的值，因此在函数的前面更改了 a->start。

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

1. 更改代码以便在函数中稍后对 t->start 进行修改(将值保存到新的局部变量并在需要它之前进行设置)修复了该问题.我认为这是最好的方法。

2. 更改 aBigger 函数以将长度作为参数并使用 aStart 和 bstart 作为值有效，但仍然意味着您更改了 a->start 并且可能会忘记并更改代码以在将来使用 a->start。

3. 更改调用以将加法或减法的结果放入不同的变量中。这可行，但它仍然意味着您的函数存在潜在漏洞。

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