С++ потоки паралельные pthread

[maksum1990]

Помогите пожалуйста переделать С консольного в С формами, я изучал только С++ консоль, а C++ form нет. Буду очень благодарен.
// paral.cpp: определяет точку входа для консольного приложения.
//
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include "windows.h"

LARGE_INTEGER b_start, b_stop, b_time, freq;

bool visual_mode = false;

int **matrixA;
int **matrixB;
int **matrixC;

int threads_count;
int matrix_size;
struct positions *pos;

struct positions{
int from;
int to;
};

void allocateMemory( int **&matrixA, int **&matrixB, int **&matrixC, struct positions *&pos, pthread_t *&threads, int matrix_size, int thread_count );
void initMatrixs( int **&matrixA, int **&matrixB, int **&matrixC, int matrix_size);
void calculateSliceMatrix( struct positions *&pos, int matrix_size, int step, int threads_count );
void* multiply(void *part_id);
void clearMultipy( int **&matrixA, int **&matrixB, int **&matrixC, int matrix_size );
void printMatrix(int **matrix);
void startInterval();
void endInterval();

int main(){

int step;

pthread_t *threads;

do{

printf("Enter threads count:");
scanf("%d", &threads_count);

} while( threads_count%4 != 0 );

do{

printf("Enter matrix size:");
scanf("%d", &matrix_size);

} while( matrix_size%4 != 0 );

step = matrix_size/threads_count;

allocateMemory( matrixA, matrixB, matrixC, pos, threads, matrix_size, threads_count );
initMatrixs( matrixA, matrixB, matrixC, matrix_size );
calculateSliceMatrix( pos, matrix_size, step, threads_count );

startInterval();

for( int i = 0; i < threads_count; i++ ){

pthread_create( &threads[i], NULL, multiply, (void *)i );
pthread_join( threads[i], NULL );

}

endInterval();

startInterval();

clearMultipy( matrixA, matrixB, matrixC, matrix_size );

endInterval();



if( visual_mode){

printMatrix(matrixA);
printf("\n");
printMatrix(matrixB);
printf("\n");
printMatrix(matrixC);

}

_getch();

}

void allocateMemory( int **&matrixA, int **&matrixB, int **&matrixC, struct positions *&pos, pthread_t *&threads, int matrix_size, int thread_count ){

matrixA = new int*[matrix_size];
matrixB = new int*[matrix_size];
matrixC = new int*[matrix_size];

pos = new struct positions[thread_count];

threads = new pthread_t[threads_count];

for ( int i = 0; i < matrix_size; i++ ){

matrixA[i] = new int[matrix_size];
matrixB[i] = new int[matrix_size];
matrixC[i] = new int[matrix_size];

}

}

void initMatrixs( int **&matrixA, int **&matrixB, int **&matrixC, int matrix_size){

srand(time(0));

for(int i = 0; i < matrix_size; i++){
for(int j = 0; j < matrix_size; j++){
matrixA[i][j] = rand()%3;
matrixB[i][j] = rand()%3;
matrixC[i][j] = 0;
}
}

}

void calculateSliceMatrix( struct positions *&pos, int matrix_size, int step, int threads_count ){

int position = 0;

for(int i = 0; i < threads_count; i++){

pos[i].from = position;
pos[i].to = position+step;
position += step;

}

}

void* multiply(void *part_id){

for( int i = pos[(int)part_id].from; i < pos[(int)part_id].to; i++){
for( int j = 0; j < matrix_size; j++){
for( int k = 0; k < matrix_size; k++ )
matrixC[i][k] += matrixA[i][j] * matrixB[j][k];
}
}

return 0;
}

void clearMultipy( int **&matrixA, int **&matrixB, int **&matrixC, int matrix_size ){

for( int i = 0; i < matrix_size; i++){
for( int j = 0; j < matrix_size; j++){
for( int k = 0; k < matrix_size; k++ )
matrixC[i][k] += matrixA[i][j] * matrixB[j][k];
}
}

}

void printMatrix(int **matrix){

for(int i = 0; i < matrix_size; i++){
for(int j = 0; j < matrix_size; j++){
printf("%3d", matrix[i][j]);
}
printf("\n");
}

}

void startInterval(){

QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&b_start);

}

void endInterval(){

QueryPerformanceCounter(&b_stop);
b_time.QuadPart = b_stop.QuadPart - b_start.QuadPart;
printf("\nTime: %lf sec.\n", (double)(b_time.QuadPart)/(double)(freq.QuadPart));

}