double-pointer

I am having trouble understanding how to assign memory to a double pointer. I want to read an array of strings and store it. char **ptr; fp = fopen("file.txt","r"); ptr = (char**)malloc(sizeof(char*)*50); for(int i=0; i<20; i++) { ptr[i] = (char*)malloc(sizeof(char)*50); fgets(ptr[i],50,fp); } instead of this I just assign a large block of memory and store the string char **ptr; ptr = (char**)malloc(sizeof(char)*50*50); would that be wrong? And if so why is it? Your second example is wrong because each memory location conceptually would not hold a char* but rather a char . If you slightly

Simple question here: is there any way to convert from a jagged array to a double pointer? e.g. Convert a double[][] to double** This can't be done just by casting unfortunately (as it can in plain old C), unfortunately. Using a fixed statement doesn't seem to resolve the problem either. Is there any (preferably as efficient as possible) way to accomplish this in C#? I suspect the solution may not be very obvious at all, though I'm hoping for a straightforward one nonetheless. A double[][] is an array of double[], not of double* , so to get a double** , we first need a double*[] double[][]

Please consider the following code: #include <stdio.h> #include <stdlib.h> #define NUM_ARRAYS 4 #define NUM_ELEMENTS 4 #define INVALID_VAL -1 int main() { int index = INVALID_VAL; int array_index = INVALID_VAL; int **ptr = NULL; ptr = malloc(sizeof(int*)*NUM_ARRAYS); if (!ptr) { printf ("\nMemory Allocation Failure !\n\n"); exit (EXIT_FAILURE); } for (index=0; index<NUM_ARRAYS; index++) { *(ptr+index) = malloc(sizeof(int)*NUM_ELEMENTS); if (!*(ptr+index)) { printf ("\nMemory Allocation Failure !\n"); exit (EXIT_FAILURE); } } /* Fill Elements Into This 2-D Array */ for (index=0; index<NUM

What is the best way to allocate memory to a two-d array in C ,from both the perspectives : memory-management and speed ? Also, which is better to use, a two-d array (and allocate memory to it) or a double pointer ? Can someone explain in detail,what happens inside,why a method is better than the other one ? To get best performance and best readability, such arrays should always be allocated as a contiguous chunk of memory: type (*array) [X][Y] = malloc( sizeof(type[X][Y]) ); You should avoid this: // BAD METHOD, not a real array type** lookup_table = malloc( X*sizeof(type*) ); for(size_t i=0;

Suppose I have an array of pointers to char in C: char *data[5] = { "boda", "cydo", "washington", "dc", "obama" }; And I wish to sort this array using qsort: qsort(data, 5, sizeof(char *), compare_function); I am unable to come up with the compare function. For some reason this doesn't work: int compare_function(const void *name1, const void *name2) { const char *name1_ = (const char *)name1; const char *name2_ = (const char *)name2; return strcmp(name1_, name2_); } I did a lot of searching and found that I had to use ** inside of qsort: int compare_function(const void *name1, const void