Thread: realloc() problems

Okay, I'm trying to learn how to dynamically allocate memory, and I figure the best way to do it is to try to make something with it and learn as I go.

Code:

//main.c

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

int main(void)
{
	//...
	Room forest;
	//...
	initializeVerbs(&forest, 4, "get", "drop", "take", "use");
	//...
	return 0;
}

//parser.h --------------

#ifndef PARSER_H
#define PARSER_H

typedef struct Room
{
	short unsigned nVerbs;
	short unsigned nNouns;
	char *verbs;
	char *nouns;
} Room;

void initializeVerbs(struct Room *room, unsigned int nargs, const char *arg, ...);
//...

#endif

//parser.c ---------------

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include "parser.h"

void initializeVerbs(Room *room, unsigned int nArgs, const char *arg, ...)
{
	unsigned count;
	unsigned length = 0;
	va_list ap;
	char *stuff;
	printf("Step 1.\n");
	room->nVerbs = nArgs;
	printf("Step 2.\n");
	va_start(ap, arg);
	for(count = 1; count < nArgs; count++)
	{
		length += (strlen(arg) + 1);
		printf("sizeof(verbs): %i\n", sizeof(room->verbs));
		printf("length = %i\n", length);
		realloc(room->verbs, length); /*problem*/
		room->verbs[length] = arg; /*Causes problems.*/
		arg = va_arg(ap, const char *);
	}
	printf("Length: %i\n", length);
}

Okay, what I'm trying to do is this. I want the user to be able to initialize as many verbs as he wants, and I want them all in one char pointer. nVerbs holds how many there are, so I can search through them later by going past the null terminator.

However...I have no idea what I'm doing. Please help.

Thanks

Still having troubles. I changed

Code:

char *verbs;

to

Code:

char **verbs;

and made these changes...

Code:

void initializeVerbs(Room *room, unsigned int nArgs, const char *arg, ...)
{
	unsigned short size = 0;
	char *temp;
	va_list ap;
	printf("Step 1.\n");
	room->nVerbs = nArgs;
	printf("Step 2.\n");
	va_start(ap, arg);
	for( ; nArgs; --nArgs)
	{
		printf("sizeof(verbs): %i\n", sizeof(room->verbs));
		temp = (char *)malloc(sizeof(arg));
		realloc(room->verbs, ++size);
		strcpy(room->verbs[size], temp);
		arg = va_arg(ap, const char *);
	}
}

Still getting evil errors. Thanks for all the help so far, though.

Code:

temp = (char *)malloc(sizeof(arg));

malloc() will only allocate 4 bytes on 32-bit compilers because sizeof(any pointer) is always 4. sizeof operator does not return the length of the string.

Yes! I got it to work. Thanks, both of you.

Here's my current code:

Code:

void initializeVerbs(Room *room, unsigned int nArgs, const char *arg, ...)
{
	unsigned short size = 0;
	char *temp;
	va_list ap;
	room->nVerbs = nArgs;
	va_start(ap, arg);
	room->verbs = (char **)malloc(sizeof(char *) * nArgs);
	for( ; nArgs; --nArgs, ++size)
	{
		temp = (char *)malloc(strlen(arg) + 1);
		strcpy(temp, arg);
		room->verbs[size] = temp;
		arg = va_arg(ap, const char *);
	}
}

Now, this works. But I'm curious if there's a better way. Is it more efficient to implement the additional NULL pointer at the end in exchange for the nVerbs counter?

Thanks so much!

But now I am lost ONCE AGAIN! (Woot.)

I know I have to free() these allocations once I'm done with them. If I'm going to have an indefinite number of structures, each with its own set of verbs, how can I accomplish this?

Yes, but...we're going to have somewhere in the neighborhood of 200 rooms. I don't want us to have to call a "myRoomFree()" function 200 times before the end of the program. It's annoying and widely open to bugs due to minor changes.

Basically, I'm looking for a C version of a desconstructor.

another way is to allocate just one huge block of memory

Code:

char* memory = malloc( MaxNumRooms * MaxNumVerbs * MaxVerbLength );

Now, write your own allocation function that divvies up memory from that memory pool. When you want to free it, you only have one object to free. There will probably be some wasted memory here, but that's the down side of simplicity.

Those Max values are exactly what I'm trying to avoid. See, if I just wanted to take the easy way out, I'd just have pointer arrays with, say, 100 characters each to hold the verbs. That's easy, and there's no memory deallocation to take care of.

But I don't WANT to do that. I'd really like to learn how to manage my memory. That's all this is to me: a learning experience. If I take the easy way out, I've gained nothing.

So, thanks, but I'd really like to learn how to free() effectively.

C language doesn't have a very efficient memory manager -- that's one reason c++ invented destructors. If you are looking for a substitute for c++ descructors, then you will be looking for a very very long time, because there isn't one.

Originally Posted by DMH

Yes, but...we're going to have somewhere in the neighborhood of 200 rooms. I don't want us to have to call a "myRoomFree()" function 200 times before the end of the program. It's annoying and widely open to bugs due to minor changes.

Basically, I'm looking for a C version of a desconstructor.

You could always just not free the memory...... :P At the end of the program it will all get unallocated anyways (depending on your OS that is....)

Is that universal enough that I can count on it?