Dynamiczne alokowanie dwuwymiarowej tablicy.

Witam moim zadaniem jest dynamiczna alokacja dwuwymiarowej tablicy w funkcji,
Funkcja wygląda następująco;

int stworz_tablice(float **ptr, int N)

N - to liczba elementów do zaalokowania
ptr - to wskaźnik, pod który ma zostać zapisany adres utworzonej tablicy

Oto mój kod

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int stworz_tablice(float **ptr, int N)
{
	
	if(N < 0) return 2;
	

	ptr=(float **)malloc(sizeof(float *)*N);
	
	int i,j;
	for(i=0;i<N;i++)
	{
		*(ptr+i)=(float*)malloc(sizeof(float)*N);
		if(ptr+i==NULL)
		{
			for(j=0;j<i;j++)
			{
				free(*(ptr+j));
			}
			free(ptr);
			return 1;
		}
	}	
		return 0;
}

int main() 
{
	int x,i,j;
	float c;
	float **wsk;
	float a=-10,b=10;
	srand(time(0));
	printf("Podaj ile liczb :");
	scanf("%d",&x);
	if(stworz_tablice(wsk,x)!=0)
	{
		printf("Error");
		return 1;
	}
	

	for(i=0;i<x;i++)
	{
		for(j=0;j<x;j++)
		{
			*(*(wsk+i)+j)=a+(float)rand()/RAND_MAX*(a-b);
		}
	}
	for(i=0;i<x;i++)
	{
		for(j=0;j<x;j++)
		{
			printf("%f ",*(*(wsk+i)+j));
		}
	}
	
	
	return 0;
}

Program w pewnym momencie się zawiesza , nie dokońca wiem co jest tego przyczyną.

Błękitny Szczur napisał(a):

Program w pewnym momencie się zawiesza , nie dokońca wiem co jest tego przyczyną.

Czyli w którym momencie???

Zamiast pisać *(*(wsk+i)+j) czytelniej (a semantycznie dokładnie tak samo!): wsk[i][j] -- tak przy okazji.

A nie powinno być:

int stworz_tablice(float ***ptr, int N)
{
 
    if(N < 0) return 2;
 
    *ptr=(float **)malloc(sizeof(float *)*N);

i tak dalej? (*ptr zamiast ptr)

I potem wywołanie stworz_tablice(&wsk,x)...

Generalnie alokacja takiej tablicy i jej zniszczenie to:

#include<stdio.h>
#include<stdlib.h>

float** allocate(size_t size)
{
    float **array = malloc(sizeof(float*) * size);
    for(size_t i=0; i < size; ++i)
    {
        *(array+i) = malloc(sizeof(float) * size);
    }
    return array;
}

void destroy(float **array, size_t size)
{
    for(size_t i=0; i < size; ++i)
    {
        free(*(array+i));
    }
    free(array);
}

int main()
{
    float **array = allocate(1000);

    //  Tutaj korzystaj z tablicy.

    destroy(array, 1000);
    return 0;
}

Reszta to już inwencja autora kodu.

No i zawsze można napisać sprawdzałkę czy zaalokowano każdy element:

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

float** allocate(size_t size)
{
    float **array = malloc(sizeof(float*) * size);
    for(size_t i=0; i < size; ++i)
    {
        *(array+i) = malloc(sizeof(float) * size);
    }
    return array;
}

bool is_correct(float **array, size_t size)
{
    if(!array) return false;

    for(size_t i=0; i < size; ++i)
    {
        if(!(*(array+i)))
        {
            return false;
        }
    }
    return true;
}

void destroy(float **array, size_t size)
{
    if(array)
    {
        for(size_t i=0; i < size; ++i)
        {
            if(*(array+i))
                free(*(array+i));
        }
        free(array);
    }
}

int main()
{
    float **array = allocate(1000);

    //  Tutaj korzystaj z tablicy.

    printf("%d\n", is_correct(array,1000));

    destroy(array, 1000);
    return 0;
}