Получение значения через список параметров

int *X=NULL;

double **Func(int **X) {
*X = new int[size];
for (int i=0; i<size; i++)
      *X[i] = someINT;
}

double **Y = Func(&X);

X = new int[size];
Func(X, size);

void Func(int *X, int size)
{
    for (int i=0; i<size; i++)
         X[i] = someINT;
}

extern "C" _CRTIMP int __cdecl _CrtIsValidHeapPointer(
        const void * pUserData
        )
{
        if (!pUserData)
            return FALSE;
 
        if (!_CrtIsValidPointer(pHdr(pUserData), sizeof(_CrtMemBlockHeader), FALSE))
            return FALSE;
 
        return HeapValidate( _crtheap, 0, pHdr(pUserData) );
}// ЗДЕСЬ КУРСОР

(*X)[i] = someINT;

case WM_DESTROY:
        {
            if (Pixels!=NULL)
            {
                for (i=0; i<rCount; i++)
                    delete[]Pixels[i];
                delete[]Pixels;
            }
            if (Weights!=NULL)
                delete[]Weights; // ЗДЕСЬ ОШИБКА! Видимо из-за того, что выделял память под веса в функции
            if (count!=NULL)
                delete[]count;
            if (Max != NULL)
                delete[]Max;
            if (Min != NULL)
                delete[]Min;
            if (d!=NULL)
                delete[]d;
 
            PostQuitMessage(0);
        };break;

double *Weights = InitializeWeights();
//function:
double *InitializeWeights()
{
    double *weights;
    int rnd;
    weights = new double[SQUARE*SQUARE];
    srand(time(NULL));
    for (int i=0; i<SQUARE*SQUARE; i++)
    {
        rnd = rand() % 21 - 10;
        weights[i] = (double) rnd / (double) 10;
    }
    return weights;
}

if (ptr != NULL)
    delete [] ptr;

#include "BMP.h";
 
int rCount;
double **Pixels=NULL;
char *fn=NULL;
double *Weights = NULL;
//double *Y = NULL;
int *d=NULL;
int **count=NULL;
//double **MaxMin=NULL;
double f=0;
double *Max=NULL;
double *Min=NULL;
 
LRESULT CALLBACK MainProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
HINSTANCE hInst;
char ClassName[]="Window";
char AppTitle[]="Lab1";
int wx, wy;
HDC hdc;
 
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASS wc;
    HWND hWnd;
    MSG msg;
    hInst=hInstance;
 
    if((hWnd=FindWindow(ClassName, NULL))!=NULL)
    {
        if(IsIconic(hWnd)) ShowWindow(hWnd, SW_RESTORE);
        SetForegroundWindow(hWnd);
        return FALSE;
    }
 
    memset(&wc, 0, sizeof(wc));
    wc.lpszClassName=ClassName;
    wc.lpfnWndProc=(WNDPROC)MainProc;   
    wc.style=CS_HREDRAW|CS_VREDRAW;
    wc.hInstance=hInstance;
    wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);
    wc.hCursor=LoadCursor(NULL,IDC_ARROW);  
    wc.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);   
    wc.lpszMenuName=NULL;
    wc.cbClsExtra=0;
    wc.cbWndExtra=0;        
    RegisterClass(&wc);
    hdc = GetDC(NULL);
    wx = GetDeviceCaps(hdc, HORZRES);
    wy = GetDeviceCaps(hdc, VERTRES);
    hWnd=CreateWindow(ClassName, AppTitle, WS_OVERLAPPED|WS_SYSMENU|WS_MINIMIZEBOX|WS_THICKFRAME, CW_USEDEFAULT, CW_USEDEFAULT, wx, wy, NULL, NULL, hInst, NULL);   
 
    if(!hWnd) 
    {
        MessageBox(NULL, "Create: error",AppTitle,MB_OK|MB_ICONSTOP);
        return FALSE;
    }
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
    while(GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}
 
LRESULT CALLBACK MainProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    char buf[250]="\0";
    int i, j;
    int Letter;
 
    switch(msg)
    {
    case WM_CREATE:
        {
            CreateWindow("BUTTON", "Загрузить картинку", WS_CHILD|WS_VISIBLE, 5, 5, 150, 30, hWnd, (HMENU)0, 0, 0);
            CreateWindow("BUTTON", "Я?", WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX, 5, 45, 100, 30, hWnd, (HMENU)4, 0, 0);
            CreateWindow("BUTTON", "Ы?", WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX, 110, 45, 100, 30, hWnd, (HMENU)5, 0, 0);
            CreateWindow("BUTTON", "Обучить сеть", WS_CHILD|WS_VISIBLE, 5, 85, 150, 30, hWnd, (HMENU)1, 0, 0);
            CreateWindow("BUTTON", "Проверить картинку", WS_CHILD|WS_VISIBLE, 5, 120, 150, 30, hWnd, (HMENU)2, 0, 0);
            CreateWindow("STATIC", "", WS_CHILD|WS_VISIBLE|SS_BITMAP, 160, 5, 150, 150, hWnd, (HMENU)3, 0, 0);
            HWND hwndCheck = GetDlgItem(hWnd, 4);
            
                CheckDlgButton(hWnd, 4, BST_CHECKED); 
            //SendMessage(hwndCheck, BST_CHECKED, 0, 0);
                
        };break;
 
    case WM_COMMAND:
        {
            if (LOWORD(wParam)==4)
            {
                CheckDlgButton(hWnd, 5, BST_UNCHECKED);
            }
            if (LOWORD(wParam)==5)
            {
                CheckDlgButton(hWnd, 4, BST_UNCHECKED);
            }
            if (LOWORD(wParam)==0)   // Загрузка картинки и считывание её данных
            {
                fn = OpenFileDlg(hWnd);
                Letter = 1;
                if (fn)
                {
                    memcpy(buf, fn, sizeof(buf));
                    NormalizeFileName(buf);
                    MyBMP *bmp = new MyBMP();
                    bmp->LoadBMP(buf);
                    if (bmp->height == 150 && bmp->width == 150)
                    {
                        HWND hwndCheck = GetDlgItem(hWnd, 4);
                        LRESULT res = SendMessage (hwndCheck, BM_GETCHECK, 0, 0);
                        if(res == BST_CHECKED)
                            Letter = 1;
                        else
                            Letter = -1;
 
                        WriteTXT(bmp, Letter);
                        LoadStaticBitmapFromFile(buf, hWnd, 3);
                    }
                }
            }
 
            if (LOWORD(wParam)==1) //Обучение
            {
                char *file=NULL;
                char buffer[255] = "";
                FILE *f;
                int k=0, j=0;
                fn = OpenFileDlg(hWnd);
                if (fn!=NULL)
                {
                    memcpy(buf, fn, sizeof(buf));
                    NormalizeFileName(buf);
                    f = fopen(buf, "r");
                    rCount = rowCount(f);
                    if (rCount>0)
                    {
                        Max = new double[SQUARE*SQUARE];
                        Min = new double[SQUARE*SQUARE];
                        d = new int[rCount];
                        Pixels = ReadTXT(f, rCount, d);
                        Pixels = NormalizeData(Pixels, Max, Min, rCount);
                        for (i=0; i<rCount; i++)
                        {
                            sprintf(buf, "d[%d] = %d", i, d[i]);
                            MessageBox(NULL, buf, "112", 0);
                        }
                        Weights = InitializeWeights();
                        Training(Weights, Pixels, d, rCount);
                    }
                }                                 
            }
 
            if (LOWORD(wParam)==2) //Проверка
            {
                fn = OpenFileDlg(hWnd);
                if (fn)
                {
                    memcpy(buf, fn, sizeof(buf));
                    NormalizeFileName(buf);
                    MyBMP *bmp = new MyBMP();
                    bmp->LoadBMP(buf);
                    if (bmp->height == 150 && bmp->width == 150)
                    {
                        count = CountPixels(bmp);
                        /*for (i=0; i<SQUARE; i++)
                        {
                            for (j=0; j<SQUARE; j++)
                            {
                                if (count[i][j] == MaxMin[i*SQUARE+j][0]) count[i][j] = 1;
                                else if (count[i][j] == MaxMin[i*SQUARE+j][1]) count[i][j] = -1;
                                else if (count[i][j] >= ((MaxMin[i*SQUARE+j][0] - MaxMin[i*SQUARE+j][1]/2))) count[i][j] /= MaxMin[i*SQUARE+j][0] - MaxMin[i*SQUARE+j][1];
                                else if (count[i][j] < ((MaxMin[i*SQUARE+j][0] - MaxMin[i*SQUARE+j][1]) / 2)) count[i][j] /= - MaxMin[i*SQUARE+j][0] + MaxMin[i*SQUARE+j][1];
                            }
                        }
                        
                        f=0;
                        for (i=0; i<SQUARE; i++)
                            for (j=0; j<SQUARE; j++)
                                f += count[i][j] * Weights[i*SQUARE+j];
                        f -= B;
                        if (f > 0) f = 1;
                        else if (f < 0) f = -1;
                        if(f==1) MessageBox(hWnd, "Я", "Результат", 0);
                        else if (f==-1) MessageBox(hWnd, "Ы", "Результат", 0);
                        LoadStaticBitmapFromFile(buf, hWnd, 3);   */
                    }
                }
            }
        };break;
 
    case WM_PAINT:
        {
            
        };break;
 
    case WM_DESTROY:
        {
            if (Pixels!=NULL)
            {
                for (i=0; i<rCount; i++)
                    delete[]Pixels[i];
                delete[]Pixels;
            }
 
            PostQuitMessage(0);
        };break;
                               
    default: return DefWindowProc(hWnd, msg, wParam, lParam);
    return 0l;
    }
}

#include <windows.h>
#include <stdio.h>
#include <io.h>
#include <stdlib.h>
#include <conio.h>
#include <winuser.h>
#include <stdio.h>
#include <conio.h>
#include <wingdi.h>
#include <math.h>
#include <Dlgs.h>
#include <commdlg.h>
#include <string.h>
#include <time.h>
 
#define SQUARE 3
#define B 0.7
 
char *OpenFileDlg(HWND hwnd)
{
    OPENFILENAME ofn;
    char szFile[150]="\0";
 
    ZeroMemory(&ofn, sizeof(OPENFILENAME));
    ofn.lStructSize = sizeof(OPENFILENAME);
    ofn.hwndOwner = hwnd;
    ofn.lpstrFile = szFile;
    ofn.nMaxFile = sizeof(szFile);
    ofn.lpstrFilter = "ALL\0*.*\0BMP\0*.BMP\0TXT\0*.TXT\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = "C:\\";
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;  
 
    if (GetOpenFileName(&ofn)==TRUE)
    {
        return szFile;      
    }
    return NULL;
}
 
double **ReadTXT(FILE *f, int Rows, int *d)
{
    double **P=NULL;
    char str[255];
    char num[255];
    char ddd[10];
    int i, k, j, l;
    if (f!=NULL)
    {
        P = new double*[Rows];
        for (j=0; j<Rows; j++)
            P[j] = new double[SQUARE*SQUARE];
 
        fseek(f, 0, SEEK_SET);
        for (i=0; i<Rows; i++)
        {
            memset(str, 0, sizeof(str));
            memset(num, 0, sizeof(num));
            fgets(str, 255, f);
            k=-1;
            j=0;
            l=0;
            do
            {
                k++;
                if (str[k] == ' ' || str[k] == '=')
                {
                    P[i][j] = atof(num);
                    j++;
                    memset(num, 0, sizeof(num));
                    l=0;
 
                    if (str[k]=='=')
                    {
                        memset(ddd, 0, sizeof(ddd));
                        if (str[k+1]=='1')
                        {
                            ddd[0] = str[k+1];
                        }
                        else
                        {
                            ddd[0] = str[k+1];
                            ddd[1] = str[k+2];
                        }
                        d[i] = atoi(ddd);
                    }
                }
                else
                {
                    num[l] = str[k];
                    l++;              
                }
                
            } while (str[k]!='=');
        }
        return P;
    }
    return NULL;
}
 
int rowCount(FILE *f)
{
    int rc=-1;
    char buf[255];
    if (f)
    {
        while(!feof(f))
        {
            fgets(buf, 255, f);
            rc++;
        }
        return rc;
    }
    return rc;
}
 
void NormalizeFileName(char *filename)
{
    if (filename!=NULL)
    {
        char buf[255];
        int i, k;
        memset(buf, 0, sizeof(buf));
        i=0;
        k=0;
        while (filename[i]!='\0')
        {
            if (filename[i] == '\\')
                filename[i] = '/';
            i++;
        }
    }
}
 
double **NormalizeData(double **Pixs, double *Max, double *Min, int N)
{
    int i, j, k;
    char buf[255];
 
    if (Pixs!=NULL)
    {
        for (i=0; i<SQUARE*SQUARE; i++)
        {
            Max[i] = MININT;
            Min[i] = MAXINT;
            for (j=0; j<N; j++)
            {
                if (Max[i] < Pixs[j][i])
                    Max[i] = Pixs[j][i];
                if (Min[i] > Pixs[j][i])
                    Min[i] = Pixs[j][i];
            }
            
        }
 
        for (i=0; i<SQUARE*SQUARE; i++)
            for (j=0; j<N; j++)
            {
                if (Max[i] == Pixs[j][i])
                {
                    Pixs[j][i] = 1;
                    continue;
                }
                if (Min[i] == Pixs[j][i])
                {
                    Pixs[j][i] = 0;
                    continue;
                }
                Pixs[j][i] =  Pixs[j][i] / (Max[i] - Min[i]);
            }
        return Pixs;
    }
    else
        return NULL;
}
 
double *InitializeWeights()
{
    double *weights;
    int rnd;
    weights = new double[SQUARE*SQUARE];
    srand(time(NULL));
    for (int i=0; i<SQUARE*SQUARE; i++)
    {
        rnd = rand() % 21 - 10;
        weights[i] = (double) rnd / (double) 10;
    }
    return weights;
}
 
void Training(double *W, double **Pixs, int *d, int N)
{
    int i, j, k;
    double *y = NULL;
    double r;
 
    y = new double[N];
    for (i=0; i<N; i++)
        y[i] = -B;
 
    for (i=0; i<N; i++)
    {
        for (j=0; j<SQUARE*SQUARE; j++)
        {
            y[i] += W[j] * Pixs[i][j];
        }
        if (y[i] > 0)
            y[i] = 1;
        else if (y[i] < 0)
            y[i] = -1;
        if (y[i] != d[i])
        {
            r = d[i] - y[i];
            for (k = 0; k < N; k++)
                W[k] += (r * Pixs[i][k]);
            //i=0;
        }
    }
}
 
class MyBMP
{
public:
    BITMAPFILEHEADER fileHeader;
    BITMAPINFOHEADER bih;
    RGBTRIPLE **colors;
    int width, height;
 
    MyBMP()
    {
        colors=NULL;
        height=0;
        width=0;
        memset(&fileHeader, 0, sizeof(BITMAPFILEHEADER));
        memset(&bih, 0, sizeof(BITMAPINFOHEADER));
    }
 
    void NewMyBMP()
    {
        if (colors)
        {
            for(int i=0;i<height;i++)
                delete[]colors[i];
            delete[]colors;
        }
        height=0;
        width=0;
        colors=NULL;
        memset(&fileHeader, 0, sizeof(BITMAPFILEHEADER));
        memset(&bih, 0, sizeof(BITMAPINFOHEADER));
    }
 
    ~MyBMP()
    {
        for(int i=0;i<height;i++)
            delete[]colors[i];
        delete[]colors;
        height=0;
        width=0;
        colors=NULL;
        memset(&fileHeader, 0, sizeof(BITMAPFILEHEADER));
        memset(&bih, 0, sizeof(BITMAPINFOHEADER));
    }
 
    void NewColors()
    {
        if (colors)
        {
            for(int i=0; i<height; i++)
            {
                delete[]colors[i];
            }
            delete[]colors; 
        }
        width = bih.biWidth;
        height = bih.biHeight;
        colors=new RGBTRIPLE*[height];
        for(int i=0; i<height; i++)
        {
            colors[i] = new RGBTRIPLE[width];
        }
    }
 
    void LoadBMP(char *filename)
    {
        FILE *bmpname;
        int i, j, size, n, off;
        char buf[1024];
 
        bmpname = fopen(filename, "rb");
        if (bmpname!=NULL)
        {
            fread(&fileHeader, sizeof(BITMAPFILEHEADER), 1, bmpname);
            fread(&bih, sizeof(BITMAPINFOHEADER), 1, bmpname);
            if(fileHeader.bfType==19778)
            {
                off = bih.biWidth % 4;
                fseek(bmpname, fileHeader.bfOffBits, SEEK_SET);
                NewColors();
                for(i=height-1;i>=0;i--)
                {
                    for(j=0;j<width;j++)
                    {
                        fread((char*)&colors[i][j].rgbtBlue,1, 1, bmpname);
                        fread((char*)&colors[i][j].rgbtGreen,1, 1, bmpname);
                        fread((char*)&colors[i][j].rgbtRed,1, 1, bmpname);
                    }
                    if(off!=0)
                        fread((char*)&buf, 1, off, bmpname);
                }
            } 
            width = bih.biWidth;
            height = bih.biHeight;
            fclose(bmpname);
        }
    }
};
 
int **CountPixels(MyBMP *bmp)
{
    int i, j;
    int kX, kY;   // пиксельное выражение квадрата
    int indX, indY; //координаты квадрата   
    if (bmp!=NULL)
    {
        int **count;
        count = new int*[SQUARE];
        for (i=0; i<SQUARE; i++)
        {
            count[i] = new int[SQUARE];
        }
        for (i=0; i<SQUARE; i++)
            for (j=0; j<SQUARE; j++)
            {
                count[i][j] = 0;
            }
        kX = 0;
        kY = 0;
        indX = 0;
        indY = 0;
        do
        {
            if (kX==bmp->width)
            {
                kY=kY+(bmp->height/SQUARE);
                if (kY==bmp->height)
                    break;
                kX=0;
                indX++;
                indY=0;
            }
            for (i=kX; i<(bmp->width/SQUARE+kX); i++)
            {
                for (j=kY; j<(bmp->height/SQUARE+kY); j++)
                {
                    if (bmp->colors[j][i].rgbtRed==0 && bmp->colors[j][i].rgbtGreen==0 && bmp->colors[j][i].rgbtBlue==0)
                        count[indX][indY]++;
                }
            }
            kX = kX + (bmp->width/SQUARE);
        } while (1);
        return count;
    }
    return NULL;
}
 
void WriteTXT(MyBMP *bmp, int L)
{
    int i, j;
    int **count=NULL;
    char buffer[250]="\0";
    char forNums[20]="\0";
    int kX, kY;   // пиксельное выражение квадрата
    int indX, indY; //координаты квадрата   
    FILE *f;
    kX = 0;
    kY = 0;
    indX = 0;
    indY = 0;
    count = CountPixels(bmp);
    f = fopen("C:/tester.txt", "a");
    for (i=0; i<SQUARE; i++)
    {
        for (j=0; j<SQUARE; j++)
        {
            memset(forNums, 0, sizeof(forNums));
            if (i==0 && j==0)
                sprintf(forNums, "%d", count[i][j]);
            else
                sprintf(forNums, " %d", count[i][j]);
            strcat(buffer, forNums);
        }
    }
    sprintf(forNums, "=%d", L);
    strcat(buffer, forNums);
    fwrite(buffer, sizeof(buffer), 1, f);
    fwrite("\n", sizeof(char), 1, f);
    fclose(f);
    for (i=0; i<SQUARE; i++)
        delete [] count[i];
    delete [] count;
}
 
BOOL LoadStaticBitmapFromFile(LPCTSTR pszFile, // file name
    HWND hWndDialog,  // parent dialog handle
    UINT nIDStatic)   // static control ID
{
    BOOL bRet = FALSE;
    HWND hWndStatic = GetDlgItem(hWndDialog, nIDStatic);
    if(NULL != hWndStatic)
    {
        HBITMAP hBitmap = (HBITMAP)LoadImage(NULL,
            pszFile,          // file containing bitmap
            IMAGE_BITMAP,     // type = bitmap
            0, 0,             // original size
            LR_LOADFROMFILE); // get image from a file
        if(NULL != hBitmap)
        {
            SendMessage(hWndStatic,
                STM_SETIMAGE,         // message to send
                (WPARAM)IMAGE_BITMAP, // bitmap type
                (LPARAM)hBitmap);     // bitmap handle
            bRet = TRUE;
        }
        else
        {
            // handle/display error 
            // see this FAQ
        }           
    }
    return bRet;
}

void Training(double *W, double **Pixs, int *d, int N)
{
    int i, j, k;
    double *y = NULL;
    double r;
 
    y = new double[N];
    for (i=0; i<N; i++)
        y[i] = -B;
 
    for (i=0; i<N; i++)
    {
        for (j=0; j<SQUARE*SQUARE; j++)
        {
            y[i] += W[j] * Pixs[i][j];
        }
        if (y[i] > 0)
            y[i] = 1;
        else if (y[i] < 0)
            y[i] = -1;
        if (y[i] != d[i])
        {
            r = d[i] - y[i];
            for (k = 0; k < N; k++)
                W[k] += (r * Pixs[i][k]);
            //i=0;
        }
    }
}

            for (i=0; i<SQUARE*SQUARE; i++)
                printf("%d", Weights[i]); 
            delete[]Weights;