为char数组动态分配内存

Question

having some understanding issues with the next block of code.

#include<iostream>
using namespace std;
int main() {
    char *str = "hi";
    char *p = new char[strlen(str) + 1];
    for (int i = 0; *(str + i); i++)
        *(p + i) = *(str + i);
    cout << p << endl;
    return 0;
}

Here's the result:

hi═¤¤¤¤

When i'm using debugger, i can see that my p points to an array of like 10 or 15 or some other amount of symbols (depends on compilation), so i'm getting extra symbols after "hi". BUT, when i'm using strcpy():

#include<iostream>
using namespace std;
int main() {
    char *str = "hi";
    char *p = new char[strlen(str) + 1];
    strcpy(p, str);
    cout << p << endl;
    return 0;
}

i'm getting the result:

hi

So, can someone, please, explain to me, why am i getting such a result with the first example of a program and how to rework it to get the result like in the second example. Thanks in advance.

Answer 1

You are not adding the terminating null character to p .

Add the line

*(p + i) = '\0';

after the for loop. However, to do that, you have to declare i before the for loop.

int i = 0;
for (i = 0; *(str + i); i++)
    *(p + i) = *(str + i);
*(p + i) = '\0';
cout << p << endl;

Answer 2

You forgot to terminate the string in your first exaple with a zero:

#include <cstddef>
#include <iostream>

int main()
{
    char const *str = "hi";
    std::size_t length = std::strlen(str);
    char *p = new char[length + 1];
    for (std::size_t i = 0; i < length; ++i)
        p[i] = str[i];
    str[length] = '\0';
    std::cout << p << '\n';
    delete[] p;
}

Please mind: String literals are immutable so they should be pointed to by char const* s. The correct type to hold sizes of objects in memory or indexes into them is std::size_t , not int . If you do manual memory management you have to make sure that you free the allocated memory by passing pointers obtained using new to delete and pointers from new[] to delete[] .

You shouldn't do memory management manually though. Use containers like std::string or std::vector or at least smart pointers like std::shared_ptr<> or std::unique_ptr<> .

Answer 3

The answer is in the stopping condition of the loop, ie *(str + i) :

for (int i = 0 ; *(str + i) ; i++)
    *(p + i) = *(str + i);

Note that there is no comparison operator in the expression. When an expression like this is used in a context where a logical condition is required, there is an implicit comparison to zero, ie *(str + i) means the same thing as *(str + i) != 0 .

Now it should be clear why the string remains unterminated: loop stops when it discovers null terminator, and does not copy it into the destination string.

A slightly more "cryptic" way of doing the same thing would be coupling the comparison with the assignment, the way K&R book did:

for (int i = 0 ; *(p + i) = *(str + i) ; i++)
    ;

Now the null test happens after the assignment, ensuring that the destination is null-terminated.