Grow array in C without using realloc?

Question

So I'm trying to read in from stdin a byte at a time. Each iteration of the while loop I am trying to reallocate the buffer, but I don't want to use realloc. This is what I've tried:

   char tempChar = '\0';
   char *buffer;
   int bufferSize = 0;


   buffer = (char*) malloc(sizeof(char));
   while((tempChar = getc(stdin)) != EOF)
   {
      buffer[bufferSize] = tempChar;
      bufferSize++;

      char *temp = buffer;
      buffer = (char*)malloc(sizeof(char)*bufferSize);
      memcpy(buffer, temp, sizeof(temp));
      free(temp);
   }
   buffer[bufferSize] = '\0';

I get a segmentation fault. Any idea why that happens?

EDIT: Ok I fixed the two bugs like other people have said. Here is the fixed version:

  char tempChar = '\0';
  char *buffer;
  int bufferSize = 1;
  int count = 0; 
  buffer = malloc(sizeof(char));

  while((tempChar = getc(stdin)) != EOF){
    buffer[count] = tempChar;
    count++;

    if(count >= bufferSize){
      bufferSize *= 2;
      char *temp = buffer;
      buffer = malloc(sizeof(char)*bufferSize);
      memcpy(buffer, temp, count);
      free(temp); 
    }
  }

  buffer[count - 1] = '\0';

Answer 1

Your buffer is too small by one byte. This line

  buffer = (char*)malloc(sizeof(char)*bufferSize);

should read

  buffer = malloc(bufferSize + 1);

Don't cast the return from malloc() in C, and sizeof(char) is one by definition.

Also, this is wrong:

  memcpy(buffer, temp, sizeof(temp));

That copies a number of bytes equal to the size of a char *.

Answer 2

There are two reasons you would get a segmentation fault here. Before going into that, I have to mention that allocating a new buffer each time you read in an additional byte is tremendously inefficient. It is almost always preferable to allocate some reasonably sized buffer and then expand it in reasonably sized chunks.

That said, the first problem in your code is memcpy(buffer, temp, sizeof(temp)). When you do sizeof(temp), you're going to get the number of bytes for a pointer on your system. Probably 4 or 8. What you actually want here is the length of your old buffer. This is a problem initially, since your buffer starts off having a size of 1 byte. You then try to copy a total of 4 or 8 bytes (probably), not all of which are part of your buffer.

Second, when you do buffer[bufferSize] = '\0', you're actually writing the \0 to the byte after the end of your buffer. You would want to use bufferSize - 1 for this.

Answer 3

I get a segmentation fault. Any idea why that happens?

Because you're writing beyond allocated memory.

This is what realloc is for.

You don't need to call realloc to grow your buffer every time you read a new byte, instead double the size of the buffer every time it needs to grow until it hits some practical maximum and then inform your user. This is how data-structures like C++'s vector<T> work.

Answer 4

There are two errors in your code.

1) memcpy(buffer, temp, sizeof(temp)); This line is copying a constant number of bytes each time. sizeof(temp) is not the allocated size of the the array, but the size of the pointer, which is most likely 4 or 8 bytes. So for the first few iterations you are actually writing more than the allocated space, and after that just not copying enough. You want to replace sizeof(temp) with bufferSize, the same value you used to allocate the buffer.

2) At the end you have buffer[bufferSize] = '\0';. This however is writing a byte past the end of allocated buffer. buffer is bufferSize bytes which means its addressable index values are 0 - bufferSize-1. However replacing this line with buffer[bufferSize-1] will replace the last character with a zero terminator, so you'll always lose the last character of input. You instead need to allocate 1 byte more. Personally I'd replace the allocation line with:

buffer = (char*)malloc(bufferSize+1);