👀 Views: 54 💬 Answers: 1 📅 Created: 2025-06-07

gcc c++17 stdoptional C++

This might be a silly question, but I'm encountering unexpected behavior when using `std::optional` in C++17 with GCC 11.2 on an x86_64 Linux system. I expected copy elision to occur when returning an `std::optional` from a function, but I'm seeing unnecessary copy operations in the generated assembly, which is affecting performance. Here’s a simplified version of my code: ```cpp #include <iostream> #include <optional> std::optional<int> getValue(bool flag) { if (flag) { return 42; } return std::nullopt; } int main() { auto result = getValue(true); if (result) { std::cout << "Value: " << *result << \"\n\"; } return 0; } ``` When I compile this code with `g++ -O3 -std=c++17 -S -o output.s myfile.cpp`, I noticed that the assembly output still contains a copy from the temporary `std::optional<int>` return value before it is assigned to `result`. I checked the optimization levels and tried using `-fno-elide-constructors`, but that only caused more copies to appear, which wasn't helpful. I thought that with C++17's guaranteed copy elision, this would be optimized away. However, the assembly shows a clear copy constructor call. ```asm ; Assembly output snippet mov QWORD PTR [rbp-24], rax ; Copy temporary optional to stack ``` This copy operation shouldn't be happening as I understand it. I've also verified using `-Wreturn-type` that there are no issues with types or uninitialized values. Are there specific flags or settings I might be missing that could enable the compiler to optimize this properly? Or is this behavior a known limitation in GCC with certain patterns of `std::optional` usage? Any insights or suggestions would be greatly appreciated! I'm working on a web app that needs to handle this. Could someone point me to the right documentation? My team is using C++ for this CLI tool. Any advice would be much appreciated.