Thread: Two Pointer Questions

Originally Posted by chris.r

1) I had an issue where [...] except some printf's to see where it was crashing (about 10 hours later) and everything worked fine. I'm afraid this bug will come up again.

Yes. You have overwritten part of the stack inside the function. Post the code.

2) Do I need to free memory when I create a string/char array like this:
char *str = "hello world";

No, try it.

Is there a limit to how much memory you can allocate?
I'd rather not post the code if I don't have to. There's quite a bit of it relating to allocating memory...

*edit*
On the other hand, I think it may be screwing up somewhere here...

Code:

struct _Table *CreateTable(int storageSize)
{
  int count=0;
  struct _Table *tbl = (struct _Table*)malloc(sizeof(struct _Table));
  tbl->StorageSize = storageSize;
  tbl->Items = (struct TableItem**)malloc(sizeof(struct TableItem*)*storageSize);
  for (count=0; count<storageSize; count++)
  {
    tbl->Items[count] = NULL;
  }
  return tbl;
}

Yes, you can only allocate as much memory as you have available virtual memory. 2 GB on Windows (x86).
And no, we can't help you if you don't post your code.

Originally Posted by chris.r

On the other hand, I think it may be screwing up somewhere here...

That code looks fine to me, altho it depends on what you think you have allocated for, eg:

Code:

  tbl->Items = (struct TableItem**)malloc(sizeof(struct TableItem*)*storageSize);
  for (count=0; count<storageSize; count++)
  {
    tbl->Items[count] = NULL;
  }

So this is an array of pointers that presumably later will point to actual, separately allocated, structs. Obviously, don't use the pointers themselves as structs.

Then there's also this container...

Code:

struct _Container *CreateContainer(char *name)
{
  struct _Container *g = (struct _Container*)malloc(sizeof(struct _Container));
  strcpy((char*)&g->Name, name);
  g->Tbl = CreateTable(10);
  return g;
}

And of course, the infamous hash table set function...

Code:

void *Set(struct _Table *table, char *key, int keyLength, void *value)
{
  void *prevValue = NULL;
  int index = Hash(key, keyLength) % table->StorageSize;
  // if there is no item in the first bucket at the index
  if (table->Items[index] == NULL)
  {
    struct TableItem *item = (struct TableItem*)malloc(sizeof(struct TableItem*));
    item->Value = value;
    item->NextItem = NULL;
    strcpy((char*)&item->Key, key);
    table->Items[index] = item;
    printf("Set item at index %d in condition 1.\n", index);
    return NULL;
  }
  struct TableItem *iter = table->Items[index];
  int found = 0;
  // if the item in the first bucket has the same key
  if (strcmp(table->Items[index]->Key, key) == 0)
  {
    found = 1;
    prevValue = table->Items[index]->Value->Value;
    table->Items[index]->Value->Value = value;
    printf("Set item at index %d in condition 2.\n", index);
  }
  // otherwise look for the item in the list at the index
  while (iter->NextItem != NULL && found == 0)
  {
    iter = iter->NextItem;
    // if we found the item in the list at the index
    if (strcmp(iter->Key, key) == 0)
    {
      found = 1;
      prevValue = iter->Value->Value;
      iter->Value->Value = value;
      printf("Set the item at %d in condition 3.\n", index);
    }
  }
  // if the item doesn't exist in the list at the index
  if (found == 0)
  {
    struct TableItem *item = (struct VertexTableItem*)malloc(sizeof(struct TableItem*));
    item->Value = value;
    item->NextItem = NULL;
    Copy((char*)&item->Key, key, keyLength);
    iter->NextItem = item;
    printf("Set the item at %d in condition 4.\n", index);
  }
  return prevValue;
}

Aaaaand don't forget the Print function. This is where the program is crashing.

Code:

void PrintTable(struct _Table *table)
{
  int index=0;
  for (index=0; index < table->StorageSize; index++)
  {
    struct TableItem *item = table->Items[index];
    if (item != NULL)
    {
      do {
        printf("%p->", item);
        item = item->NextItem;
      } while (item != NULL);
    }
    printf("NULL\n");
  }
}

Code:

    struct TableItem *item = (struct TableItem*)malloc(sizeof(struct TableItem*));

is enough to crash.
Its best to use

Code:

       struct Table *item = malloc( sizeof(*item) );

One problem with using printf is that stdout is buffered by default. That means data can be left in the buffer (and not printed out) when the crash occurs, possibly misleading you. You should always used one of these for debugging:

Code:

printf("blah blah"); fflush(stdout);
fprintf(stderr, "blah blah");

The second one works because stderr is not buffered. Supposedly puts() uses stderr but I have seen fprintf(stderr) statements made after a puts() statement get output first, so I won't recommend puts().

More seriously, it's probably about time you started to learn to use a debugger, which can make some problems of this sort much easier to solve. Here's a simple example of that using gdb:

getting a segfault using pointers

For example, in that print function:

Code:

void PrintTable(struct _Table *table)
{
  int index=0;
  for (index=0; index < table->StorageSize; index++)

If *table is NULL, seg fault here. Unrelated style point:

Code:

    if (item != NULL)
    {
      do {
        printf("%p->", item);
        item = item->NextItem;
      } while (item != NULL);
    }

is the same as the simpler:

Code:

while (item != NULL) {
         printf("%p->", item);
         item = item->NextItem;
}

The two commands you will want to make use of in gdb right now are "bt" (for backtrace) and "print" with which you could check whether table is NULL or not (if you segfault inside PrintTable, try "print table" in gdb afterward). Also you may need "up" -- if the segfault happens inside a library and the backtrace leads into your program (it will), you can't print any of the variables in the offending function until you move "up" into it.

Implementation refers to the code the compiler vendor has created. Your C standard library. Mostly code that you don't see. Internal stuff that makes all the public functions go around.

MK27 has some excellent ideas with "Use the debugger Luke".

You can add to the toolbox.

valgrind ./myprog
Which will tell you about all sorts of illegal memory usage. You can even use it to drop into the debugger when it spots a problem.


gcc prog.c -lefence
Electric Fence is a malloc debug library, which arranges memory so that you get a segfault as soon as you step off the end of any memory you allocated.
Running such a program in the debugger will show you the exact line of code trying to access past the end of its allocation.