realloc()

Hi again,

I know that this is mainly for C, however it asks me to use it in my C++ book to deal with any overflow going into an array.

My idea was to have an initial array of size 10 and when reading into it, if the array went over 10 (kept track of by a counter), then I would use re-alloc to change the size of the array. As usual it hasn't worked out quite like I expected :)

Code:

---

istream& read(istream& is, int* s)
{
        int temp;
        int i = 0;
        while(is>>temp && temp != '!'){
                s[i] = temp;
                ++i;
                if(i > 10) {
                        realloc(s, i*4);
        }
        }

        return is;
       
}

---

Now, as I understand, the 2nd argument for realloc is the size in bytes, so I have set this as i*4 bytes, so if the array goes to size 11 then it should be 11 bytes. However, when I print the array, it is just random trash!

Any advice please?

Thanks.

Btw, int* s is a pointer to an int array in free store, if it makes any difference.

You need to pass the pointer by reference, and then you need to make use of the return value of realloc. Furthemore, you need to decide how to handle the case if realloc returns a null pointer (e.g., you might free the existing dynamic array and then... throw an exception?)

But there's more: you also need to keep track of both the size (as in number of elements in use) and capacity (as in number of elements allocated) of the dynamic array. After all, after you expand the dynamic array, it is still possible that the resulting capacity is not enough.

I suggest that you just use a std::vector<int> instead. You would be able to use a std::vector of objects of a non-POD class type, but it would be incorrect to use realloc for a dynamic array of objects of a non-POD class type.

Thanks. I thought by me incrementing i within the loop and then using realloc each loop through once i > 10, would increase it as each new element is added? Is that not the case?

Thanks,

realloc ALSO returns a pointer (to the possibly moved memory)

So you need to pass your original pointer by reference, AND make sure it is updated.

You also need to watch out for realloc returning NULL. In this case, the old memory is NOT freed. It is a common error to trash your only pointer with something like
p = realloc( p, size );


> so I have set this as i*4 bytes,
* sizeof(int)
would be clearer, and more portable.

Quote:

---

Originally Posted by darren78

I thought by me incrementing i within the loop and then using realloc each loop through once i > 10, would increase it as each new element is added? Is that not the case?

---

Ah. Yes, except that it should be:

Code:

---

int* t = realloc(s, i * sizeof(*t));
if (t) {
    s = t;
} else {
    // handle the fact that realloc could not realloc.
}

---

But if you do it this way, then after the first ten elements, you will be calling realloc for every subsequent element, which is terribly inefficient. Rather, you should increase the capacity by some factor when necessary, and thus amortise the cost of expanding the dynamic array.

Quote:

---

Originally Posted by laserlight

Code:

---

int* t = realloc(s, i * sizeof(*t));

}

---

---

When I try this, I get error c2440: cannot convert from void* to int*. I'm unsure why as none of them are declared void?

My mistake, or rather, your book's mistake that became my mistake. You need to cast to int* as the return value of realloc is void*, but void* is not implicitly convertible to int* in C++.

What book is this again?

Quote:

---

Originally Posted by laserlight

My mistake, or rather, your book's mistake that became my mistake. You need to cast to int* as the return value of realloc is void*, but void* is not implicitly convertible to int* in C++.

What book is this again?

---

Thanks. It's PPP by Stroustrup.

Quote:

---

Originally Posted by darren78

It's PPP by Stroustrup.

---

Amazing, as that goes against what he wrote in Learning Standard C++ as a New Language. I presume that this is a relatively late chapter, and you merely have not sufficiently practiced the earlier material? After all, by now you should know at least in principle how push_back of std::vector works, and so you should have reached for the size+capacity solution when trying to imitate it with realloc, as it would have been explained to you how push_back can run in amortised constant time.

Quote:

---

Originally Posted by laserlight

Amazing, as that goes against what he wrote in Learning Standard C++ as a New Language. I presume that this is a relatively late chapter, and you merely have not sufficiently practiced the earlier material? After all, by now you should know at least in principle how push_back of std::vector works, and so you should have reached for the size+capacity solution when trying to imitate it with realloc, as it would have been explained to you how push_back can run in amortised constant time.

---

Yeah, I know all about how vectors work, etc and size(), etc. I think for this section, and just in this one particular exercise, he asks us to create an array on the free store and to look up realloc as a way of dealing with any overflow from what the array was initialised to. it's not something that he is particularly teaching, I don't think.

Sorry, just re-reading your previous comment. I know how to use push_back but nothing in the book has been said yet on how exactly it works. I think the next few chapters that I am yet to read go over the creation of vectors.

Quote:

---

Originally Posted by darren78

Yeah, I know all about how vectors work, etc and size(), etc. I think for this section, and just in this one particular exercise, he asks us to create an array on the free store and to look up realloc as a way of dealing with any overflow from what the array was initialised to. it's not something that he is particularly teaching, I don't think.

---

Still it's amazing that he isn't using the facilities of his own language: new[] and delete[]. You can definitely write this function in terms of that and it would be substantially easier.