C++ 动态 memory 分配怪异 output

Question

I'm learning about dynamic memory allocation in C++. On running the code below, different output is printed every time.

char *const dynamic_array = new char[50];
dynamic_array[0] = '\0';
dynamic_array[0] = 'a';
cout << dynamic_array << endl;
delete[] dynamic_array;

Example output(s) of 5 runs:

• aδ
• aδ
• aⁿ
• aΓ
• aε

why is the output different on some runs?

Answer 1

This is unrelated to dynamic memory allocation but only to the legacy C string. A C string is a null terminated char array. As you failed to properly write a null character ( '\0' ) after the 'a' , using it as a C string is undefined behaviour.

Answer 2

The operator<< you are calling here:

cout << dynamic_array << endl;

Expects a pointer to the first element of a null-terminated character array. Your character array is not null-terminated, hence your code has undefined behavior.

If you want a dynamically sized string you should write:

std::string dynamic_array{"a"};
std::cout << dynamic_array;

Answer 3

This has nothing to do with dynamic memory allocation. Your code would have failed even if you had used a fixed local array without new[] :

char fixed_array[50];
fixed_array[0] = '\0';
fixed_array[0] = 'a';
cout << fixed_array << endl;

You are calling the overloaded operator<< that takes a nul-terminated char* string as input, but you are simply putting the '\0' terminator in the wrong array element.

Use this instead:

char *const dynamic_array = new char[50];
dynamic_array[0] = 'a';
dynamic_array[1] = '\0'; // <-- index 1, not 0!
cout << dynamic_array << endl;
delete[] dynamic_array;

char fixed_array[50];
fixed_array[0] = 'a';
fixed_array[1] = '\0'; // <-- index 1, not 0!
cout << fixed_array << endl;

Answer 4

In C++, variables and objects need to be declared and initialized , but depending on whether a particular variable is a local variable, a class-member variable or a global/static variable, their default initialization may be done by the compiler or not, following the rules described here: https://en.cppreference.com/w/cpp/language/default_initialization

In short it means that local variables don't get default-initialized, while static/global variables get default-initialized. What concerns to class member-variables, if there's no member-initialization syntax present in constructors (which is the case for the default-constructor), then they'll get default initialized as well.

Another thing to remember regarding this uninitialized-variable issue and other undefined behaviors in C++ is that some compilers may decide (based on some heuristics or by default) to default-initialize all variables upon their declaration to avoid run-time logic errors, which may not always be desirable (mostly due to performance reasons), but it's possible to disable those. A good starting point for reading about this is here: https://www.learncpp.com/cpp-tutorial/uninitialized-variables-and-undefined-behavior/