The question might appear incredibly simple but how do I declare a function in c that returns a double array. For instance
char myfunction(int a, int b)
{
...
char d[a][b];
...
return d;
}
But it doesn't seem to work (if the response could avoid the 'malloc' and 'free' usage, it could be more helpful to understand those kinds of basic usage)
Best, Newben
But it doesn't seem to work (if the response could avoid the 'malloc' and 'free' usage, it could be more helpful to understand those kinds of basic usage)
Well, you can't because you are proposing to return a pointer which is invalid once the function returns. The array is declared with automatic storage duration and, as a result, all references to it are invalid once the function returns. You cannot return arrays from functions in C.
If you need to populate data in the function then either return a char** that you malloc from within the function.
char **foo(int cols, int rows) {
char **ret = malloc(rows * sizeof(char*));
if(!ret)
return ret;
for(int i = 0; i < rows; ++i) {
ret[i] = malloc(cols);
/* error checking again for malloc,
call free() on pointers 0...i upon failure.
memset to 0 if you like */
}
return ret;
}
You can now use multi-dimensional array syntax on the return value.
char **p = foo(10, 20);
// p[j] returns a pointer to char, p[j][k] returns a char
char elem = p[j][k];
In this situation you can't avoid malloc and free. The problem is by declaring
char d[a][b];
You're allocating an array directly on the stack, so when your function returns the array is de-allocated and the address you returned is invalid.
Using something more like:
char** myfunction(int a, int b) {
char** d = (char**)malloc(a * sizeof(char*));
if (d ! = NULL) {
for (int i = 0; i < b; i++) {
d[i] = (char*)malloc(sizeof(char));
if (d[i] == NULL) {
for (int j = 0; j < i; j++) {
free(d[j]);
}
free(d);
d = NULL;
break;
}
}
}
return d;
}
void* can be implicitly and safely converted to any type of pointer in C.
stdlib.h, so malloc is assumed to be an extern function which returns int. Without the cast a warning will be thrown, with it nothing will. It is also redundant, not idiomatic, and does nothing but add clutter to C code.In C, if you want a function to create an array and return it to its caller, you must use malloc or another function that dynamically allocates memory (such as calloc or realloc). You can then return a pointer to the array.
char **make2dArray(int x, int y) {
int i;
char **array = calloc(x, sizeof(char*));
for(i = 0; i < x; i++) {
array[i] = calloc(y, sizeof(char));
}
return array;
}
If, on the other hand, you simply need to modify the value of an array, it is best to take the array as a parameter and modify it in place.
void modify2dArray(int x, int y, char **array) {
int i, j;
for(i = 0; i < x; i++) {
for(j = 0; j < y; j++) {
array[i][j] = 1;
}
}
}
And remember, once you're done with dynamically allocated memory, call free for each allocation:
void dealloc2dArray(int x, int y, char **array) {
int i;
for(i = 0; i < x; i++) {
free(array[i]);
}
free(array);
}
Here's what using these functions might look like:
char **array = NULL;
array = make2dArray(5,6);
modify2dArray(5,6,array);
dealloc2dArray(5,6);
array = NULL;
Please note that the dynamic allocation functions (malloc, calloc, and realloc) can fail, returning NULL. I didn't check for NULL after each allocation here to save on space, but it's generally good practice to ensure that your allocations succeed.
In C since C99 the correct way to allocate a real 2D array, and not an emulation as in the other answers, is to do something like the following:
char (*array)[cols] = malloc(cols * rows);
If you have to do that in a function, the easiest way for me seems to be
void * foo(int cols, int rows) {
char (*ret)[cols] = malloc(rows * cols);
// do something with it
return ret;
}
When calling it you'd have to be a bit more careful to give the dimension to the new variable
char (*array)[cols] = foo(cols, rows);
All of this has the advantage that one simple malloc is used to allocate a contiguous object, and that you only need to do one call to free at the end to deallocate the memory.
don the stack and returning that value, which is undefined behavior. See this classic post for more details. Instead, you need tomallocthe memory in your function and thenfreeit in the caller. If you want to temporarily work around the problem of dynamic memory allocation while you're learning, makeda global or file-scope variable - you can still return it.freeand I'm not 100% sure if it's totally correct apart from that issue.