Best content on youtube about c as far as i know

Racist

@@guitargeorge7255 🤣🤣🤣

Sorry, I don't never really worked with linker scripts. I can't help you any more than just googling the subject and looking through the results.

arrays as function parameters are treated as pointers

you can do either, I think most coders use foo(int* a) instead of foo(int[ ]) Thats what codeVault means when he says the array name decays to a pointer by using just the name as a parameter in a function call that takes a pointer

I think this is what's confusing to you: the address of a block of memory (of however many bytes) is the address of the first byte in that block Of course the next integers in that array will be further away in memory so they will have a different address from the first one (since each int takes 4 bytes in memory)

It should compile without any issues. Although you might have to call malloc after reading the sizeOfArray variable. Send me the code if it's still not compiling

Arrays are allocated automatically (regardless of type): char arr1[100]; // automatically allocated on the stack with 100 chars int arr2[100]; // automatically allocated on the stack with 100 integers Only when you use pointers and malloc it's different: char* arr3; arr3 = malloc(sizeof(char) * 100); // dynamic allocation, otherwise you usually get segmentation fault

Here's a video specifically for that question (although quite old, please disregard the poor quality of the audio): kzfaq.info/get/bejne/nbqIhcl2ubGXqmg.html

Because names is an array of strings not a pointer to string. You actually need to store those strings somewhere and char** names is just a pointer, it cannot store array elements.

p[0] is equivalent to *(p + 0) So your suggestion wouldn't work since *p[0] = 1; would be equivalent to **(p + 0) which would deallocate twice

@@CodeVault Ty so much I need to learn better pointers and arrays.

Basically yes. For most use cases there's no difference. Here are a couple more niche differences if you are curious: - A statically allocated array's size is fixed, once a number is given in those [] it can't be changed. In some compilers that number has to be a const. With a pointer, you can just use realloc to make the dynamically allocated array bigger - A statically allocated array has a maximum size limit due to limit of the stack memory (I think it's usually 1MB but could differ) - Arrays passed as parameters are actually considered pointers all the time (so even sizeof will return 8 bytes (or 4 on 32-bit)). - Multidimensional arrays are contiguous in memory, while you'd need to use two or more pairs of [] when dereferencing, the same implementation with pointers and dynamically allocated array would have to be using only one pair of [] when dereferencing since in both cases you always dereference once (regardless of the number of dimensions of that array)

They are different. I challenge you to assign one array to another array. For example assign int A[3]={5,6,7} to B[3]={0}; so that B==A ?

Ahh, my bad, that's another difference I missed. They behave like const pointers too

free(p); p = NULL; Would be the correct order. There is this video explaining the practice: code-vault.net/lesson/rh1tys8m13:1603733526917

@@CodeVault thx u )