Build an array of strings dynamically

Following my last topic I have another question related somehow...

I now have this generic menu function declared like this:

Code:

int menu_function(char **menuops, int nOps);

And I call it with something like this:

Code:

char *menuops[] = {"Option 1", "Option 2", "Option 3"};
int op = -1;

op = menu_function(menuops, sizeof(menuops) / sizeof(char *));

Now, I need to create a new and different array of strings dynamically. I'm opening some directory and get all file names inside that directory (this is already done) and I want to add all those filenames into an array of strings much like menuops so later I can call menu_function with those filenames as menu options.

If I have a variable declared like:

Code:

char *menuops[];

How can I build an array of strings into that variable?

By using exactly what I wrote in your last topic already:

Code:

size_t stringNbr = 10;
size_t maxStringLength = 128;
int i;
char **myStringArray;
myStringArray = malloc(stringNbr * sizeof(char *));
for (i = 0; i < stringNbr; i++)
{
    myStringArray[i] = malloc(maxStringLength * sizeof(char));
}

To put a value into the array of strings, you use:

Code:

strcpy(myStringArray[i], "this is a string");

And be aware that this notation:

Code:

char *menuops[];

is not legal and is only used to initialize an array if the declaration follows.

If you know the size of the array of strings, you can also write:

Code:

char myStringArray[10][300];

to define an array of 10 strings of size 300.

Sorry, didn't read the last part with full attention... So, for testing, I came up with this:

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
	char *options[] = {"Option 1", "Option 2", "Option 3"};
	char **myStringArray;
	int i, numOps;
	
	numOps = sizeof(options) / sizeof(char *);
	
	myStringArray = malloc(numOps * sizeof(char *));
	
	for (i = 0; i < numOps; i++) {
    	myStringArray[i] = malloc(strlen(options[i]) * sizeof(char));
    	strcpy(myStringArray[i], options[i]);
	}
	
	for (i = 0; i < numOps; i++) {
		printf("&#37;s\n", myStringArray[i]);
	}
	
	return 0;
}

I tested it, and it worked fine. Is it ok or the code can be improved?

P.S:
Simple question... Why sometimes I need to use sizeof(char *) instead of only sizeof(char)? Like in the following 2 lines:

Code:

numOps = sizeof(options) / sizeof(char *);	
myStringArray = malloc(numOps * sizeof(char *));

> numOps = sizeof(options) / sizeof(char *);
I'd prefer
numOps = sizeof(options) / sizeof(options[0]);
Then you're not dependent on the declaration.

> myStringArray = malloc(numOps * sizeof(char *));
Say
myStringArray = malloc(numOps * sizeof(*myStringArray ) );
Then you're not dependent on the declaration.

> myStringArray[i] = malloc(strlen(options[i]) * sizeof(char));
You forgot to add 1 to the length to allow space for the \0

The questions been answered. Boo. I had a few things to say:

You will notice a couple of things about malloc'd multidimensional arrays. First, you will have to estimate the sizes of the dimensions to get anything workable, so either go with very large, or refine what kind of data you expect them to hold and get a smaller size.

Resizing a multidimensional array is probably going to be a pain, so if you want, you could also do something like this:

Code:

char *foo = malloc ( nrows * ncols * sizeof(*foo) );
foo[nrows * this_row + idx] = /* accessing the array is a matter of some mild arithmatic, 
                                 to "skip over" chunks that don't matter */
free(foo);                    /* by avoiding a fragmented memory strategy, reallocing and freeing 
                                 the memory is very elementary */

Not to imply that this is the best choice in all situations, but generally you want to go with what you can understand, because there isn't a perfect method. The reason that people choose fragmented memory strategies is because it is easier resize in the middle of the array, I suppose. Keep in mind though, that you will probably always need to shift data around if one string needs more room, no matter what strategy you use.

Well, I'm not able to make it work on my real code... This is the code I have:

Code:

void loadCategories(void) {
	struct dirent *dpItem;
	char **catList;
	int i, j;	
	
    DIR *dp;

    if((dp = opendir("data/games/JF")) != NULL) {   	
    	while((dpItem = readdir(dp)) != NULL) {
    		if(strcmp(dpItem->d_name, ".") && strcmp(dpItem->d_name, "..")) {
    			catList[i] = malloc((strlen(dpItem->d_name) + 1) * sizeof(char));
				strcpy(catList[i++], dpItem->d_name);
    		}
    	}
    	
    	mvprintw(0,0, "%s\n", catList[0]);
    	
    	/*for (j = 0; j < i; i++) {
			printw("%s\n", catList[j]);
		}*/
		
		refresh();

    	closedir(dp);
    }
}

The problem is on the line mvprintw(0,0, "%s\n", catList[0]); which produces a segmentation fault, the code works if I comment that line (as you can see with the below for loop commented, cause I was trying to print all files found). But that won't help cause I need to print the file names found...

Just in case you don't know (which I doubt) the printw() is cause I'm using ncurses and it works in the same way as printf().

What's wrong with my code?

Well there is no obvious sign of where you allocate catList before assigning catList[ i ]

I'd also like to point out that i is being used before it holds a value (such as 0).

I didn't because I don't know how much files there is in the directory, there can be 1, 2, or more I don't know. How can I allocated memory for catList if I don't know how much?

But I don't think that's the problem, cause for now, I now there are only 2 files so I put:

Code:

catList = malloc(2 * sizeof(char *));

Before the while loop and it didn't work anyway...

Originally Posted by citizen

I'd also like to point out that i is being used before it holds a value (such as 0).

I though every int declared variable would have 0 automatically assigned if I didn't assigned a value manually... Either way, I also tried to define i as 0 before using it, and it didn't work also.

Code:

catList = malloc(2 * sizeof(char *));

This only allocates 2 pointers to strings, not the strings themselves.

And if you're interested in the files inside a directory, this FAQ entry might help you.

> I didn't because I don't know how much files there is in the directory
Well everything else isn't going to pick up the slack for you. If you don't do something, it isn't going to happen.

BTW, this exact problem is covered in the FAQ under how to read files in a directory, including how to implement an expanding array.

Edit: which KONI has just posted

In my previous post where I stated the 2 things that you guys pointed out and I said I tested them but didn't work... well, I've tested them but I never tested them both at the same time, so now it's working... I also changed my code and removed malloc() and strcpy() in favor of strdup() as suggested by a friend... I didn't know this function.

Anyway, this is my actual code now:

Code:

void loadCategories(void) {
	struct dirent *dpItem;
	char **catList;
	int i = 0, j;	
	
    DIR *dp;

    if((dp = opendir("data/games/JF")) != NULL) {
    	catList = malloc(2 * sizeof(char *));
    	 	
    	while((dpItem = readdir(dp)) != NULL) {
    		if(strcmp(dpItem->d_name, ".") && strcmp(dpItem->d_name, "..")) {
				catList[i++] = strdup(dpItem->d_name);
    		}
    	}
    	
    	for (j = 0; j < i; j++) {
			mvprintw(j,0,"%s\n", catList[j]);
		}
		
		refresh();

    	closedir(dp);
    }
}

And I have one last question as I didn't exactly understand what you said KONI. Right now, I know I have only 2 files in the directory so I've used catList = malloc(2 * sizeof(char *)); but if I have more? What should I do? Cound the files before allocating memory for catList? Or...

I also changed my code and removed malloc() and strcpy() in favor of strdup() as suggested by a friend... I didn't know this function.

strdup() is a non-standard function. I recommend that you don't use it, but you can if you want to. It's relatively easy to implement strdup() so if a compiler doesn't have it you can write a version of it. (You're already using POSIX functions like readdir() and closedir() -- might as well use strdup too. )

Use realloc(), as outlined in these FAQs (especially the first one):
http://faq.cprogramming.com/cgi-bin/...&id=1044780608
http://faq.cprogramming.com/cgi-bin/...&id=1045780608

I tried to read the FAQ but the only code that uses realloc() is that big Win32 example which is too confusing for me... I can't understand how to use realloc on my code...

1. What does malloc do ?
2. What does realloc do ?
3. When would you need use realloc ?
4. How could you use this information to dynamically expand the array depending on the number of files in a directory ?