C++ 调试和发布模式的区别？

我正试图为无边界的整数运算构建一个简单的库（我知道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;
}

#包括
#包括
#包括
#定义一个加号-1
#定义一个_减-2
#定义整数10
类型定义结构{
整数符号；
int启动；
字符*num；
}荷兰银行；
无效初始值（abn*n）；
void sInitABN（abn*n，char*cs）；
无效iInitABN（abn*n，整数）；
void sReInitABN（abn*n，char*cs）；
void iReInitABN（abn*n，int num）；
无效delABN（abn*n）；
int-aBigger（const-abn*国王，const-abn*奴隶）；
无效aPlus（abn*t，常数abn*a，常数abn*b）；
无效阿米努斯（abn*t，常数abn*a，常数abn*b）；
无效打印abn（常量abn*a）；
内部异常（常量异常*a）；
int-iPow（int-base，int-exp）；
int-fromlse=0；
int main（）{
srand（（无符号）时间（NULL））；
printf（“每次操作的测试次数：”）；
int-testN；
scanf（“%d”、&testN）；
printf（“\n”）；
荷兰银行a、b；
initABN&a；initABN&b；
inti，t1，t2；
对于（i=0；inum=NULL；
}
void sInitABN（abn*n，char*cs）{
int i；
对于（i=0；cs[i]！=0；++i）；--i；
如果（cs[0]='-'）{
n->符号=A_减号；
n->start=i-1；
n->num=（char*）malloc（i）；
对于（；i>0；--i）{
n->num[n->start-i+1]=cs[i]-“0”；
}
}否则{
n->sign=A_加号；
n->start=i；
n->num=（char*）malloc（i+1）；
对于（；i>=0；--i）{
n->num[n->start-i]=cs[i]-“0”；
}
}
}
无效iInitABN（abn*n，整数）{
char*tempCs=（char*）malloc（整数+1）；
sprintf（tempCs，“%d”，num）；
左旋（n，tempCs）；
免费（临时工）；
}
void sReInitABN（abn*n，char*cs）{
自由（n->num）；
左旋多巴（n，cs）；
}
void iReInitABN（abn*n，int num）{
char*tempCs=（char*）malloc（整数+1）；
sprintf（tempCs，“%d”，num）；
sReInitABN（n，tempCs）；
免费（临时工）；
}
无效delABN（abn*n）{
自由（n->num）；
n->num=NULL；
}
内特阿比格尔（康斯特阿布尼*国王，康斯特阿布尼*奴隶）{
int kingSize=king->start，slaveSize=slave->start；
如果（国王尺寸>奴隶尺寸）{
返回1；
}
如果（国王大小<奴隶大小）{
返回0；
}
int i；
对于（i=kingSize；i>=0；--i）{
如果（国王->数量[i]>奴隶->数量[i]）{
返回1；
}
如果（国王->数量[i]<奴隶->数量[i]）{
返回0；
}
}
返回0；
}
无效aPlus（abn*t，常数abn*a，常数abn*b）{
int aSign=a->符号，bSign=b->符号；
if（！fromElse）{
如果（aSign！=bSign）{
fromElse=1；
阿米纳斯（t，a，b）；
fromElse=0；
返回；
}
}
字符*温度；
int aStart=a->start，bStart=b->start；
如果（开始>开始）{
t->start=aStart+1；
temp=（char*）calloc（aStart+2,1）；
}否则{
t->start=b开始+1；
temp=（char*）calloc（bStart+2,1）；
}
int i，j；
for（i=0；i num[i]；
}
for（i=0；i num[i]；
如果（温度[i]>=10）{
温度[i]-=10；
++温度[i+1]；
对于（j=i+1；；++j）{
如果（温度[j]>=10）{
温度[j]-=10；
++温度[j+1]；
}否则{
打破
}
}
}
}
如果（温度[t->开始]==0）{
--t->启动；
}
如果（aSign==A加）{
t->符号=A_加号；
}否则{
t->符号=A_减号；
}
自由（t->num）；
t->num=温度；
}
无效阿米努斯（abn*t，常数abn*a，常数abn*b）{
int aSign=a->符号，bSign=b->符号；
if（！fromElse）{
如果（aSign！=bSign）{