Why Does Using malloc() with C string Initialization Lead to Segmentation Faults?

How to Handle C String Initialization When Memory Allocated with malloc()?

In C , attempting to use the malloc() function to create a structure containing a std::string may result in segmentation faults. To understand this issue, consider the following example:

struct example {
  std::string data;
};

int main() {
  example *ex = (example *)malloc(sizeof(*ex)); // Allocating memory for the structure
  ex->data = "hello world";                   // Assigning a value to the std::string member
  std::cout << ex->data << std::endl;       // Printing the value of the std::string member
}

When executing this code, a segmentation fault occurs. This happens because simple memory allocation using malloc() does not properly initialize the std::string object within the structure.

Solution: Using new Operator

To resolve this problem, avoid using malloc() when working with classes or structures containing non-trivial constructors, such as std::string. Instead, utilize the new operator to allocate memory and construct the object correctly:

example *ex = new example; // Allocating memory and constructing the object
ex->data = "hello world";
std::cout << ex->data << std::endl;

Advanced Technique: Placement New with malloc()

Alternatively, if you insist on using malloc(), you can employ a technique called "placement new":

void *ex_raw = malloc(sizeof(example)); // Raw memory allocation
example *ex = new(ex_raw) example;      // Placement new to construct the object

However, it is highly recommended to use the new operator for simplicity and safety.

The above is the detailed content of Why Does Using malloc() with C string Initialization Lead to Segmentation Faults?. For more information, please follow other related articles on the PHP Chinese website!