Thread: Problems Returning A char**

Code:

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

FILE *in;
char **readFile();

void main()
{
	in = fopen("sentences.in", "rt");
	char **warr = readFile(in);
	printf("%s\n", warr[0]);
}

char **readFile(FILE *in)
{
	char *word, **warr;
	int toGen = 0;
	word = (char*)malloc(25 * sizeof(char));
	warr = (char**)malloc(25 * sizeof(char*));
	fscanf(in, "%d", &toGen);
	for(int i = 0; i < 28; ++i)
	{
		fscanf(in, "%s", word);
		if(i >= 28)
		{
			printf("Only %d words can be used in your input file.", 20);
		}
		warr[i] = calloc(strlen(word) + 1, sizeof(char));
		strcpy(warr[i], word);
		printf("warr[%d]: [%s] Length Of Word: %d\n", i, warr[i], strlen(word));
	}
	return warr;
}

Having problems with returning warr back into main from readFile.
Prints perfect in readFile

Code:

printf("warr[%d]: [%s] Length Of Word: %d\n", i, warr[i], strlen(word));

Won't print in main

Code:

printf("%s\n", warr[0]);

Anyone know what I'm doing wrong?

The warr in main and the warr in the function are two different variables. Returning the address of a local variable is never a good idea.

You need to allocate memory for warr in main, and pass is as a parameter into your function, like I told you in your last thread.

Ah ok I didn't understand what you meant last time... that fixed it"

Code:

void main()
{
	in = fopen("sentences.in", "rt");
	char **warr = (char**)malloc(50 * sizeof(char*));
	warr = readFile(in, warr);
	printf("%s\n", warr[0]);
}

char **readFile(FILE *in, char **warr)
{

also, main should be declared as

Code:

int main(void)

and it should

Code:

return 0;

At the end.

I'm pretty sure I have had trouble doing this before, where declaring and mallocing something in a function and then returning that local variable, specifically an array, led to garbage results.

That said, I have not tested this myself, so I defer to your greater experience, however, I think that the safest route is to declare warr outside the function and pass it in. You can malloc it in the function just fine, as long as you return the pointer, but declare it outside to be safe:

Code:

int main()  //!! fixed
{
    in = fopen("sentences.in", "rt");
    char **warr = readFile(in, warr);
    printf("%s\n", warr[0]);
    return 0;     //!! fixed
}

char **readFile(FILE *in, char **warr)
{
    char *word;
    int toGen = 0;
    word = malloc(25 * sizeof(char));
    warr = malloc(28 * sizeof(char*));  //!! FIXED !!!!!!
    fscanf(in, "%d", &toGen);
    for(int i = 0; i < 28; ++i)
    {
        fscanf(in, "%s", word);
/*        if(i >= 28)
        {
            printf("Only %d words can be used in your input file.", 20);
        }*/
        warr[i] = calloc(strlen(word) + 1, sizeof(char));
        strcpy(warr[i], word);
        printf("warr[%d]: [%s] Length Of Word: %d\n", i, warr[i], strlen(word));
    }
    return warr;
}

it is entirely possible that this makes no difference at all, but my gut feeling here is that this is the safer route.

And incidentally, warr needs to be free'd, and so does word.

Well, the best way to do it would be to get rid of word completley and just use warr in there, which can be freed in main afterwards.

This is how that code could (sort of) potentially work, even though I think after looking at this that it is fundamentally the wrong way of doing it. Song names can not have spaces in them, are truncated to LENGTH, and limited to LINES. Ugh. I would prefer to read it through fgets() and malloc to the file size and then just split out the variable-length strings on '\n' as needed.

Nevertheless, this has one feature I like. The function is almost ad hoc polymorphic. Call it with 0 to free the memory before using it on each successive file.

Limitations: To add to the above complaints, it is not reentrant and can only handle one open file at a time.

Please excuse all the token pasting. I got glue on my fingers.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#define WIDTH 10
#define LINES 3
#define FB(arg) #arg
#define FMT(arg) "%"FB(arg)"s"
#define MFMT(arg) "warr[%2d]: [%-"FB(arg)"s] length %d\n"
char **readFile (char *name);
/* main */
int main (int argc, char **argv) {
    int i = 0;
    char **hlist = readFile ("wordlist.in");
    if (hlist) {
        while (hlist[i]) {
            printf ("%s\n",hlist[i++]);
        }
        /* free memory */
        readFile (0);
    } else {
        return 42;
    } return 0;
}
/* read file */
char **readFile (char *name) {
    static char **warr;
    int i;
    FILE *in;
    if (name) {
        if ((in = fopen (name, "r"))) {
            warr=malloc ((LINES+1) * sizeof warr);
            for (i=LINES;i--;) {
                warr[i]=malloc (WIDTH+1);
                if (!warr[i]) {
                    perror ("malloc");
                    exit (1);
            }   } for (i=0;i<LINES&&fscanf (in, FMT(WIDTH), warr[i])!=EOF;i++) {
                printf (MFMT(WIDTH), i, warr[i], (int)strlen(warr[i]));
            } warr[i]=0;fclose(in);
            return warr;
        } else {
            perror ("fopen");
    }   } else {
        for (i=LINES;i--;) {
            free (warr[i]);
        } free (warr);
        printf ("memory freed!\n");
    } return NULL;
}

generated from pseudocode with Anchor | freshmeat.net