Are there any limitations to realloc()

Question

Here I'm trying to write a code to find the powers of 2 by manipulating a string. I know this can be done with some built in functions but I'm interested in doing this using string manipulation techniques.

The problem works fine till 2⁷⁶ and then I don't know why my program displays some unwanted characters. I don't understand why this happens exactly from the exponent 76 and before that I get the desired output.

Here is my code. Hope I can find what's going wrong with your help.

---

CODE:

Note: Here I use 4 functions

1. int len() : to find length of string.
2. void add() : to perform the operation to find power of 2.
3. void rev() : displays string in reverse order, as its the desired output.
4. int main()

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

    char *a;
    int i;

    int len()
    {
        for(i=0;a[i]!='\0';i++);
        return i;
    }

    void rev()
    {
        printf("\n");
        for(i=len();i>=0;i--)
            printf("%c",a[i]);
        printf("\n-------------------\n");
    }

    void add()
    {
        int k,v=0;
        for(k=0;k<len();k++)
        {
            v=2*(((int)a[k])-48);
            a[k]=v+48;
        }
        for(k=0;k<len();k++)
        {
            if((int)a[k]>57)
            {
                if(k<(len()-1))
                {
                    a[k+1]+=1;
                    a[k]=((((int)a[k])-48)%10)+48;
                }//in if 1
                if(k==len()-1)
                {
                    realloc(a,(len()+1)*sizeof(char));
                    a[k+1]=49;
                    a[k]=((((int)a[k])-48)%10)+48;
                }//in if 2
            }//out if
        }//for
    }//add

    int main()
    {
        int j;
        a=(char *)calloc(1,sizeof(char));
        a[0]='1';
        for(j=1;j<=81;j++)
        {
            add();
            printf(" %d :\n",j);
            rev();
        }
        scanf("%d",&i);
        return 0;
    }

---

I don't understand what's going wrong... does realloc has a limitation is assigning memory or is it my system's fault?

---

EDIT:

As @DavidSchwartz suggested I must assign the newly returning pointer starting address to a the variable

a=realloc(a,(len()+1)*sizeof(char));

and I want to how can I effectively detect and avoid over flow.

Answer 1

You ignore the return value of realloc and just continue to use the old block of memory that may or may not still be yours. Surely you meant:

        a = realloc(a,(len()+1)*sizeof(char));

Answer 2

You need to assign '\0' to your array (within the bounds you've allocated).

Consider a hypothetical array of eggs stored in an egg carton. If you tell someone there's a sequence of eggs at the start of the carton that continues on until they reach a terminal egg (something that looks different to the other eggs), what happens when they don't find the terminal egg? Mind explosion is what happens. They'll probably yell at you and accuse you of acting stupid; the behaviour is undefined.

From the computers perspective, we should keep looking for the terminal egg, past the other end of the carton, onto the floor, out the door, onto the road and splat... we're hit by a car; the behaviour is undefined, yet again.

You need to put that terminating egg into the carton. Keep in mind this means you also need to make space for that terminating egg.

---

Store the return value of realloc into a temporary variable!

As a matter of fact, realloc does have limitations, as does the rest of C: The limitations mostly affect those who guess how to use it rather than reading (the manual), as you've observed. There are two points to take away from that manual:

• It's possible that realloc might allocate a new object, with a different address, which it communicates via the return value.
• When realloc fails, it'll return NULL. It's important not to charge on overflowing the array, and to note that the old pointer hasn't been freed; if you overwrite the old pointer value with the new (null) pointer value, you won't be able to free it... You'll have leaked memory.

In fact, you should (almost) always check the return value of every standard C function. If you don't know how, find the appropriate manual and read it. If you can't read the manual without being confused about everything from top to bottom, you need a better book because you haven't yet grasped the basics.

Here is how you should (almost) always use realloc:

void *temp = realloc(array, size);
if (temp == NULL) {
    /* XXX: Handle allocation failure */
}
array = temp;

How you recover from allocation failure is your decision, but what's important is that you can recover from allocation failure (and without simultaneously leaking memory). A simple solution to fill in the blanks (the XXX comment) in the above code would be:

void *temp = realloc(array, size);
if (temp == NULL) {
    free(array); // This'll stop valgrind from complaining about leaked memory
    exit(EXIT_FAILURE);
}
array = temp;

---

Is there any particular reason you aren't using strlen? Perhaps your book hasn't taught you about that yet.

---

((((int)a[k])-48)%10)+48;

What is this? Hasn't your book taught you that you can add and subtract character constants yet? This is much more portable and legible: (a[k] - '0') % 10 + '0'

On the topic of books, clearly yours isn't working out for you. I'm confident that you'll benefit from K&Rs "The C Programming Language, 2nd edition". Do the exercises as you come across them; don't skip them.

---

One more thing: Don't cast malloc, realloc or calloc

Answer 3

realloc does not modify the pointer you pass to it. Instead, it returns a new pointer, that MIGHT be the one you passed to it, if there is enough free space in the memory.

Instead of realloc(a,(len()+1)*sizeof(char)); you should use a = realloc(a,(len()+1)*sizeof(char));.

You can learn more about realloc here: http://www.cplusplus.com/reference/cstdlib/realloc/