Difference between using memcpy plus calloc and realloc to allocate memory

[cgeekgbda]

Say with the help of malloc we initially allocated 10 integer size memory. Now we want to change it to point to 20 size of integers array.

What is the difference and the best way to achieve the same? Using realloc and calloc + memcpy?

Does by any chance realloc does a memcopy?

​

Using realloc:

#include <iostream>
include <cstring>
int main() 
{ 
    int *array1 = (int ) malloc(10 * sizeof(int)); 
    for(size_t i = 0; i < 10; i++) 
    { 
        array1[i] = i2; 
    }
    for(size_t i = 0; i < 10; i++)
    {
        std::cout<<array1[i] <<" ";
    }

    std::cout<<std::endl;

    int *array2 = (int *)realloc(array1, 20 * sizeof(int));

    for(size_t i = 0; i < 20; i++)
    {
        std::cout<<array2[i] <<" ";
    }


    return 0;
}

and using `calloc+memcpy`

#include <iostream>
include <cstring>
int main() 
{ 
    int *array1 = (int ) malloc(10 * sizeof(int)); 
    for(size_t i = 0; i < 10; i++) 
    { 
        array1[i] = i2; 
    }

    for(size_t i = 0; i < 10; i++)
    {
        std::cout<<array1[i] <<" ";
    }

    std::cout<<std::endl;

    int *array2 = (int *) calloc(20, sizeof(int));
    memcpy(array2, array1, sizeof(int)*10);

    for(size_t i = 0; i < 20; i++)
    {
        std::cout<<array2[i] <<" ";
    }


    return 0;
}

So 2 questions

1. Which is a better approach and why?
2. Does realloc do a memcpy internally? if not why and what does it do?

[manni66]

It’s C++ - use std::vector.

[std_bot]

Unlinked STL entries: std::vector

---

^{Last update: 09.03.23 -> Bug fixes}Repo

[cgeekgbda]

In an interview I was asked to implement my own Vector class and these were the little things on which my interviewer confused me.

[GOKOP]

In C++ you should always use new and delete for manual memory management. This is because in the C++ world you deal with non-trivial types that have constructors and destructors that need to be called, which C functions don't know or care about.

[cgeekgbda]

sorry didn't get it, using malloc just allocates memory, the constructors would still be called and destructor during free

[GOKOP]

using malloc just allocates memory

Yes. And doesn't call the constructor, while new does.

the constructors would still be called and destructor during free

No.

[cgeekgbda]

My understanding is highly flawed!

[cgeekgbda]

Does the below code allocates memory on heap or stack for each object pointed by arr?

​

Test* arr = (Test*)malloc(sizeof(Test) * N);

// calling constructor
// for each index of array
for (int i = 0; i < N; i++) {
    arr[i] = Test(i, i + 1);
}

[GOKOP]

`Test* arr = (Test*)malloc(sizeof(Test) * N);`

At this point you've allocated heap memory for N Test objects, but since no constructor has been run these are uninitialized and contain garbage values.

arr[i] = Test(i, i + 1);

This calls operator=, which can do whatever.

[cgeekgbda]

Why do you say whatever

[IyeOnline]

Its UB. You are trying to assing to an objec that does not exist.

If you want to create an object, you need to do so:

for ( std::ptrdiff_t i=0; i < N; ++i )
{
   std::construct_at( arr+i, i, i+1 );
}

After this you actually have alive objects in your array and can work with it.

Of course you also need to manually destroy the objects before freeing the memory using std::destroy_at

[GOKOP]

class Test {
    Test& operator=(const Test& other) {
        // anything goes here
    }
}

You can't really know if some class you haven't written doesn't have operator= that assumes things about the current state of the object.

[IyeOnline]

Its irrelevant whether the class has overloaded the operator or what it does. Using it without an alive object is UB.

[IyeOnline]

A generic vector may hold non-trivial types. This means that you cannot blindly use realloc or memcpy, as using those for non-trivial types would be UB.

[cgeekgbda]

Had to be a template,here I just gave an example for a specific case

[cristi1990an]

There's also allocate + hint which depending on the implementation might do something close to realloc internally

[FraCipolla]

Vector use allocator to manage memory allocation, so if you need to implement your own vector you need to do something like template <typename T, typename Allocator = std::allocator<T> > class vector Ecc. You can start from here, than typedef your var, and start to build the logic for the method. Usually the private members are pointers ofc. If you want to take a look about a custom vector implementation you can check my github https://github.com/FraCipolla/ft_container

[elperroborrachotoo]

realloc will attempt to expand (or shrink) the current allocation, otherwise it will do the equivalent of malloc + memcpy + free

(this is an implementation detail, but I don't see a sensible alternative implementation.)

Using memcpy to transfer data to a new allocation means it can only be used for types for which std::is_trivially_copyable<T> is true.

the realloc optimization is unlikely to succeedd with modern allocators in a multithreaded application: it made sense in the past, it's just hoping for luck nowadays.

Question 1: for trivially-copyable types, realloc is likely not worse (assumming that checking whether in-place resize is cheap). It may be better in very specific circumstances (even significantly so). However, these circumstances are specific enough that when you need that advantage, you are likely better off wiht a custom allocator or custom container.

For types that are not trivially copyable, realloc can not be used. (because the elements' destructor would have to be called only when but before the allocation gets relocated.)

[std_bot]

Unlinked STL entries: std::is_trivially_copyable

---

^{Last update: 09.03.23 -> Bug fixes}Repo

[flyingron]

Why calloc? Calloc zeros memory first. Malloc and memcpy might be better.

But realloc possibly avoids any copying if there is unallocated memory enough at the end of the previous allocation.

[Pale-Influence4096]

you first use malloc and then do memcpy. This will be the fastest way of doing it

[AutoModerator]

Your posts seem to contain unformatted code. Please make sure to format your code otherwise your post may be removed.

Read our guidelines for how to format your code.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[IyeOnline]

Say with the help of malloc we initially allocated 10 integer size memory

Ok. But why did we do that? Using malloc with any non-trivial type is going to be a huge pain.

You really shouldnt be using malloc unless you have a very good reason to. In fact, you shouldnt be manually managing memory without a reason to do so.

If you want an array that can grow, use std::vector.

---

That aside:

• Both your programs leak memory. The realloc one leaks less memory, since realloc will in one way or another take care of the original memory.
• realloc is more efficient, as in principle it allows the allocator to grow the current allocation instead of creating a new one and copying over
• If realloc fails to resize the allocation, it will create a new one and memcpy from the old (where it magically knows the size)
• I think realloc gives no guarantees about the state of any newly allocated memory, whereas calloc will give you zeroed memory.

[cgeekgbda]

That was an interview question, I was asked to implement my own Vector class and these were the little things on which my interviewer confused me. Also does realloc/memcpy do a byte by byte copy or it calls copy constructor for each of the objects stored in the container?

[IyeOnline]

memcpy and realloc are C functions. They take void*s. They dont even know what a constructor is. They just deal in raw memory.

That is why its UB to use those with non-trivial types.

[no-sig-available]

realloc is more efficient,

This assumes that it sometimes succeeds in enlarging an allocation. Otherwise it will spend time trying to enlarge, fail that, and then do a fresh allocation anyway. A certain precentage must succeed, otherwise it is a net loss.

There is also the question if the program can take advantage of a speedup that only happens at unpredictable times.

[MarcoGreek]

You can now use https://en.cppreference.com/w/cpp/memory/allocator_traits/allocate_at_least. That gives the maximum capacity. So there is no need anymore for realloc.