👀 Views: 50 💬 Answers: 1 📅 Created: 2025-07-18

c++17 stdoptional sharedptr C++

I'm a bit lost with I've been banging my head against this for hours. I am working with an unexpected scenario with `std::optional` in C++17 that wraps a class containing a `std::shared_ptr`. When I try to copy the containing class, I expect the `std::optional` to handle the shared pointer correctly, but I am seeing some unexpected behavior. Here's a simplified version of my code: ```cpp #include <iostream> #include <memory> #include <optional> class MyClass { public: MyClass(int value) : data(std::make_shared<int>(value)) {} std::shared_ptr<int> data; }; class Container { public: std::optional<MyClass> item; }; int main() { Container container; container.item.emplace(5); Container copy = container; // Copying the container *container.item->data = 10; // Modify original std::cout << "Original: " << *container.item->data << '\n'; std::cout << "Copy: " << *copy.item->data << '\n'; return 0; } ``` When I run this code, both the original and the copy print `10`, which indicates that they are sharing the same `std::shared_ptr`. I expected the `std::optional` to create a deep copy of `MyClass`. I have tried using `std::make_shared` in different contexts, but the behavior remains the same. Is there any way to ensure that the copy of `Container` will have its own instance of `data`, or is this the expected behavior? I would appreciate any insights or solutions to this question. My development environment is Ubuntu. Has anyone else encountered this? The stack includes C++ and several other technologies.