I have a weird issue I've been running into while trying to write D bindings to some C++ code. I'm trying to call some C++ functions that take in a std::string but don't make a copy of it. To do this, I want to write a std::string to a buffer passed in from D so I can keep it from being destructed.

However, I'm getting a segfault when I attempt to write to the buffer I pass in despite supposedly allocating enough memory to store a std::string. Even stranger, when I allocate 488 instead of 32, the segfault goes away.

Below, I've created a minimal example that illustrates my problem:
**main.d**
```d
import core.stdc.stdlib;

extern(C++) {
void create(void*);
void display(void*);
}

void main() {
void* buf = malloc(32);// The size of a std::string on my platform is 32. //^--strangely, below segfault doesn't happen when 488 is allocated instead
        create(buf);
        display(buf);
}
```

**dothings.cpp**
```c++
#include <string>
#include <fstream>

void create(void* b) {
        std::string s = "engineer again";
        *(std::string*)(b) = s;// Segfault here
}

void display(void* b) {
        std::string s = *(std::string*)(b);
        std::ofstream file;
        file.open("imwishing");
        file << s << "\n";
        file.close();
}
```
(To build, I call "gdc main.d dothings.cpp -lstdc++ -g")

I suspect I'm making some false assumptions somewhere along the line, so please feel free to ask if you'd like to know more about what I'm doing here.

Reply via email to