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
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
#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.