change static array into dynamic with malloc and realloc?

Question

Hallo the following code read the stdin and put it into stdout, but in reverse. I used for this a static array, because I know how much characters are in the input.txt. My question is how can I change my array in a dynamic array(pointer) with using malloc and realloc? All my tries failed.

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



    int main()
{
    char ch;
    int i,counter;
    char array[50];

    counter = 0;
    i = 0;

    while((ch=getchar()) != EOF)
    {

        array[i] = ch;
        i++;
        counter++;

    }

    for(i = (counter + 1); i >= 0; i--)
    {
        printf("%c",array[i]);
    }

    printf("\n");

    return 0;
}

Answer 1

Even if you know that the input you use never has more than 50 characters, you should enforce that limit. When the program is run with arbitrary input, you will eventually access data beyond the array's end.

Anyway, here's your program core, extracted into a function:

void rev1()
{
    char array[50];     // Allocate 50 bytes on the stack
    int i = 0;
    char ch;

    while (i < 50 && (ch = getchar()) != EOF) array[i++] = ch;    
    while (i--) putchar(array[i]);
    printf("\n");

    // Do nothing - array goes out of scope
}

If you just want to use the same fixed-length buffer on the heap, the code is very similar. You should define a pointer to char instead of the array and then call malloc in order to obtain the required memory. After you are done using that memory, you must release it with free.

Here's a second version that uses memory on the heap:

void rev2()
{
    char *array;
    int i = 0;
    char ch;

    array = malloc(50 * sizeof(*array));    // Allocate on the heap
    if (array == NULL) exit(1);             // Check for failure

    while (i < 50 && (ch = getchar()) != EOF) array[i++] = ch;    
    while (i--) putchar(array[i]);
    printf("\n");

    free(array);        // Explicitly release data after use
}

Things to note:

• sizeof(*array) is sizeof(char) in this case, which is always 1 and therefore often is omitted. But p = malloc(count * sizeof(*p)) is a very useful allocation pattern for allocating an array of count elements that will still work if you change the type of the things pointed to.

• Memory allocation on the heap may fail; malloc will then return NULL. You must cater for such cases. The simple strategy is to just print an error message and abort the program. Depending on what you need the memory for, you might chose other failure strategies.

• Note how the core of the function, the loop is exactly the same as in the first version.

• You also must enforce the limit of 50 chars. The array is on the heap, but it doesn't grow.

• Free the memory after use. If you don't you "leak memory", i.e. you keep chunks of memory blocked. Here, array - the pointer variable that holds the array, not the array itself - is a local variable that goes out of scope. Forgetting to free the memory here will mean that you lose its address and can't access it again.

• The variable array points to the start of the memory. This variable must be passed to free. Don't change this variable, e.g. by incrementing it, otherwise you will lose your "key" to the memory.

A slightly more involved version re-allocates memory as needed. You can use realloc instead of malloc if your array grows. The already allocated data stays in place, even if the memory is not the same:

void rev3()
{
    char *array = NULL;     // Initially unallocated NULL array
    size_t size = 0;        // Allocated size, initially 0
    int i = 0;
    char ch;

    while ((ch = getchar()) != EOF) {
        if (i >= size) {                    // Check current bounds
            size += 50;                     // Increase memory
            array = realloc(array,          // Reallocate
                size * sizeof(*array));
            if (array == NULL) exit(1);
        }
        array[i++] = ch;    
    }

    while (i--) putchar(array[i]);
    printf("\n");

    free(array);        // Explicitly release data after use
}

Notes:

• realloc(NULL, size) behaves like malloc(size). Therefore you can implement a reallocation scheme easily by starting with a NULL pointer.

• Although the kernel keeps track of the allocated size internally, you have no means to know it, so you must keep track of this information yourself, in this case with size.

• Again, you must ensure the the allocation was successful. I've used quick-and-dirty (and silent) program termination above, but you can chose other strategies.

• In this case, the core loop is somewhat more involved. Before appending to the memory, you must check whether you should increase it. After you have populated your memory, access (within the allocated bounds) is as usual.

Answer 2

The obvious solution:

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

void readandprint(void)
{
  int c = getchar();
  if (c == EOF)
    return;
  readandprint();
  printf("%c", c);
  return;
}

int main()
{
  readandprint();
  printf("\n");
  return 0;
}

Answer 3

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

int main(void){
    int ch;//It must be int for comparison with the EOF.
    int i, counter;
    char *array = malloc(50);
    int size = 50;

    counter = 0;

    while((ch=getchar()) != EOF){
        array[counter++] = ch;
        if(counter == size){
            char *temp = realloc(array, size += 50);
            if(temp==NULL){
                free(array);
                fprintf(stderr, "realloc error!\n");
                return -1;
            }
            array = temp;
        }
    }

    while(counter){
        printf("%c", array[--counter]);
    }

    free(array);
    return 0;
}