How do I perform basic memory management

Hi,

Having been programming in the sheltered word of .NET for a while, I appear to have forgotten how to perform the most basic of tasks in C and desperately require help.

I want to store a list of words in memory that I can access quickly. Because all of the words will be of different lengths, I thought that I would store all of the words on one heap (the "word" heap) and then store a pointer to each word in the "word" heap in the "dictionary" heap.

My logic was that the "dictionary" heap would store 32 bit memory addresses that I could then 'dereference' to retrieve the corresponding word on the "word" heap. Because all the values on dictionary heap would be the same size, it should be very easy to step through (rather than dealing wih strings of different lengths).

However, I have been plagued by problems. The program reads the words from a file. Small files were OK, but I noticed that over a certin size strange and/or fatal errors began occurring. Therefore, I have stripped the file IO from the program completely and put the code that would usually execute for each word in the file in a FOR loop so that I can check at which point in the loop things go awry.

When the upper bound of the loop is set to a value over 279, the "word heap" address returned from the dictionary heap is incorrect and when the loop upper bound is set to a value over 15895 the program crashes.

I think that I am doing something fundamentally wrong and would appreciate any help.

I have tidied the code up as best I can but please forgive the state of it as it is most definately a "work in progress".

Thanks in advance,

Simon
(code attached)

#include <windows.h>
#include <stdio.h>

//Heap related vatriables :
//-------------------------
HANDLE wordHeap; //Stores words/strings
HANDLE dictionaryHeap; //Stores pointers to the word heap
char ** dictionary; //Block allocated from dictionary heap
char ** words;//Bloack allocated from word heap

//My test word
char * WORD_TO_STORE = "Whywontthiswork";

//Function
char * storeWord (char *);

int main() {

//VARIABLES USED TO OUTPUT WORDS
char ** dicPtr; //Pointer to the address on the "dictionary" heap
char ** wordPtr; // Pointer to the address on the "word" heap
////////////////////////////////

// VARIABLES USED TO STORE WORDS
long i; // Loop counter
int firstBlock; // Pointer to first block of memory allocated on "dictionary" heap
char ** dictionaryWalker; // Used to traverse "dictionary" heap

//ALLOCATE MEMORY
dictionaryHeap = HeapCreate(0,0,0);
wordHeap = HeapCreate (0,0,0);
dictionaryWalker = malloc(sizeof(char*));

// Set flag to rmember to store "first block"
firstBlock = 1;

printf ("Storing words.......\n\n");

//If the loop upper bound is > 279 then the "word ptr" will return an incorrect (odd) address
//If the loop upper bound is > 15895 then we crash :-(
for (i=0; i < 279; i++) {


dictionary = HeapAlloc(dictionaryHeap,0,sizeof(char*));
if (firstBlock == 1) {

memcpy(dictionaryWalker,&dictionary,sizeof(char*));
firstBlock =0;
}

memcpy(dictionary,storeWord(WORD_TO_STORE),sizeof(char *));

}

//Output last word pointer
printf ("\tLast Word ptr : %x\n", *dictionary);

printf ("\n\nRetrieving words.......\n\n");
//This loop should output every address on the "word" heap
while (*dictionaryWalker <= dictionary) {


dicPtr = (char**)dictionaryWalker;
wordPtr = malloc(sizeof(char*));

//THIS IS THE OFFENDING LINE :
memcpy(wordPtr,*dicPtr,sizeof(char*));

*dictionaryWalker += 16; //Minimum heap allocation unit

// If this is the last pointer then dump the word pointer
if (*dictionaryWalker > dictionary) {
printf ("\tLast Word ptr : %x\n",*wordPtr);
}

free(wordPtr);// Cleanup
}

return 0;
}


// Stores a word in the "word" heap and returns a pointer to that
// word
char * storeWord (char * word) {

words = HeapAlloc(wordHeap,0,strlen(word) + 1);
memcpy(words,word,strlen(word) +1);
return &words;
}