Ошибка "не объявлен идентификатор k"

// GaussGDlg.cpp : implementation file
//
 
#include <stdio.h>
#include "stdafx.h"
#include "GaussG.h"
#include "GaussGDlg.h"
 
//Подключение описания класса диалога задания диапазона генерации значений элементов 
//матрицы:
#include "GenGialog.h" 
 
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
 
/////////////////////////////////////////////////////////////////////////////
// CGaussGDlg dialog
 
CGaussGDlg::CGaussGDlg(CWnd* pParent /*=NULL*/)
    : CDialog(CGaussGDlg::IDD, pParent)
{
    //{{AFX_DATA_INIT(CGaussGDlg)
    m_Dim = 0;
    m_EdCalc = _T("");
    //}}AFX_DATA_INIT
    // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    //Запрещение изменения размеров компонентов при изменении размеров главного окна:
    m_AllowResize = false;
}
 
void CGaussGDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CGaussGDlg)
    DDX_Control(pDX, IDC_EDIT_RESULTS, m_Results);
    DDX_Control(pDX, IDC_STATIC9, m_Static9);
    DDX_Control(pDX, IDC_STATIC8, m_Static8);
    DDX_Control(pDX, IDC_STATIC7, m_Static7);
    DDX_Control(pDX, IDC_STATIC6, m_Static6);
    DDX_Control(pDX, IDC_STATIC5, m_Static5);
    DDX_Control(pDX, IDC_STATIC4, m_Static4);
    DDX_Control(pDX, IDC_STATIC3, m_Static3);
    DDX_Control(pDX, IDC_STATIC2, m_Static2);
    DDX_Control(pDX, IDC_STATIC1, m_Static1);
    DDX_Control(pDX, IDC_SPIN1, m_Spin);
    DDX_Text(pDX, IDC_EDIT1, m_Dim);
    DDV_MinMaxInt(pDX, m_Dim, 1, 20);
    DDX_Control(pDX, IDC_MSFLEXGRID1, m_MatrixIn);
    DDX_Control(pDX, IDC_MSFLEXGRID2, m_MatrixOut);
    DDX_Control(pDX, IDC_MSFLEXGRID3, m_MatrixE);
    DDX_Text(pDX, IDC_EDIT_RESULTS, m_EdCalc);
    //}}AFX_DATA_MAP
}
 
BEGIN_MESSAGE_MAP(CGaussGDlg, CDialog)
    //{{AFX_MSG_MAP(CGaussGDlg)
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_EN_CHANGE(IDC_EDIT1, OnChangeEdit1)
    ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN1, OnDeltaposSpin1)
    ON_WM_SIZE()
    ON_COMMAND(ID_MENUITEM_EXIT, OnMenuitemExit)
    ON_COMMAND(ID_MENUITEM_GEN, OnMenuitemGen)
    ON_COMMAND(ID_MENUITEM_CLEAR, OnMenuitemClear)
    ON_COMMAND(ID_MENUITEM_TEST, OnMenuitemTest)
    ON_COMMAND(ID_MENUITEM_CALC, OnMenuitemCalc)
    ON_COMMAND(ID_MENUITEM_SAVE_RES, OnMenuitemSaveRes)
    ON_BN_CLICKED(IDC_BUTTON1, OnMenuitemCalc)
    ON_BN_CLICKED(IDC_BUTTON2, OnMenuitemTest)
    ON_COMMAND(ID_MENUITEM_OPEN_RES, OnMenuitemOpenRes)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()
 
/////////////////////////////////////////////////////////////////////////////
// CGaussGDlg message handlers
 
BOOL CGaussGDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
 
    // Set the icon for this dialog.  The framework does this automatically
    //  when the application's main window is not a dialog
    SetIcon(m_hIcon, TRUE);         // Set big icon
    SetIcon(m_hIcon, FALSE);        // Set small icon
    
    //Установка диапазона задания размерности матрицы:
    m_Spin.SetRange(2, 20);
    m_Dim = 3;
    UpdateData(false);
 
    //Установка размерности сеток для исходной и преобразованной матрицы:
    m_MatrixIn.SetCols(3);
    m_MatrixIn.SetRows(3);
    m_MatrixOut.SetCols(3);
    m_MatrixOut.SetRows(3);
    m_MatrixE.SetCols(3);
    m_MatrixE.SetRows(3);
 
    //Разрешение изменения размеров компонентов при изменении размеров главного окна:
    m_AllowResize = true; 
 
    m_NumberSave = 1; //Установка номера файла для сохранения по умолчанию ("results1.txt")
 
    return TRUE;  // return TRUE  unless you set the focus to a control
}
 
// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.
 
void CGaussGDlg::OnPaint() 
{
    if (IsIconic())
    {
        CPaintDC dc(this); // device context for painting
 
        SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
 
        // Center icon in client rectangle
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;
 
        // Draw the icon
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialog::OnPaint();
    }
}
 
// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CGaussGDlg::OnQueryDragIcon()
{
    return (HCURSOR) m_hIcon;
}
 
//Изменение размерности сеток для матриц:
void CGaussGDlg::OnChangeEdit1() 
{
    //Переменная m_SetDim определяет, допустимо ли выполнять операторы этого обработчика:
    if (!m_SetDim)
    {
        UpdateData(true);
        m_MatrixIn.SetCols(m_Dim);
        m_MatrixIn.SetRows(m_Dim);
        m_MatrixOut.SetCols(m_Dim);
        m_MatrixOut.SetRows(m_Dim); 
        m_MatrixE.SetCols(m_Dim);
        m_MatrixE.SetRows(m_Dim);   
    }
    
}
 
void CGaussGDlg::OnDeltaposSpin1(NMHDR* pNMHDR, LRESULT* pResult) 
{
    NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
 
    UpdateData(true);
    m_SetDim = false; //Разрешение изменять размеры сеток для татриц
    UpdateData(false);
    
    *pResult = 0;
}
 
BEGIN_EVENTSINK_MAP(CGaussGDlg, CDialog)
    //{{AFX_EVENTSINK_MAP(CGaussGDlg)
    ON_EVENT(CGaussGDlg, IDC_MSFLEXGRID1, -603 /* KeyPress */, OnKeyPressMsflexgrid1, VTS_PI2)
    //}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()
 
//Вывод преобразованных промежуточных матрицы А и единичной матрицы на экран:
void CGaussGDlg::ShowResults(int i, double A[20][20], double L[20][20])
{
    CString stRow;
    int j, k;
    if (i==-1)
        stRow.Format("<Исходная матрица А:>");
    else
    {
        stRow.Format("\r\n\r\n----------------------Шаг N%d: ведущий элемент a%d%d----------------------", i+1, i+1, i+1);
        m_EdCalc = m_EdCalc + stRow;
        if (i==m_Dim-1)
            stRow.Format("\r\n<Ед.матрица:>");
        else
            stRow.Format("\r\n<Преобразованная матрица А:>");
    }
    m_EdCalc = m_EdCalc + stRow;
 
    for (k=0; k<m_Dim-1; k++)
    {       
        for (j=0; j<16; j++)
            m_EdCalc = m_EdCalc + " ";
        stRow.Format("\t");
        m_EdCalc = m_EdCalc + stRow;
    }
 
    if (i==-1)
        stRow.Format("\t\t<Ед.матрица:>");
    else
        if (i==m_Dim-1)
            stRow.Format("\t\t\t<Обрат. матрица А(-1):>");
        else
            stRow.Format("\t<Преобразованная ед.матрица:>");
    m_EdCalc = m_EdCalc + stRow;
 
    for (k=0; k<m_Dim; k++)
        for (j=0; j<m_Dim*2; j++)
        {
            if (j==0) 
                stRow.Format("\r\n");
            else 
                if (j==m_Dim)
                    stRow.Format("\t\t");
                else
                    stRow.Format("\t");
            m_EdCalc = m_EdCalc + stRow;
            if (j<m_Dim)
                //Вывод матрицы А:
                stRow.Format("%13.4f", A[k][j]);
            else
                //Вывод ед.матрицы L:
                stRow.Format("%13.4f", L[k][j-m_Dim]);
            m_EdCalc = m_EdCalc + stRow;
        } //for j
    UpdateData(false);
}
 
//Формирование числа в ячейке исходной матрицы:
void CGaussGDlg::OnKeyPressMsflexgrid1(short FAR* KeyAscii) 
{
    int k = *KeyAscii;
 
    //Анализ нажатой клавиши: если нажата цифра или знаки "." и "-", то символ добавляется к 
    //строке текущей ячейки, ввод нецифровых символов подавляется:
    if ((isdigit(k)!=0) || (*KeyAscii==45) || (*KeyAscii==46)) 
    {
        m_MatrixIn.SetTextMatrix(m_MatrixIn.GetRow(),m_MatrixIn.GetCol(),
            m_MatrixIn.GetTextMatrix(m_MatrixIn.GetRow(),m_MatrixIn.GetCol()) + (char*)KeyAscii);   
        UpdateData(false);
    }
    else
        //Анализ нажатой клавиши: если нажата клавиша Backspace, то последний символ в строке 
        //удаляется:
        if (*KeyAscii==8)
        {
            CString str = m_MatrixIn.GetTextMatrix(m_MatrixIn.GetRow(),m_MatrixIn.GetCol());
            str.Delete(str.GetLength()-1,1);
            m_MatrixIn.SetTextMatrix(m_MatrixIn.GetRow(),m_MatrixIn.GetCol(), str);
            UpdateData(false);
        }
}
 
//Установка новых координат компонентов на форме при изменении ее размера:
void CGaussGDlg::OnSize(UINT nType, int cx, int cy) 
{
    CDialog::OnSize(nType, cx, cy);
    
    if ((m_AllowResize) && ((nType==SIZE_MAXIMIZED) || (nType==SIZE_RESTORED)))
    {
        //Объявление переменных, хранящих координаты компонентов на форме:
        CRect MatInRect, MatOutRect, MatERect, ResRect, MainRect;
        //Получение координат компонентов на форме:
        m_MatrixIn.GetWindowRect(&MatInRect);
        m_MatrixOut.GetWindowRect(&MatOutRect);
        m_MatrixE.GetWindowRect(&MatERect);
        m_Results.GetWindowRect(&ResRect);
        //Преобразование полученных экранных координат в клиентские:
        ScreenToClient(&MatInRect);
        ScreenToClient(&MatOutRect);
        ScreenToClient(&MatERect);
        ScreenToClient(&ResRect);
 
        //Высота интервала между компонентами-матрицами:
        int MatInterval = MatOutRect.top - MatInRect.bottom;
        //Высота компонента-матрицы:
        int MatHeight = (cy - MatInRect.top - 5 - 2*MatInterval)/3;
        //Ширина компонента-матрицы:
        int MatWidth = (cx - 35)*2/5;
        
        //Установка новых координат для компонентов на форме:
        MatInRect.bottom = MatInRect.top + MatHeight;
        MatInRect.right = MatInRect.left + MatWidth;
 
        MatOutRect.top = MatInRect.bottom + MatInterval;
        MatOutRect.bottom = MatOutRect.top + MatHeight;
        MatOutRect.right = MatOutRect.left + MatWidth;
 
        MatERect.top = MatOutRect.bottom + MatInterval;
        MatERect.bottom = MatERect.top + MatHeight;
        MatERect.right = MatERect.left + MatWidth;
 
        ResRect.bottom = ResRect.top + cy - MatInRect.top - 5;
        ResRect.left = MatInRect.right+5;
        ResRect.right = cx-5;
 
        //Установка нового положения для компонентов на форме:
        m_MatrixIn.MoveWindow(MatInRect, TRUE);
        m_MatrixOut.MoveWindow(MatOutRect, TRUE);
        m_MatrixE.MoveWindow(MatERect, TRUE);
        m_Results.MoveWindow(ResRect, TRUE);
 
        //Установка нового положения для подписей:
        m_Static1.MoveWindow(MatInRect.left,MatInRect.top-15,MatInRect.right-MatInRect.left,15, TRUE);
        m_Static2.MoveWindow(MatOutRect.left,MatOutRect.top-15,MatOutRect.right-MatOutRect.left,15, TRUE);
        m_Static3.MoveWindow(MatERect.left,MatERect.top-15,MatERect.right-MatERect.left,15, TRUE);
        m_Static4.MoveWindow(10,(MatInRect.bottom + MatInRect.top)/2,20,15, TRUE);
        m_Static5.MoveWindow(10,(MatOutRect.bottom + MatOutRect.top)/2,30,15, TRUE);
        m_Static6.MoveWindow(15,(MatOutRect.bottom + MatOutRect.top)/2-5,10,10, TRUE);
        m_Static7.MoveWindow(3,(MatERect.bottom + MatERect.top)/2,40,15, TRUE);
        m_Static8.MoveWindow(25,(MatERect.bottom + MatERect.top)/2-5,10,10, TRUE);
        m_Static9.MoveWindow(ResRect.left,ResRect.top-15,ResRect.right-ResRect.left,15, TRUE);
    }
}
 
void CGaussGDlg::OnMenuitemExit() 
{
    CDialog::OnCancel();    
}
 
//Генерация случайных значений элементов исходной матрицы из заданного диапазона:
void CGaussGDlg::OnMenuitemGen() 
{
    //Загрузка диалога задания диапазона случайных значений:
    CGenGialog GenDlg;
    if (GenDlg.DoModal() == IDOK)
    {
        srand((unsigned)time(NULL));
        for (int i=0;i<m_Dim;i++)
            for (int j=0;j<m_Dim;j++)
            {
                //Генерация целого случайного числа из диапазона 0.."До"-"От"+1:
                CString stCell;
                stCell.Format("%d", rand()%(GenDlg.m_GenTo - GenDlg.m_GenFrom+1));          
                //Приведение полученного числа к допустимому (заданному) диапазону:
                int g = atoi(stCell) + GenDlg.m_GenFrom;
                stCell.Format("%d", g);
                m_MatrixIn.SetTextMatrix(i,j, stCell);
            }
        UpdateData(false);
    }
}
 
//Очистка окон для ввода новых данных:
void CGaussGDlg::OnMenuitemClear() 
{
    int i,j;
    for (i=0;i<m_Dim;i++)
        for (j=0;j<m_Dim;j++)
        {
            m_MatrixIn.SetTextMatrix(i,j,"");
            m_MatrixOut.SetTextMatrix(i,j,"");
            m_MatrixE.SetTextMatrix(i,j,"");
        }
    m_EdCalc = "";
    UpdateData(false);  
}
 
//Проверка - умножение исходной матрицы на полученную обратную и вывод результирующей 
//матрицы на экран (должна получиться единичная матрицы):
void CGaussGDlg::OnMenuitemTest() 
{
    //Передача данных из сетки исходной матрицы:
    UpdateData(true);
    double A[20][20];  //Исходная матрица
    double z[20][20];  //Результат перемножения исходной и обратной матриц:
    int i, j;
    for (i=0;i<m_Dim;i++)
        for (j=0;j<m_Dim;j++)
        {
            CString str = m_MatrixIn.GetTextMatrix(i,j);
            //Если данные введены не во все элементы сетки, выводится сообщение об ошибке:
            if (str!="")
                A[i][j] = atof(str);
            else
            {
                MessageBox("Не заданы элементы исходной матрицы!","Ошибка", MB_OK|MB_ICONERROR);       
                return;
            }
        }
 
    //Перемножение исходной матрицы на обратную:
    for (i=0;i<m_Dim;i++)
        for (j=0;j<m_Dim;j++)
        {
            z[i][j] = 0;
            for (int t=0;t<m_Dim;t++)
                z[i][j] =  z[i][j] + A[i][t]*AObr[t][j];
            CString stCell;
            stCell.Format("%.4f", z[i][j]);
            m_MatrixE.SetTextMatrix(i,j, stCell);
        }
    UpdateData(false);
}
 
//Нахождение обратной матрицы методом Гаусса-Жордана:
void CGaussGDlg::OnMenuitemCalc() 
{
    //Передача данных из матрицы сетки в служебную матрицу А:
    UpdateData(true);
    double A[20][20];
    int i, j;
    for (i=0;i<m_Dim;i++)
        for (j=0;j<m_Dim;j++)
        {
            CString str = m_MatrixIn.GetTextMatrix(i,j);
            //Если данные введены не во все элементы сетки, выводится сообщение об ошибке:
            if (str!="")
                A[i][j] = atof(str);
            else
            {
                MessageBox("Не заданы элементы исходной матрицы!","Ошибка", MB_OK|MB_ICONERROR);       
                return;
            }
        }
 
    //Создание временной матрицы А1 для хранения значений элементов матрицы А:
    for (i=0;i<m_Dim;i++)
        for (j=0;j<m_Dim;j++)
            AObr[i][j] = A[i][j];
 
    double L[20][20];
    CString stResults = "";
    
    //Заполнение матрицы L как единичной матрицы:
    for (i=0; i<m_Dim; i++)
        for (j=0; j<m_Dim; j++)
            if (i!=j) L[i][j]=0;
            else L[i][j]=1;
    
    m_EdCalc = "";
    ShowResults(-1, A, L);
 
    //Последовательно для каждой строки исходной матрицы и единичной матрицы проводятся 
    //следующие действия: 
    //1)Деление текущей строки матрицы на ведущий элемент
    //2)Исключение элементов матрицы над ведущим элементом
    //3)Исключение элементов матрицы под ведущим элементом
    for (i=0; i<m_Dim; i++)
    {
        //Проверка не равен ли ведущий элемент 0. Если равен, то ищем строку с
        //ненулевым i-м элементом и меняем ее местами с текущей i-й строкой:
        double p = A[i][i];
        if (p==0)
        {
            int j = i+1;
            while ((A[j][i]==0) && (j<m_Dim)) 
                j++;
            if (j<m_Dim)
            {
                //Если строка найдена, меняем значения текущей и найденной строк:
                for (int k=0; k<m_Dim; k++)
                {
                    double Temp = A[i][k];
                    A[i][k] = A[j][k];
                    A[j][k] = Temp;
                }
                p = A[i][i];
            } //if (j<n)
            //Если ненулевой элемент не найден, значит исходная матрица - вырожденная:
            else
            {
                m_EdCalc = "";
                UpdateData(false);
                MessageBox("Исходная матрица вырожденная!","Ошибка", MB_OK|MB_ICONERROR);       
                return;
            }
        } //if (p==0)
        
        //Деление текущей строки основной и единичной матрицы на ведущий элемент:
        for (j=0; j<m_Dim; j++)
        {
            A[i][j] = A[i][j]/p;
            L[i][j] = L[i][j]/p;
        } //for j
 
        //Исключение элементов основной и единичной матрицы над ведущим элементом:
        for (int k=0; k<i; k++)
        {
            p = A[k][i];
            for (j=0; j<m_Dim; j++)
            {
                L[k][j] = L[k][j] - p*L[i][j];
                A[k][j] = A[k][j] - p*A[i][j];
            } //for j
        } //for k
        
        //Исключение элементов основной и единичной матрицы под ведущим элементом:
        for (k=i+1; k<m_Dim; k++)
        {
            p = A[k][i];
            for (j=0; j<m_Dim; j++)
            {
                L[k][j] = L[k][j] - p*L[i][j];
                A[k][j] = A[k][j] - p*A[i][j];
            } //for j
        } //for k
 
        ShowResults(i, A, L);
    } //for i   
    
    //Вывод элементов полученной матрицы в сетку:
    for (i=0;i<m_Dim;i++)
        for (int j=0;j<m_Dim;j++)
        {
            AObr[i][j] = L[i][j]; //Сохранение обратной матрицы для последующей проверки
            CString stCell;
            stCell.Format("%.4f", AObr[i][j]);
            m_MatrixOut.SetTextMatrix(i,j, stCell);
        }
}
 
//Сохранение результатов расчетов в текстовый файл:
void CGaussGDlg::OnMenuitemSaveRes() 
{
    //Формирование очередного имени файла по умолчанию для сохранения (results1.txt, 
    //results2.tx...):
    CString FileName = "results";
    CString NFile;
    NFile.Format("%d", m_NumberSave);
    FileName = FileName + NFile + ".txt";
 
    CFileDialog fileDlg (FALSE, "txt", FileName, NULL,
        "Текстовые файлы (*.txt)|*.txt|Все файлы(*.*)|*.*||");
    if(fileDlg.DoModal() == IDOK)
        {
            FILE *stream;
            if((stream = fopen(fileDlg.GetFileName(), "wt" )) == NULL )
            {
                MessageBox("Ошибка сохранения!", "Ошибка", MB_OK|MB_ICONERROR);
                return;
            }
 
            fprintf(stream, m_EdCalc);
 
            if(fclose(stream))
            {
                MessageBox("Ошибка сохранения!", "Ошибка", MB_OK|MB_ICONERROR);
                return;
            }
            m_NumberSave++;//Установка номера очередного файла для сохранения по умолчанию
        }
}
 
//Загрузка результатов расчетов из текстового файла:
void CGaussGDlg::OnMenuitemOpenRes() 
{
    CFileDialog fileDlg (TRUE, "txt", NULL, NULL,
        "Текстовые файлы (*.txt)|*.txt|Все файлы(*.*)|*.*||");
        if(fileDlg.DoModal() == IDOK)
        {
            //Файл открываетс в ассоциированном с ним приложении (обычно -  "Блокнот"):
            ShellExecute(NULL, "open", fileDlg.GetFileName(), NULL, NULL, SW_SHOWNORMAL);
        }
}

//Исключение элементов основной и единичной матрицы под ведущим элементом:
     for (int k=i+1; k<m_Dim; k++)

BEGIN_MESSAGE_MAP(CGaussGDlg, CDialog)
    //{{AFX_MSG_MAP(CGaussGDlg)
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_EN_CHANGE(IDC_EDIT1, OnChangeEdit1)
    ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN1, OnDeltaposSpin1)
    ON_WM_SIZE()
    ON_COMMAND(ID_MENUITEM_EXIT, OnMenuitemExit)
    ON_COMMAND(ID_MENUITEM_GEN, OnMenuitemGen)
    ON_COMMAND(ID_MENUITEM_CLEAR, OnMenuitemClear)
    ON_COMMAND(ID_MENUITEM_TEST, OnMenuitemTest)
    ON_COMMAND(ID_MENUITEM_CALC, OnMenuitemCalc)
    ON_COMMAND(ID_MENUITEM_SAVE_RES, OnMenuitemSaveRes)
    ON_BN_CLICKED(IDC_BUTTON1, OnMenuitemCalc)
    ON_BN_CLICKED(IDC_BUTTON2, OnMenuitemTest)
    ON_COMMAND(ID_MENUITEM_OPEN_RES, OnMenuitemOpenRes)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

char* cstr=NULL;//указатель на строку как в Си.
//раньше было cstr="Hello"; но ты решил проверить, что будет если передать NULL
std::string cppstr(cstr);//строка как в С++