C++20 structured bindings with std::tuple causing unexpected copying behavior
I'm relatively new to this, so bear with me. I'm working on a project and hit a roadblock. I'm sure I'm missing something obvious here, but I'm using C++20 structured bindings with a `std::tuple` to unpack values, but I'm encountering an unexpected copying behavior that seems to be impacting performance... Here's a simplified version of my code: ```cpp #include <iostream> #include <tuple> std::tuple<int, double, std::string> createTuple() { return {42, 3.14, "Hello"}; } int main() { auto [a, b, c] = createTuple(); // structured binding std::cout << a << ' ' << b << ' ' << c << '\n'; return 0; } ``` When I run this code, I notice that if I replace the `std::string` with a custom class that has a non-trivial copy constructor, performance significantly drops. For instance, this class is defined as follows: ```cpp class CustomClass { public: CustomClass() = default; CustomClass(const CustomClass&) { /* expensive copy */ } }; ``` When I modify my tuple to include `CustomClass`: ```cpp std::tuple<int, double, CustomClass> createTuple() { return {42, 3.14, CustomClass()}; } ``` The structured binding seems to be causing multiple calls to the copy constructor of `CustomClass`, which I wasn't expecting. I tried using `std::move` to see if I could optimize it, but it didn't seem to work as intended. I thought structured bindings should be efficient and allow for move semantics to take effect. Is there a way to avoid this copying behavior when using structured bindings with `std::tuple` in C++20? Am I missing something regarding the copy elision or move semantics in this context? Any insights would be appreciated! I'm working on a CLI tool that needs to handle this. My development environment is Linux. I'd be grateful for any help. I've been using C++ for about a year now. For context: I'm using C++ on Windows 11.