how to use memcpy with unique_ptr

Question

I was trying to learn smart pointer as i came across this.

{ //Example 1
    //String to be copied
    std::string strHello = "HelloWorld1";
    int size = strHello.length();

    //Creating Ptr using make_unique
    std::unique_ptr<char[]> pstrText;
    pstrText = make_unique<char[]>(size + 1); // Allocating +1 for \0

    //Copying values to the new pointer
    int r = memcpy_s(pstrText.get(), size + 1, strHello.c_str(), size);

    //Printing
    std::cout << pstrText.get() << std::endl;
}

{ //Example 2
    //String to be copied
    std::string strHello = "HelloWorld2";
    int size = strHello.length();

    //Creating Ptr using make_unique
    std::unique_ptr<char[]> pstrText;
    pstrText = make_unique<char[]>(size);

    //Copying values to the new pointer
    int r = memcpy_s(pstrText.get(), size, strHello.c_str(), size);

    //Printing
    std::cout << pstrText.get() << std::endl;
}
{//Example 3

    //String to be copied
    std::string strHello = "HelloWorld3";
    int size = strHello.length();

    //Creating Ptr using make_unique
    std::unique_ptr<char[]> pstrText;
    pstrText = make_unique<char[]>(size + 1); //Allocating + 1

    //Copying values to the new pointer
    int r = memcpy_s(pstrText.get(), size, strHello.c_str(), size);

    //Printing
    std::cout << pstrText.get() << std::endl;
}

{//Example 4

    //String to be copied
    std::string strHello = "HelloWorld4";
    int size = strHello.length();

    //Creating Ptr using make_unique
    std::unique_ptr<char[]> pstrText;
    pstrText = make_unique<char[]>(size);

    //Copying values to the new pointer
    int r = memcpy_s(pstrText.get(), size + 1, strHello.c_str(), size); 

    //Printing
    std::cout << pstrText.get() << std::endl;
}

The Output is as Follows using VS 2013 Debug(Win32):

HelloWorld1
HelloWorld2²²²²½½½½½½½½■
HelloWorld3
HelloWorld4²²²²½½½½½½½½■

1. If Example 1 is correct why does the Example 3 also give the correct output?
2. What Does the garbage values at the end signify?
3. Why didn't the compiler throw any error or exception?
4. In Example 4 Why is there no error when we had tried to copy a value at the end but was not initialized
5. How do we properly initialize a smart pointer in this case? Will anything change if it a BYTE array instead of char;

Answer 1

Two things you need to know:

First is that in C++ memcpy_s is a Microsoft VC++ CRT specific extension. It exists in C (added in the C11 standard), but even then the Microsoft implementations of the safe functions are often not following the C standard.

The second thing, and which is the cause of your problem, is that the last argument is the number of bytes to copy. Since you only specify size there, your call will not copy the string null-terminator. You need to copy size + 1 bytes:

int r = memcpy_s(pstrText.get(), size + 1, strHello.c_str(), size + 1);
//                                                               ^^^^
//                    Copy plus one, to also copy the null-terminator

Answer 2

If Example 1 is correct why does the Example 3 also give the correct output?

make_unique<char[]>(size + 1); initialises all the chars to 0. Both example 1 and 3 don't overwrite this, because they copy respectively the smaller of size + 1 and size; and the smaller of size and size. I.e. they both copy size chars

What Does the garbage values at the end signify?

That your program has undefined behaviour. std::ostream::operator<<(char *) in this case reads bytes until it sees a 0.

Why didn't the compiler throw any error or exception?

Because C++ is not safe. Rather than defining a particular behaviour (such as throwing an exception) when you access outside an array, the whole program isn't bound by the rules of C++. This is called "Undefined Behaviour".

In Example 4 Why is there no error when we had tried to copy a value at the end but was not initialized

Because C++ is not safe

How do we properly initialize a smart pointer in this case? Will anything change if it a BYTE array instead of char;

Either example 1 or example 3 is fine. However, why not just use std::string?