Yes, that is also a solution. I talk about static variables a bit more in-depth here: code-vault.net/lesson/fnrghf6w4b:1603733522024

No, not really

Yes you can. Although it's not always the best idea since the static variable makes the variable's memory location unchanged from call to call. So, if you call it twice to get two different arrays, the second call would modify the array from the first call. You'll need to be careful with that. I made a video on this topic: kzfaq.info/get/bejne/hdSXerigqrTLh6M.html

I think you ignored the n argument which should be used here: for (int i = 0; i < n; i++)

Yep. With the same exact concept. You just need to allocate the 2D arrays differently: code-vault.net/lesson/zgpd1zov1t:1603733527939

@@CodeVault I was already going crazy thinking about how to develop this solution. Thank you!

Yes it is! I think you could simply use a dynamically allocated array there with a static size. Another option is to simply pass them through the arguments (the pointer to the array and the number of elements).

The typecasting is only really advised when in C++. For C, it is automatically casted (like when assigning a float to an int or vice-versa) and casting it could hide certain bugs. For more details you can read the discussion here: stackoverflow.com/questions/20094394/why-do-we-cast-return-value-of-malloc?lq=1

@@CodeVault thanks

This should work. But there are many problems with the code. First, if you call this function multiple times. Suppose the function has an argument "a" and you modify this array in your function whenever you call it: x[0][0] = a; Well... now, if you call the function twice, you'll get one of the call modifying the other's call's result since, well, both calls return the same exact address. Here's the full code: int (*foo(int a))[2] { static int x[2][2] = { {0,1}, {0,1} }; x[0][0] = a; return x; } int main(int argc, char* argv[]) { void* arr = foo(1); printf("%d ", ((int*)arr)[0]); void* arr2 = foo(2); // this call modifies "arr" as well printf("%d ", ((int*)arr2)[0]); printf("%d ", ((int*)arr)[0]); // "arr" is modified even though we didn't do anything with it from calling foo(2) to here return 0; } Another issue is the return type. The return should actually be just a simple pointer to int since x[2][2] is actually an array of arrays but the compiler automatically converts array types to pointer types so it's easier to work with just plain pointers here

There are at least 2 ways you can do this. One is using everything exactly as in the video except for the indexing part. Instead of result[i] you'd have result[i * col_num + j] and iterating it with two for loops. col_num being the number of columns in the 2D array. And, of course, allocating enough memory with malloc(sizeof(int) * 5 * 5) (if you want a 5x5 array). Another way is to use a double pointer. Basically return a double pointer to an array of pointers that each point to an array of elements. Every pointer in that array representing a row. The latter is more complicated and I suggest using the former as you only really deal with one array, one pointer so only one free call.

@@CodeVault Thank you very much!

@@CodeVault Can you make a video showing how to return a 2d array?

Similar to strings. Just pass in double pointers and allocate memory prior to calling the function.

Best option is to just have the function take an array and its capacity, then, the user will be responsible for allocating and deallocating the memory for the array (and it could also just be statically allocated)

@@CodeVault yeah but since you don't know the size of the array in advance, what size should the array you pass be of?

In these situations you usually allocate some space in the beginning that should fit all your data (capacity =/= size). If more space is needed you can return an error code

Hmm... can you share the code here? Maybe I can help

The easy way would be to just make a struct and statically allocate it, otherwise, you'd have to dynamically allocate a char**

Sending it as a parameter is by far better, for 2 reasons: 1) The caller is responsible of deallocating the memory if needed 2) You're not limited to dynamically allocated memory for the array

@@CodeVault makes sense. Thanks. Subscribed today as soon as I saw you showing distinct ways and their pitfalls in the video!

Where would the pointer point to? Can you send me an example so I can understand what you mean please?