Программа бьётся и указывает на файл free.c
От: RussianFellow Россия http://russianfellow.livejournal.com
Дата: 14.01.20 13:33
Оценка: :))
Я пишу свой проект на Visual Studio 2012, версия моего проекта Release.

В диалоговом окне у меня расположена кнопка "Выполнить" и многострочное текстовое поле (класс CEdit). После нажатия на кнопку "Выполнить" программа выполняет все необходимые действия, выводит многострочный текст в это текстовое поле, но на команде return у меня выбрасывается окно с сообщением:

MyProgram.exe вызвал срабатывание точки останова.

После нажатия на кнопку "Продолжить" опять выбрасывается это окно, а после повторного нажатия на кнопку "Продолжить" в этом окне происходит завершение работы этой функции.
При этом, когда выбрасывается это окно, то у меня выскакивает файл free.c на функции _free_base:

void __cdecl _free_base (void * pBlock)
{
    int  retval = 0;
    if (pBlock==NULL)
        return;
    RTCCALLBACK(_RTC_Free_hook,(pBlock,0));
    retval = HeapFree(_crtheap,0,pBlock);
    if (retval==0) // курсор в отладчике становится здесь
    {
        errno = _get_errno_from_oserr(GetLastError());
    }
}


Что бы это значило? Как исправить эту ошибку--чтобы не выскакивало это окно с сообщением?

Код моей функции:

void CBroachDialog3::OnBnClickedButton1()
// если была нажата кнопка "Выполнить"
{
    // TODO: добавьте свой код обработчика уведомлений
    int  i, j, n, m, len, year, month, day, hour, minute, year2, month2, day2, hour2, minute2, intsat, PR_atm, icount, currcorr, numcorr, atm;
    int  yearstart, monthstart, daystart, hourstart, minutestart;
    long double  secondstart;
    long  jtstart, jtcorr[3];
    long double  second, second2, partDay, partDay2, val, tjstart, partDaystart, deltat, tjcorr[3];
    char  /* sresult[1024], */ sresult[2048], s[80], syear[5], smonth[3], sday[3], shour[3], sminute[3], ssecond[20], syear2[5], smonth2[3], sday2[3], shour2[3], sminute2[3], ssecond2[20], sdatetime2[50];
    char  syearstart[5], smonthstart[3], sdaystart[3], shourstart[3], sminutestart[3], ssecondstart[20];
    char  *p, stcorr[40], stimescale[4]; 
    bool  corrflag;
    CString  myString;
    LPCTSTR  pzText;
    struct NU_SO NU;        
    struct BX_co faf;
    string  str;
    Matrix2  dXdQ, dXdQT, Kx, helpmatr, resmatr, helpmatr1, helpmatr2, helpmatr3,  dXdV1matr, dXdV2matr, dXdQ1, corrmatr(6,6), corrmatr1(6,6), corrmatr2(6,dim), addparmatr(6,dim-6);
    Matrix2  RNBmat2, RNBmat2T, tempmatr1; //Krnb, Krnbnorm;
    NMTMatrix  nmtmatr(6,dim);
    T3DMatrix  RNBmat;
    T3DVector  qr, qv;
    //vector<long double>  sigmarnb;
    NewSatInit  nst;
    Satellite *sat;

    sigmarnb.reserve(20);
    sigmarnb.resize(6);
    //printf("sdatetime: %s\n",sdatetime);
    strcpy(sdatetime2,sdatetime+1);
    strncpy(syearstart,sdatetime2,4);    syearstart[4] = '\0';
    strncpy(smonthstart,sdatetime2+5,2);    smonthstart[2] = '\0';
    strncpy(sdaystart,sdatetime2+8,2);    sdaystart[2] = '\0';
    strncpy(shourstart,sdatetime2+11,2);    shourstart[2] = '\0';
    strncpy(sminutestart,sdatetime2+14,2);    sminutestart[2]= '\0';
    strcpy(ssecondstart,sdatetime2+17);
    yearstart = atoi(syearstart);
    monthstart = atoi(smonthstart);
    daystart = atoi(sdaystart);
    hourstart = atoi(shourstart);
    minutestart = atoi(sminutestart);
    secondstart = atof(ssecondstart);
    //printf("Start time: %d.%02d.%02d/%02d:%02d:%06.3f\n",yearstart,monthstart,daystart,hourstart,minutestart,secondstart);
    partDaystart = (hourstart * 3600.0 + minutestart * 60.0 + secondstart) / 86400.0;
    DJ(&jtstart,&tjstart,yearstart,monthstart,daystart,partDaystart);
    //printf("timescale = %d\n",timescale);
    if (timescale==1)  tjstart -= 0.125L;
    if ((timescale==1)||(timescale==2))
    {
        DtEph(jtstart+tjstart);
        tjstart += Tph.DT;
    }
    //printf("Start time: %ld %.10f\n",jtstart,tjstart);
    if (pPage4->pOrbitaPage->aprior==1)
        covmatrdim = pPage4->pOrbitaPage->covmatrdim;
    else
        covmatrdim = 0;
    m_IDC_MFCMaskedEdit1.GetWindowTextA(myString); // считываем дату и время протяжки
    myString = myString.Trim();
    len = myString.GetLength();
    pzText = myString.GetBuffer();
    for (i=0; i<len; i++)  s[i] = pzText[i];    s[len] = '\0';
    strcpy(sdatetimebroach,s);
    //printf("sprot: %s\n",s);
    strncpy(syear2,s,4);    syear2[4] = '\0';
    strncpy(smonth2,s+5,2);    smonth2[2] = '\0';
    strncpy(sday2,s+8,2);    sday2[2] = '\0';
    strncpy(shour2,s+11,2);    shour2[2] = '\0';
    strncpy(sminute2,s+14,2);    sminute2[2]= '\0';
    strcpy(ssecond2,s+17);
    year2 = atoi(syear2);
    month2 = atoi(smonth2);
    day2 = atoi(sday2);
    hour2 = atoi(shour2);
    minute2 = atoi(sminute2);
    second2 = atof(ssecond2);
    //printf("Broach time: %d.%02d.%02d/%02d:%02d:%06.3f\n",year2,month2,day2,hour2,minute2,second2);
    partDay2 = (hour2 * 3600.0 + minute2 * 60.0 + second2) / 86400.0;
    DJ(&jt,&tj,year2,month2,day2,partDay2);
    timescalebroach = m_IDC_COMBO1.GetCurSel(); // считываем шкалу времени
    //printf("timescalebroach = %d\n",timescalebroach);
    // приведение времени (jt,tj) к шкале ET
    if (timescalebroach==1)  tj -= 0.125L;
    if ((timescalebroach==1)||(timescalebroach==2))
    {
        DtEph(jt+tj);
        tj += Tph.DT;
    }
    //printf("Broach time: %ld %.10f\n",jt,tj);
    //
    pPage4->writeToIniFile();
    Sleep(2000);
    pPage4->pOrbitaPage->readData();
    //
    n = pPage4->pPage1->m_IDC_COMBO5.GetCurSel(); // считываем номер модели атмосферы
    if (n<=0)  PR_atm = 0;
    if (n==1)  PR_atm = 10;
    if (n==2)  PR_atm = 11;
    if (n==3)  PR_atm = 12;
    //
    //UnmapViewOfFile(F);
    pPage4->pOrbitaPage->faf.Egr = pPage4->pOrbitaPage->faf.Egr * DAY * DAY / (AE * AE * AE);
    intsat = CreateSatellite(&(pPage4->pOrbitaPage->NU),&(pPage4->pOrbitaPage->faf));
    nst = pPage4->pOrbitaPage->CreateNewSatInit(PR_atm,&(pPage4->pOrbitaPage->NU),&(pPage4->pOrbitaPage->faf));
    sat = (Satellite*)intsat;
    //delete sat;
    //sat = NULL;
    //
    nst.jt0 = jtstart; // целой части юлианской даты jt для времени уточнённых начальных условий
    nst.tj0 = tjstart; // дробной части юлианской даты tj для времени уточнённых начальных условий
    nst.TimeIn = 0; // шкала времени ET
    nst.refSysCodeIn = 0; // система координат -- инерциальная J2000
    //
    // добавление импульсов коррекции, если это необходимо
    numcorr = 0;
    if (aps.timparray.size()>0)
    {
        numcorr = aps.timparray.size();
        for (i=0; i<numcorr; i++)
        {
            str = (string)(aps.timparray.at(0));
            strcpy(stcorr,str.c_str());
            strncpy(syear,stcorr,4);    syear[4] = '\0';
            strncpy(smonth,stcorr+5,2);    smonth[2] = '\0';
            strncpy(sday,stcorr+8,2);     sday[2] = '\0';
            strncpy(shour,stcorr+11,2);    shour[2] = '\0';
            strncpy(sminute,stcorr+14,2);    sminute[2] = '\0';
            p = strchr(stcorr+17,' ');
            if (p!=NULL)
            {
                strncpy(ssecond,stcorr+17,(int)(p-stcorr-17));    ssecond[(int)(p-stcorr-17)] = '\0';
                strcpy(stimescale,p+1);
            }
            else
            {
                strcpy(ssecond,stcorr+17);
                strcpy(stimescale,"ET");
            } 
            year = atof(syear);
            month = atof(smonth);
            day = atof(sday);
            hour = atof(shour);
            minute = atof(sminute);
            second = atof(ssecond);
            partDay = (hour*3600.0 + minute*60.0 + second) / 86400.0;
            DJ(&jtcorr[i],&tjcorr[i],year,month,day,partDay);
            timescale = (int)(aps.timescaleimparray.at(i));
            if (timescale==1)  tjcorr[i] -= 0.125L;
            if ((timescale==1)||(timescale==2))
            {
                DtEph(jtcorr[i]+tjcorr[i]);
                tjcorr[i] += Tph.DT;
            }
        }
        corrflag = true;
    }
    else
        corrflag = false;
    //
    // добавление новых значений Sb, kappa, ar, an, ab, если это необходимо
    if (dim>6)
    {
        /* if (pPage4->pOrbitaPage->faf.Sb>0)
        {
            nst.mfe.m_MEF.Sb = (long double)(aps.Sbarray.at(0));
        }
        if (pPage4->pOrbitaPage->faf.Kappa>0)
        {
            nst.mfe.m_Kappa = (long double)(aps.kappaarray.at(0));
        } */
        if (pPage4->pOrbitaPage->faf.f_Empirical_a>0)
        {
            nst.mfe.f_Empirical_a = 1;
        }
    }
    //
    Sb = nst.mfe.m_MEF.Sb;
    kappa = nst.mfe.m_Kappa;
    nst.Flag_integr = 1;
    //printf("dim = %d\n",dim);
    sat = new Satellite(nst);
    addSatelliteMembers(*sat,nst);
    NewSatellite(sat);
    dXdQ.AllocateMemory(6,dim);
    if (numcorr==0)
    // если нет точек коррекции
    {
        sat->SetTime(jt,tj); // интегрируем на время протяжки
        sat->GetCurrentVector(rv,1);
        sat->GetCurrentMatrix(nmtmatr);
        //printf("Matrix nmtmatr:\n");
        for (i=0; i<6; i++)
        {
            for (j=0; j<dim; j++)
            {
                val = nmtmatr(i,j);
                dXdQ.SetValue(i,j,val);
                //printf("nmtmatr(%d,%d) = %le\n",i,j,val);
            }
        }
        //printf("\n");
    }
    else
    // если есть точки коррекции
    {
        dXdQ.CleanMassif();
        dXdQ.AllocateMemory(6,dim+3*numcorr);
        dXdQ.FillZeros();
        dXdQT.AllocateMemory(dim+3*numcorr,6);
        currcorr = 0;
        for (i=0; i<numcorr; i++)
        {
            if ((jt+tj)>=(jtcorr[i]+tjcorr[i]))
            {
                // производим дополнение импульсов коррекции
                sat->SetTime(jtcorr[i],tjcorr[i]);
                sat->GetCurrentVector(rv,1);
                sat->GetCurrentMatrix(nmtmatr);
                for (int i1=0; i1<6; i1++)
                {
                    for (j=0; j<6; j++)
                    {
                        val = nmtmatr(i1,j);
                        corrmatr.SetValue(i1,j,val);
                    }
                }
                if (i==0)
                // если это первая точка коррекции
                {
                    for (int i1=0; i1<6; i1++)
                    {
                        for (j=0; j<6; j++)
                        {
                            val = corrmatr.GetValue(i1,j);
                            corrmatr1.SetValue(i1,j,val);
                        }
                    }
                }
                if (i==1)
                // если это вторая точка коррекции
                {
                    helpmatr = corrmatr.MatrixMultiplication(corrmatr1);
                    corrmatr1 = helpmatr;
                    dXdV1matr.CleanMassif();
                    dXdV1matr.AllocateMemory(6,3);
                    for (int i1=0; i1<6; i1++)
                    {
                        for (j=0; j<3; j++)
                        {
                            val = corrmatr.GetValue(i1,j+3);
                            dXdV1matr.SetValue(i1,j,val);
                        }
                    }
                }
                if (i==2)
                // если это третья точка коррекции
                {
                    helpmatr = corrmatr.MatrixMultiplication(corrmatr1);
                    corrmatr1 = helpmatr;
                    helpmatr = corrmatr.MatrixMultiplication(dXdV1matr);
                    dXdV1matr = helpmatr;
                    dXdV2matr.CleanMassif();
                    dXdV2matr.AllocateMemory(6,3);
                    for (int i1=0; i1<6; i1++)
                    {  
                        for (j=0; j<3; j++)
                        {
                            val = corrmatr.GetValue(i1,j+3);
                            dXdV2matr.SetValue(i1,j,val);
                        }
                    }
                }
                // перезапуск интегратора с изменением вектора скорости в момент коррекции
                rv[1].x += (((long double)(aps.Vimparray[i*9]))/1000/AE*DAY);
                rv[1].y += (((long double)(aps.Vimparray[i*9+3]))/1000/AE*DAY);
                rv[1].z += (((long double)(aps.Vimparray[i*9+6]))/1000/AE*DAY);
                //
                T3DVector  dXdQ0in[2][10];
                T3DVector* pT3DVector[] = {dXdQ0in[0],dXdQ0in[1]};
                if (dim>6)
                // если число уточняемых параметров больше 6
                {
                    for (int i1=0; i1<(dim-6); i1++)
                    {
                        dXdQ0in[0][i1].x = nmtmatr(0,i1+6);
                        dXdQ0in[0][i1].y = nmtmatr(1,i1+6);
                        dXdQ0in[0][i1].z = nmtmatr(2,i1+6);
                        dXdQ0in[1][i1].x = nmtmatr(3,i1+6);
                        dXdQ0in[1][i1].y = nmtmatr(4,i1+6);
                        dXdQ0in[1][i1].z = nmtmatr(5,i1+6);
                    }
                    sat->RestartIntegr_Var(jtcorr[i],tjcorr[i],rv,i,pT3DVector,dim-6);
                }
                else
                // если число уточняемых параметров равно 6
                    sat->RestartIntegr_Var(jtcorr[i],tjcorr[i],rv,i,NULL,0);
                currcorr++;
            }
            else
                break;
        }
        sat->SetTime(jt,tj); // интегрируем на время протяжки
        sat->GetCurrentVector(rv,1);
        sat->GetCurrentMatrix(nmtmatr);
        for (i=0; i<6; i++)
        {
            for (j=0; j<dim; j++)
            {
                val = nmtmatr(i,j);
                dXdQ.SetValue(i,j,val);
            }
        }
        if (currcorr>0)
        {
            dXdQ1.AllocateMemory(6,6);
            for (i=0; i<6; i++)
            {
                for (j=0; j<6; j++)
                {
                    val = dXdQ.GetValue(i,j);
                    dXdQ1.SetValue(i,j,val);
                }
            }
            if (currcorr==1)
            // если после первой точки коррекции
            {
                helpmatr = dXdQ1.MatrixMultiplication(corrmatr1);
                helpmatr1.CleanMassif();
                helpmatr1.AllocateMemory(6,3);
                for (i=0; i<6; i++)
                {
                    for (j=0; j<3; j++)
                    {
                        val = dXdQ.GetValue(i,j+3);
                        helpmatr1.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<(dim-6); j++)
                    {
                        val = dXdQ.GetValue(i,j+6);
                        addparmatr.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<6; j++)
                    {
                        val = helpmatr.GetValue(i,j);
                        dXdQ.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<(dim-6); j++)
                    {
                        val = addparmatr.GetValue(i,j);
                        dXdQ.SetValue(i,j+6,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<3; j++)
                    {
                        val = helpmatr1.GetValue(i,j);
                        dXdQ.SetValue(i,dim+j,val);
                    }
                }
            }
            if (currcorr==2)
            // если после второй точки коррекции
            {
                helpmatr = dXdQ1.MatrixMultiplication(corrmatr1);
                helpmatr1 = dXdQ1.MatrixMultiplication(dXdV1matr);
                helpmatr2.CleanMassif();
                helpmatr2.AllocateMemory(6,3);
                for (i=0; i<6; i++)
                {
                    for (j=0; j<3; j++)
                    {
                        val = dXdQ.GetValue(i,j+3);
                        helpmatr2.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<(dim-6); j++)
                    {
                        val = dXdQ.GetValue(i,j+6);
                        addparmatr.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<6; j++)
                    {
                        val = helpmatr.GetValue(i,j);
                        dXdQ.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<(dim-6); j++)
                    {
                        val = addparmatr.GetValue(i,j);
                        dXdQ.SetValue(i,j+6,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<3; j++)
                    {
                        val = helpmatr1.GetValue(i,j);
                        dXdQ.SetValue(i,dim+j,val);
                        val = helpmatr2.GetValue(i,j);
                        dXdQ.SetValue(i,dim+j+3,val);
                    }
                }
            }
            if (currcorr==3)
            // если после третьей точки коррекции
            {
                helpmatr = dXdQ1.MatrixMultiplication(corrmatr1);
                helpmatr1 = dXdQ1.MatrixMultiplication(dXdV1matr);
                helpmatr2 = dXdQ1.MatrixMultiplication(dXdV2matr);
                helpmatr3.CleanMassif();
                helpmatr3.AllocateMemory(6,3);
                for (i=0; i<6; i++)
                {
                    for (j=0; j<3; j++)
                    {
                        val = dXdQ.GetValue(i,j+3);
                        helpmatr3.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<(dim-6); j++)
                    {
                        val = dXdQ.GetValue(i,j+6);
                        addparmatr.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++) 
                {
                    for (j=0; j<6; j++)
                    {
                        val = helpmatr.GetValue(i,j);
                        dXdQ.SetValue(i,j,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<(dim-6); j++)
                    {
                        val = addparmatr.GetValue(i,j);
                        dXdQ.SetValue(i,j+6,val);
                    }
                }
                for (i=0; i<6; i++)
                {
                    for (j=0; j<3; j++)
                    {
                        val = helpmatr1.GetValue(i,j);
                        dXdQ.SetValue(i,dim+j,val);
                        val = helpmatr2.GetValue(i,j);
                        dXdQ.SetValue(i,dim+3+j,val);
                        val = helpmatr3.GetValue(i,j);
                        dXdQ.SetValue(i,dim+6+j,val);
                    }
                }
            }
        }
    }
    if (m_IDC_CHECK1.GetCheck()==1)
    // если была выбрана протяжка ковариационной матрицы
    {
        if (dim>covmatrdim)
        {
            AfxMessageBox("Несоответствие размера ковариационной матрицы.");
            return;
        }
        if (covmatrdim==0)
        {
            AfxMessageBox("Не задан размер ковариационной матрицы");
            return;
        }
        if (isMatrixZero(Kmatr)==true)
        {
            AfxMessageBox("Ковариационная матрица--нулевая");
            return;
        }
        // вычисление ковариационной матрицы на время (jt,tj)
        FILE *f2 = fopen("covmatr.txt","w+");
        fprintf(f2,"Матрица Kx:\n\n");
        for (i=0; i<dim; i++)
        {
            for (j=0; j<dim; j++)
            {
                val = Kmatr.GetValue(i,j);
                fprintf(f2,"%.14le    ",val);
                if (j==(dim-1))  fprintf(f2,"\n");
            }
        }
        fprintf(f2,"\n\n");
        dXdQT.AllocateMemory(dim,6);
        helpmatr.AllocateMemory(6,dim);
        Kovmatr.AllocateMemory(6,6);
        dXdQT = dXdQ.TransposeMatrix();    
        helpmatr = dXdQ.MatrixMultiplication(Kmatr);    
        Kovmatr = helpmatr.MatrixMultiplication(dXdQT);
        m_IDC_BUTTON3.EnableWindow(1);
        fprintf(f2,"Матрица dXdQ:\n\n");
        for (i=0; i<6; i++)
        {
            for (j=0; j<dim; j++)
            {
                val = dXdQ.GetValue(i,j);
                fprintf(f2,"%.14le    ",val);
                if (j==(dim-1))  fprintf(f2,"\n");
            }
        }
        fprintf(f2,"\n\n");
        fprintf(f2,"Матрица dXdQT:\n\n");
        for (i=0; i<dim; i++)
        {
            for (j=0; j<6; j++)
            {
                val = dXdQT.GetValue(i,j);
                fprintf(f2,"%.14le    ",val);
                if (j==5)  fprintf(f2,"\n");
            }
        }
        fprintf(f2,"\n\n");
        fprintf(f2,"Матрица Kovmatr:\n\n");
        for (i=0; i<6; i++)
        {
            for (j=0; j<6; j++)
            {
                val = Kovmatr.GetValue(i,j);
                fprintf(f2,"%.14le    ",val);
                if (j==5)  fprintf(f2,"\n");
            }
        }
        fclose(f2);
        // перевод ковариационной матрицы ошибок НУ на tпрот--Kovmatr в ковариационную матрицу ошибок Krnb в орбитальной СК
        qr.x = rv[0].x;    qr.y = rv[0].y;    qr.z = rv[0].z;
        qv.x = rv[1].x;    qv.y = rv[1].y;    qv.z = rv[1].z;
        tempmatr1.CleanMassif();
        //tempmatr1.AllocateMemory(dim+3*numcorr,dim+3*numcorr);
        tempmatr1.AllocateMemory(6,6);
        tempmatr1.FillZeros();
        RNBmat = myRNB(qr, qv);
        RNBmat2.AllocateMemory(6,6);
        RNBmat2.FillZeros();
        for (i=0; i<3; i++)
        {
            for (j=0; j<3; j++)
            {
                RNBmat2.SetValue(i,j,RNBmat.a[i][j]);
            }
        }
        for (i=3; i<6; i++)
        {
            for (j=3; j<6; j++)
            {
                RNBmat2.SetValue(i,j,RNBmat.a[i-3][j-3]);
            }
        }
        RNBmat2T.AllocateMemory(6,6);
        RNBmat2T = RNBmat2.TransposeMatrix();
        tempmatr1 = RNBmat2.MatrixMultiplication(Kovmatr);
        Krnb.AllocateMemory(6,6);
        Krnb = tempmatr1.MatrixMultiplication(RNBmat2T);
        for (i=0; i<6; i++)
        {
            sigmarnb[i] = sqrtl(fabsl(Krnb.GetValue(i,i)));
        }
        Krnbnorm.AllocateMemory(6,6);
        for (i=0; i<6; i++)
        {
            for (j=0; j<6; j++)
            {
                val = Krnb.GetValue(i,j)/(sigmarnb[i]*sigmarnb[j]);
                Krnbnorm.SetValue(i,j,val);
            }
        } 
    }
    sprintf(sresult," % .16le\r\n\r\n",rv[0].x*AE);
    sprintf(s," % .16le\r\n\r\n",rv[0].y*AE);
    strcat(sresult,s);
    sprintf(s," % .16le\r\n\r\n",rv[0].z*AE);
    strcat(sresult,s);
    sprintf(s," % .16le\r\n\r\n",rv[1].x*AE/DAY);
    strcat(sresult,s);
    sprintf(s," % .16le\r\n\r\n",rv[1].y*AE/DAY);
    strcat(sresult,s);
    sprintf(s," % .16le\r\n\r\n",rv[1].z*AE/DAY);
    strcat(sresult,s);
    sprintf(s," % .16le\r\n\r\n",Sb);
    strcat(sresult,s);
    sprintf(s," % .16le\r\n",kappa);
    strcat(sresult,s);
    //
    if (corrflag==true)
    {
        sprintf(s,"\r\n");
        strcat(sresult,s);
        numcorr = aps.timparray.size();
        for (i=0; i<numcorr; i++)
        {
            str = (string)(aps.timparray.at(0));
            strcpy(stcorr,str.c_str());
            sprintf(s,"tcorr%d = %s",i+1,stcorr);
            strcat(sresult,s);
            strcpy(s,"");
            timescale = (int)(aps.timescaleimparray.at(i));
            if (timescale==0)  sprintf(s," ET");
            if (timescale==1)  sprintf(s," ДМВ");
            if (timescale==2)  sprintf(s," UTC");
            strcat(sresult,s);
            strcat(sresult,"\r\n\r\n");
            val = (long double)(aps.Vimparray.at(9*i));
            sprintf(s,"V%dx = % .16le м/c\r\n\r\n",i+1,val);
            val = (long double)(aps.Vimparray.at(9*i+3));
            sprintf(s,"V%dy = % .16le м/с\r\n\r\n",i+1,val);
            val = (long double)(aps.Vimparray.at(9*i+6));
            sprintf(s,"V%dz = % .16le м/с\r\n\r\n",i+1,val);
        }
    }
    //
    m_IDC_EDIT3.SetWindowText(sresult);
    pPage4->broachX = rv[0].x;
    pPage4->broachY = rv[0].y;
    pPage4->broachZ = rv[0].z;
    pPage4->broachVx = rv[1].x;
    pPage4->broachVy = rv[1].y;
    pPage4->broachVz = rv[1].z;
    pPage4->broachSb = Sb;
    pPage4->broachKappa = kappa;
    n = Kovmatr.n;
    m = Kovmatr.m;
    pPage4->broachKmatr.AllocateMemory(n,m);
    pPage4->broachKmatr = Kovmatr;
    strcpy(pPage4->sbroachdatetime,sdatetimebroach);
    pPage4->broachtimescale = timescalebroach;
    pPage4->m_IDC_EDIT3.EnableWindow(1);
    pPage4->m_IDC_EDIT3.SetWindowText(pPage4->sbroachdatetime);
    pPage4->m_IDC_COMBO2.EnableWindow(1);
    pPage4->m_IDC_COMBO2.SetCurSel(timescalebroach);
    return;
}


Также на всякий случай мой класс для работы с матрицами:

#include "stdafx.h"
#include "../MathLib/Matrixes2.h"
#include "../Basis/ReadWrite.h"
#include <locale.h>
#include <process.h>
#include <vector>
#include <iostream>
#include <exception>

using namespace std;

Matrix2::Matrix2()
{
    n = 0;
    m = 0;
    massif.clear();
}

Matrix2::Matrix2(int n, int m)
{
    if ((n!=0)&&(m!=0))
    {
    this->n = n;
    this->m = m;
    try
    {
    massif.resize(n*m,0.0);
    }
    catch (exception& ex)
    {
        printf("Matrix2 constructor: error of memory allocation.\n");
        printf("%s\n",ex.what());
        printf("Press any key to exit.\n");
        _getch();
        exit(0);
    }
    }
    else
    {
        this->n = 0;
        this->m = 0;
        this->massif.clear();
    }
}

Matrix2::~Matrix2()
{
    massif.clear();
    n = 0;
    m = 0;
}

void Matrix2::AllocateMemory(int n, int m)
{
    this->n = n;
    this->m = m;
    try
    {
    massif.resize(n*m,0.0);
    }
    catch (exception& ex2)
    {
        printf("Matrix2::AllocateMemory function: error of memory allocation.\n");
        printf("%s\n",ex2.what());
        printf("Press any key to exit.\n");
        _getch();
        exit(0);
    }
}

void Matrix2::FillZeros()
{
    int  i, massize;
    massize = massif.size();
    for (i=0; i<massize; i++)  massif[i] = 0.0;
}

void Matrix2::CleanMassif()
{
    massif.clear();
    n = 0;
    m = 0;
}

Matrix2& Matrix2::operator= (Matrix2& matr)
{
    int i;

    this->massif.clear();
    this->n = matr.n;
    this->m = matr.m;
    this->massif.resize(n*m);
    for (i=0; i<(n*m); i++)
    {
        this->massif[i] = matr.massif.at(i);
    }
    matr.CleanMassif();
    return *this;
}

long double& Matrix2::operator()(int i, int j)
{
    return (long double&)(massif.at((i*m)+j));
}

void  Matrix2::SetValue(int i, int j, long double val)
{
    massif[i*m + j] = val;
} // конец функции Matrix2::SetValue

long double Matrix2::GetValue(int i, int j)
{
    long double val;

    val = (long double)(massif.at((i*m) + j));
    return val;
} // конец функции Matrix2::GetValue

Matrix2  Matrix2::NumberMultiplication(long double number)
{
    int i;
    Matrix2 resmatr(n,m);

    for (i=0; i<(n*m); i++)  resmatr.massif[i] = this->massif.at(i) * number;
    return resmatr;
} // конец функции Matrix2::NumberMultiplication

Matrix2  Matrix2::Addition(Matrix2 matr)
{
    int i;
    Matrix2 resmatr(n,m);
    if ((this->n != matr.n)||(this->m != matr.m))
    {
        printf("Dimension of first matrix is not equal of dimension of second matrix!\n");
        return resmatr;
    }
    else
    {
        for (i=0; i<(n*m); i++)  resmatr.massif[i] = this->massif.at(i) + matr.massif.at(i);
    }
    return resmatr;
} // конец функции Matrix2::Addition

Matrix2  Matrix2::Substraction(Matrix2 matr)
{
    int i;
    Matrix2  resmatr(n,m);

    if ((this->n != matr.n)||(this->m != matr.m))
    {
        printf("Dimension of first matrix is not equal of dimension of second matrix!\n");
        return resmatr;
    }
    else
    {
        for (i=0; i<(n*m); i++)  resmatr.massif[i] = this->massif.at(i) - matr.massif.at(i);
    }
    return resmatr;
} // конец функции Matrix2::Substraction

Matrix2  Matrix2::MatrixMultiplication(Matrix2 matr)
{
    int i, j, k, thisn, thism, matrn, matrm;
    long double  sum, val1, val2;

    Matrix2  resmatr;
    thisn = this->n;
    thism = this->m;
    matrn = matr.n;
    matrm = matr.m;
    resmatr.AllocateMemory(thisn,matrm);
    if (thism!=matrn)
    {
        printf("Dimension of first matrix doesn't correspond to dimension of second matrix!\n");
        return resmatr;
    }
    else
    {
        // действия по перемножению исходной матрицы и матрицы matr
        for (i=0; i<thisn; i++)
        {
            for (j=0; j<matrm; j++)
            {
                sum = 0.0;
                for (k=0; k<thism; k++)
                {
                    val1 = this->massif.at(i*thism + k);
                    val2 = matr.massif.at(k*matrm + j);
                    sum += val1 * val2;
                }
                resmatr.SetValue(i,j,sum);
            }
        }
    }
    return resmatr;
} // конец функции Matrix2::MatrixMultiplication

Matrix2  Matrix2::InverseMatrix(int *rank)
{
    int  i, j, k, count, countnull, rankmatr;
    long double  val, maximum, maxelem, valj, val2;
    long double  eps, eps1;
    vector<long double> temparray;
    Matrix2  resmatr(n, m), srcmatr(n, m);

    eps1 = 1.0E-15;
    temparray.clear();
    for (i=0; i<(n*m); i++)  srcmatr.massif[i] = this->massif.at(i);
    if (n!=m)
    {
        printf("Matrix is not a square matrix!\n");
        exit(0);
    }
    else
    {
        // инициализация результирующей матрицы resmatr как единичной
        for (i=0; i<n; i++)
        {
            for (j=0; j<n; j++)
            {
                if (i!=j)
                {
                    resmatr.SetValue(i,j,0.0);
                }
                else
                {
                    resmatr.SetValue(i,j,1.0);
                }
            }
        }
        // поиск максимального по модулю элемента матрицы
        maxelem = 0.0;
        for (i=0; i<n; i++)
        {
            for (j=0; j<n; j++)
            {
                if (fabsl(srcmatr(i,j))>fabsl(maxelem))    maxelem = srcmatr(i,j);
            }
        }
        eps = fabsl(maxelem) * eps1;
        countnull = 0;
        // действия по нахождению обратной матрицы
        // нахождение треугольной матрицы
        for (i=0; i<n; i++)
        {
            val = srcmatr(i,i);
            maximum = val;
            count = i;
            for (j=i+1; j<n; j++)
            {
                if (fabsl(srcmatr(j,i))>fabsl(maximum))
                {
                    maximum = srcmatr(j,i);
                    count = j;
                }
            }
            if (fabsl(maximum)<eps)
            {
                countnull++;
                continue;
            }
            else
            {
                if (count>i)
                {
                  // смена строк с номерами i и count
                  temparray.resize(n);
                  for (k=0; k<n; k++)
                  {
                    temparray[k] = srcmatr(count,k);
                    val2 = srcmatr(i,k);
                    srcmatr.SetValue(count,k,val2);
                    val2 = temparray.at(k);
                    srcmatr.SetValue(i,k,val2);
                    temparray[k] = resmatr(count,k);
                    val2 = resmatr(i,k);
                    resmatr.SetValue(count,k,val2);
                    val2 = temparray.at(k);
                    resmatr.SetValue(i,k,val2);
                  }
                  temparray.clear();
                }
            }
            val = srcmatr(i,i);
            for (k=0; k<n; k++)
            {
                val2 = srcmatr(i,k);
                srcmatr.SetValue(i,k,val2/val);
                val2 = resmatr(i,k);
                resmatr.SetValue(i,k,val2/val);
            }
            for (j=i+1; j<n; j++)
            {
                printf("i = %d    j = %d\n",i,j);
                valj = srcmatr(j,i);
                for (k=0; k<n; k++)
                {
                    val2 = srcmatr(j,k) - (srcmatr(i,k) * valj);
                    srcmatr.SetValue(j,k,val2);
                    val2 = resmatr(j,k) - (resmatr(i,k) * valj);
                    resmatr.SetValue(j,k,val2);
                }
            }
        } // конец цикла for (i=0; i<n-1; i++)
        val = 0.0;
        rankmatr = n - countnull; // нахождение ранга матрицы
        if (countnull>0)
        {
            *rank = rankmatr;
            printf("Ранг матрицы равен: %d",rankmatr);
            _getch();
            return  resmatr;
        }
        // приведение исходной матрицы к единичной
        for (i=n-1; i>0; i--)
        {
            val = srcmatr(i,i);
            for (j=i-1; j>=0; j--)
            {
                valj = srcmatr(j,i);
                for (k=0; k<n; k++)
                {
                    val2 = srcmatr(j,k) - (srcmatr(i,k) * valj);
                    srcmatr.SetValue(j,k,val2);
                    val2 = resmatr(j,k) - (resmatr(i,k) * valj);
                    resmatr.SetValue(j,k,val2);
                }
            }
        }
        val = srcmatr(0,0);
        for (k=0; k<n; k++)
        {
           val2 = resmatr(0,k) / val;
           resmatr.SetValue(0,k,val2);
           val2 = srcmatr(0,k) / val;
           srcmatr.SetValue(0,k,val2);
        }
    }
    return  resmatr;
} // конец функции Matrix2::InverseMatrix

Matrix2  Matrix2::InverseMatrixKol(long double eps, int* badrows)
{
    int  i, j, k, l, column, count, rankmatr;
    long double  mnozh1, mnozh2, max1, max2, coef;
    long double  coef1, coef2, sum, eps1, var, val2;
    char  helpstr[160];
    bool  flag1;
    Matrix2  srcmatr(n,m);
    Matrix2  resmatr;
    vector<matrrow>  matrrowarray;

    matrrowarray.clear();
    for (i=0;i<(n*m);i++)  srcmatr.massif[i] = (long double)(this->massif.at(i));
    mnozh1 = 1.0;
    mnozh2 = 1.0;
    max2 = max1 = 0.0;
    coef = 1.0;
    l = 1;
    eps1 = eps * n;
    *badrows = 0;
    resmatr.AllocateMemory(n,m);
    resmatr.FillZeros();
    flag1 = false;
    if (m!=n)
    // если количество строк не равно количеству столбцов
    {
        resmatr.n = 0;
        resmatr.m = 0;
        resmatr.massif.clear();
        *badrows = 1;
        printf(" Ошибка при обращении матрицы: матрица не квадратная!\n");
    }
    else
    {
        matrrowarray.resize(n);
        for (i=0; i<n; i++)
        {
            matrrowarray[i].bad = false;
            matrrowarray[i].number = 0;
        }
        // инициализация результирующей матрицы resmatr как единичной
        for (i=0; i<n; i++)
        {
            for (j=0; j<n; j++)
            {
                if (i!=j)
                {
                    resmatr.SetValue(i,j,0.0);
                }
                else
                {
                    resmatr.SetValue(i,j,1.0);
                }
            }
        } // конец цикла for (i=0; i<n; i++)
        // действия по нахождению обратной матрицы
        coef1 = 0.0;
        for (i=0; i<n; i++) // поиск максимального по модулю элемента во всей матрице
        {
            for (k=0; k<n; k++)
            {
                if (fabsl(srcmatr(i,k))>fabsl(coef1))  coef1 = srcmatr(i,k);
            }
        }
        for (i=0; i<n; i++) // нормирование всех элементов матрицы на этот элемент
        {
            for (k=0; k<n; k++)
            {
                val2 = srcmatr(i,k) / coef1;
                srcmatr.SetValue(i,k,val2);
                val2 = resmatr(i,k) / coef1;
                resmatr.SetValue(i,k,val2);
            }
        }
        for (i=0; i<n; i++) 
        // поиск максимального элемента в текущей строке и нормирование строки на этот максимальный её элемент
        {
            sum = 0.0;    
            for (k=0; k<n; k++)
            {
                sum += fabsl(srcmatr(i,k));
            }
            // проверка строки на близость всех её элементов к нулю
            if (sum<eps1)
            {
                // i-ая строка--"плохая", все её элементы нулевые или близки к нулю
                matrrowarray[i].bad = true;
            }
            else
            {
                // i-ая строка--"хорошая", не все элементы близки к нулю
                matrrowarray[i].bad = false;
            }
            //
            if (matrrowarray[i].bad==false)
            // если строка--ненулевая
            {
                coef1 = 0.0;
                column = 0;
                for (k=0; k<n; k++)
                {
                    if (fabsl(srcmatr(i,k))>fabsl(coef1))
                    {
                        coef1 = srcmatr(i,k);
                        column = k;
                    }
                }
                for (k=0; k<n; k++)
                {
                    val2 = srcmatr(i,k) / coef1;
                    srcmatr.SetValue(i,k,val2);
                    val2 = resmatr(i,k) / coef1;
                    resmatr.SetValue(i,k,val2);
                }
                matrrowarray[i].number = column;
            }
            // вычитание из строк, расположенных сверху и снизу от текущей строки, этой текущей строки, умноженной на соответствующей на коэффициент
            if (matrrowarray[i].bad==false)
            {
                for (j=0; j<n; j++)
                {
                    if (j!=i)
                    {
                        coef2 = srcmatr(j,column);
                        for (k=0; k<n; k++)
                        {
                            val2 = srcmatr(j,k) - coef2 * srcmatr(i,k);
                            srcmatr.SetValue(j,k,val2);
                            val2 = resmatr(j,k) - coef2 * resmatr(i,k);
                            resmatr.SetValue(j,k,val2);
                        }
                    }
                }
            }
        } // конец цикла по i
        for (i=0; i<n; i++)
        // сортировка строк в исходной матрице так, чтобы получилась единичная матрица
        {
            if (srcmatr(i,i)!=1.0)
            {
                for (j=0; j<n; j++)
                {
                    if (j!=i)
                    {
                        if (srcmatr(j,i)==1.0)
                        {
                            // меняем i-ую и j-ую строки в матрицах
                            for (k=0; k<n; k++) 
                            {
                                var = srcmatr(j,k);
                                val2 = srcmatr(i,k);
                                srcmatr.SetValue(j,k,val2);
                                srcmatr.SetValue(i,k,var);
                            }
                            for (k=0; k<n; k++)
                            {
                                var = resmatr(j,k);
                                val2 = resmatr(i,k);
                                resmatr.SetValue(j,k,val2);
                                resmatr.SetValue(i,k,var);
                            }
                            break; 
                        }
                    }
                }
            }
        } // конец цикла по i 
        count = 0;
        for (i=0; i<n; i++)
        {
            if (matrrowarray[i].bad==true)  count++;
        }
        if (count>0)
        {
            *badrows = count;
            rankmatr = n - (*badrows);
            setlocale(LC_CTYPE,"Russian");
            sprintf(helpstr," Исходная матрица вырожденная, её ранг равен %d\n",rankmatr);
            printToConsoleWindow(helpstr);
            setlocale(LC_ALL,"English_United States.1252");
        }
        else
        {
            *badrows = 0;
            rankmatr = n;
        }
        matrrowarray.clear();
    }
    return  resmatr;
} // конец функции Matrix2::InverseMatrixKol

Matrix2  Matrix2::TransposeMatrix()
{
    int i, j;
    Matrix2  resmatr(m,n);
    
    for (i=0; i<n; i++)
    {
        for (j=0; j<m; j++)
        {
            resmatr.massif[j*n + i] = this->massif[i*m + j];
        }
    }
    return resmatr;
} // конец функции Matrix2::TransposeMatrix
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.