C std::make_unique usage-CodePudding

This is the first time I am trying to use std::unique_ptr but I am getting an access violation when using std::make_unique with large size .

what is the difference in this case and is it possible to catch this type of exceptions in c ?

void SmartPointerfunction(std::unique_ptr<int>&Mem, int Size)
{

   try
   {
      /*declare smart pointer */

      //Mem = std::unique_ptr<int>(new int[Size]); // using new  (No crash)
      Mem = std::make_unique<int>(Size);   // using make_unique    (crash when Size = 10000!!)

      /*set values*/
      for (int k = 0; k < Size; k  )
      {
        Mem.get()[k] = k;
      }

   }
   catch(std::exception& e)
   {
    std::cout << "Exception :" << e.what() << std::endl;
   }
}

CodePudding user response：

When you invoke std::make_unique<int>(Size), what you actually did is allocate a memory of size sizeof(int) (commonly 4bytes), and initialize it as a int variable with the number of Size. So the size of the memory you allocated is only a single int, Mem.get()[k] will touch the address which out of boundary.

But out of bounds doesn't mean your program crash immediately. As you may know, the memory address we touch in our program is virtual memory. And let's see the layout of virtual memory addresses.

You can see the memory addresses are divided into several segments (stack, heap, bss, etc). When we request a dynamic memory, the returned address will usually located in heap segment (I use usually because sometimes allocator will use mmap thus the address will located at a memory shared area, which is located between stack and heap but not marked on the diagram).

The dynamic memory we obtained are not contiguous, but heap is a contiguous segment. from the OS's point of view, any access to the heap segment is legal. And this is what the allocator exactly doing. Allocator manages the heap, divides the heap into different blocks. These blocks, some of which are marked "used" and some of which are marked "free". When we request a dynamic memory, the allocator looks for a free block that can hold the size we need, (split it to a small new block if this free block is much larger than we need), marks it as used, and returns its address. If such a free block cannot be found, the allocator will call sbrk to increase the heap.

Even if we access address which out of range, as long as it is within the heap, the OS will regard it as a legal operation. Although it might overwrite data in some used blocks, or write data into a free block. But if the address we try to access is out of the heap, for example, an address greater than program break or an address located in the bss. The OS will regard it as a "segment fault" and crash immediately.

So your program crashing is nothing to do with the parameter of std::make_unique<int>. It just so happens that when you specify 1000, the addresses you access are out of the segment.

CodePudding user response：

std::make_unique<int>(Size);

This doesn't do what you are expecting! It creates single int and initializes it into value Size!

I'm pretty sure your plan was to do:

auto p = std::make_unique<int[]>(Size)

Note extra brackets. Also not that result type is different. It is not std::unique_ptr<int>, but std::unique_ptr<int[]> and for this type operator[] is provided!