Return array allocated by malloc - c

Question

I have the code in main.c:
int main(void)
{
int* sudokuBoard = getBoard();
printBoard(sudokuBoard, 9);
return 1;
}
and also I have next code in another file:
int* getBoard()
{
int i;
int **Board = (int**)malloc(9 * sizeof(int*));
for (i = 0; i < 9; i++)
{
Board[i] = (int*)malloc(9 * sizeof(int));
}
int prototype[9][9] =
{
{ 0,0,1,0,0,0,0,0,9 },
{ 0,3,0,0,0,0,5,4,0 },
{ 0,0,0,0,0,0,0,0,0 },
{ 0,0,0,2,0,0,0,8,0 },
{ 2,0,0,0,6,7,0,0,0 },
{ 0,0,0,0,0,0,0,1,0 },
{ 0,9,0,0,0,0,0,0,0 },
{ 0,0,0,9,0,0,2,0,0 },
{ 0,0,0,0,4,0,0,0,0 },
};
for (i = 0; i < 9; i++)
{
Board[i] = prototype[i];
}
return &Board[0][0];
}
void printBoard(int* arr, int size)
{
int i, j;
printf("BOARD:\n");
for (i = 0; i < size; i++)
{
for (j = 0; j < size; j++)
{
printf("%d ", *(arr + i*size + j));
}
printf("\n");
}
printf("\n----------------\n");
}
Problem is when I try to print my array (there are strange numbers instead of array values). How can I create array in one function and return it to another and then print it?

Answer 1

In this loop
for (i = 0; i < 9; i++)
{
Board[i] = (int*)malloc(9 * sizeof(int));
}
there are allocated 9 extents of memory and pointers Board[i] are initialized by their addresses.
In this loop
for (i = 0; i < 9; i++)
{
Board[i] = prototype[i];
}
the pointers are reassigned. As result there are memory leaks in the function.
Moreover the pointers now point to elements of a local array and will be invalid after exiting the function.
Instead of reassigning the pointers you have to copy elements of the local array to the newly allocated arrays.
Also it is entirely unclear why you are trying to declare the function as having the return type int * instead of the correct return type int **.
Also as the sizes of the arrays are fixed you could to allocate one two-dimensional array like
int ( *Board )[9] = malloc( int[9][9] );

Answer 2

I've been trying to learn C the past couple of months, so I took a stab at taking your code and sprucing it up a bit and fixing your issue. I've left comments that explain the changes / fixes. Looks like others have already provided answers but I had fun working with your code. If anyone sees any issues in my code please let me know, would love to learn more!
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <stdint.h>
#include <inttypes.h>
#include <assert.h>
// Instead of hard coding the board size, we can let the getBoard function
// inform the caller the number of rows and columns. Also, we can use
// int8_t instead of int to ensure cross platform consistency
int8_t *getBoard(int8_t *rows, int8_t *cols) {
// Make sure the caller passed in what we need
assert(rows /* rows should not be NULL*/);
assert(cols /* cols should not be NULL*/);
*rows = 9;
*cols = 9;
int8_t prototype[9][9] = {
{ 0,0,1,0,0,0,0,0,9 },
{ 0,3,0,0,0,0,5,4,0 },
{ 0,0,0,0,0,0,0,0,0 },
{ 0,0,0,2,0,0,0,8,0 },
{ 2,0,0,0,6,7,0,0,0 },
{ 0,0,0,0,0,0,0,1,0 },
{ 0,9,0,0,0,0,0,0,0 },
{ 0,0,0,9,0,0,2,0,0 },
{ 0,0,0,0,4,0,0,0,0 },
};
int8_t *board = malloc(sizeof(prototype));
// Instead of iterating through the prototype we can memmove the contents
memmove(board, prototype, sizeof(prototype));
return board;
}
// Because we don't have the row and column count hardcoded anymore, we have to
// pass in the count to our print function.
void printBoard(int8_t *arr, int8_t rows, int8_t cols) {
// puts gives you the "\n" at the end "for free"
puts("BOARD:");
// We don't have to pre-declare our iterator variables anymore in modern C.
for (int8_t y = 0; y < rows; y++) {
for (int8_t x = 0; x < cols; x++) {
// Seperating out the pointer math makes it easier to look at
int8_t *column = arr + y * cols;
int8_t n = *(column + x);
// We can use the formatters provided by inttypes.h to again ensure consistency
printf("%" PRId8 " ", n);
}
printf("\n");
}
}
int main(int argc, const char * argv[]) {
// getBoard now gives us the counts of the board
int8_t rows = 0;
int8_t cols = 0;
int8_t* sudokuBoard = getBoard(&rows, &cols);
// We'll pass the counts into the print function
printBoard(sudokuBoard, rows, cols);
// Because getBoard malloc'd the board, we need to free it
free(sudokuBoard);
return 0;
}