No, you cannot put text with embedded null characters on the clipboard. Let's look at the list of standard Windows clipboard formats. There are a few formats that hold things generally understood as text:

• CF_TEXT (1)
• CF_OEMTEXT (7)
• CF_UNICODETEXT (13)

Every single one of those has this sentence in its definition:

A null character signals the end of the data.

Now, CF_UNICODETEXT keeps its data as UTF-16LE, so it will more than likely have some null bytes, but null characters (two null bytes in a row, basically) will still end the string.

We can only speculate about why null characters aren't allowed in clipboard text, but more than likely it's just because the most commonly-used string processing functions in Windows assume a null character signals the end. The only other way to know where a string stops would be to prefix it with its length.

You can hold graphics on the clipboard even though they likely have null bytes because they get passed around in different clipboard formats (e.g. CF_BITMAP), which have to be understood differently by programs.

The only thing I can think of, if you're using the keyboard, would be holding down the ALT key, pressing the 0 key on the numeric keypad and releasing the ALT key again.

http://www.wikihow.com/Type-Symbols-Using-the-ALT-Key

The problem is that you never copy the '\0' character at the end of the string. To see why consider this:

The string passed in is a constant string sized exactly to fit the data:

char from[] = "text2copy";

It looks like this in memory:

            ----+----+----+----+----+----+----+----+----+----+----+----
   other memory |  t |  e |  x |  t |  2 |  c |  o |  p |  y | \0 | other memory
            ----+----+----+----+----+----+----+----+----+----+----+----
                   ^
                 from

Now let's imagine that you have done the loop several times already and you are at the top of the loop and from is pointing to the 'y' character in text2copy:

            ----+----+----+----+----+----+----+----+----+----+----+----
   other memory |  t |  e |  x |  t |  2 |  c |  o |  p |  y | \0 | other memory
            ----+----+----+----+----+----+----+----+----+----+----+----
                                                           ^
                                                         from

The computer executes *to++ = *from++; which copies the 'y' character to to and then increments both to and from. Now the memory looks like this:

            ----+----+----+----+----+----+----+----+----+----+----+----
   other memory |  t |  e |  x |  t |  2 |  c |  o |  p |  y | \0 | other memory
            ----+----+----+----+----+----+----+----+----+----+----+----
                                                                ^
                                                              from

The computer executes } while(*from); and realizes that *from is false because it points to the '\0' character at the end of the string so the loop ends and the '\0' character is never copied.

Now you might think this would fix it:

void copyString(char *to, char *from)
{
    do{
        *to++ = *from++;
    } while(*from);
    *to = *from; // copy the \0 character
}

And it does copy the '\0' character but there are still problems. The code even more fundamentally flawed because, as @JonathanLeffler said in the comments, for the empty string you peek at the contents of memory that is after the end of the string and because it was not allocated to you accessing it causes undefined behaviour:

            ----+----+----
   other memory | \0 | other memory
            ----+----+----
                   ^
                 from

The computer executes *to++ = *from++; which copies the '\0' character to to and then increments both to and from which makes from point to memory you don't own:

            ----+----+----
   other memory | \0 | other memory
            ----+----+----
                        ^
                      from

Now the computer executes }while(*from); and accesses memory that isn't yours. You can point from anywhere with no problem, but dereferencing from when it points to memory that isn't yours is undefined behaviour.

The example I made in the comments suggests saving the value copied into a temporary variable:

void copyString(char *to, char *from)
{
    int test;
    do{
        test = (*to++ = *from++); // save the value copied
    } while(test);
}

The reason I suggested that particular way was to show you that the problem was WHAT you were testing and not about testing the loop condition afterwards. If you save the value copied and then test that saved value later the character gets copied before it is tested (so the \0 gets copied) and you don't read from the incremented pointer (so there is no undefined behaviour)

But the example @JonathanLeffler had in his comments is shorter, easier to understand, and more idiomatic. It exact does the same thing without declaring a named temporary variable:

void copyString(char *to, char *from)
{
    while ((*to++ = *from++) != '\0')
       ;
}

The code first copies the character and then tests the value that was copied (so the '\0' will be copied) but the incremented pointer is never dereferenced (so there is no undefined behaviour).

You could also one-shot it with

std::transform(
  str.begin(), str.end(), resp, [](char c) { return c == '\0' ? ' ' : c; }
);

Of course as @Mats has mentioned your string doesn't have any null chars, strings can also be initialized as follows though:

char const cstr[] = "Hello World.\0 How are you?";
std::string str(cstr, sizeof cstr);

C++14 has a std::string literal operator

std::string str = "Hello World.\0 How are you?"s;