Unexpected segmentation fault when using std::optional in C++20 with custom types
I tried several approaches but none seem to work... Hey everyone, I'm running into an issue that's driving me crazy. I'm experimenting with I'm working with a segmentation fault when trying to use `std::optional` with a custom type in my C++20 application..... My custom type has a non-trivial destructor and is supposed to hold some resource that requires proper cleanup. Here's a simplified version of my code: ```cpp #include <optional> #include <iostream> class MyResource { public: MyResource() { std::cout << "Resource acquired." << std::endl; } ~MyResource() { std::cout << "Resource released." << std::endl; } }; int main() { std::optional<MyResource> res; res.emplace(); // This should initialize the resource return 0; } ``` When I run this code, I get a segmentation fault, and I need to figure out why. I've confirmed that the destructor of `MyResource` is not called, which is strange because it should be automatically invoked when `std::optional` goes out of scope. I've also tried initializing `res` directly with: ```cpp std::optional<MyResource> res = MyResource(); ``` However, I still face the same scenario. Could this be related to how `std::optional` manages the lifetime of its contained object, especially since `MyResource` has a non-trivial destructor? Any insights on how to properly manage this or diagnose the question would be greatly appreciated! My development environment is macOS. My team is using C++ for this service. This is my first time working with C++ stable. Any help would be greatly appreciated! This is for a CLI tool running on Ubuntu 20.04. Hoping someone can shed some light on this.