[Bug libstdc++/66699] New: Incorrect order of destruction for std::tuple elements

[Bug libstdc++/66699] New: Incorrect order of destruction for std::tuple elements

[antoshkka at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

            Bug ID: 66699
           Summary: Incorrect order of destruction for std::tuple elements
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: antoshkka at gmail dot com
  Target Milestone: ---

According to C++ Standard:
"An instantiation of tuple with two arguments is similar to an instantiation of
pair with the same two arguments."

The following small example prints the order of tuple and pair elements
destruction:

#include <tuple>
#include <iostream>

struct print_num {
    int num_;
    ~print_num() {
        std::cerr << num_;
    }
};


int main() {
    {
        std::cerr << "pair : ";
        std::pair<print_num, print_num> p;
        std::get<0>(p).num_ = 0;
        std::get<1>(p).num_ = 1;
    }

    {
        std::cerr << "\ntuple: ";
        std::tuple<print_num, print_num> t;
        std::get<0>(t).num_ = 0;
        std::get<1>(t).num_ = 1;
    }
}

Program outputs
pair : 10
tuple: 01


It seems that destruction of a tuple from last to first element is more correct
than the current approach with destruction from the first element to last.

[Bug libstdc++/66699] Incorrect order of destruction for std::tuple elements

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
I don't see why you think this is an issue because:
f(temp(), temp());

The C++ does not specifies which one gets constructed first or second.

[Bug libstdc++/66699] Incorrect order of destruction for std::tuple elements

[msebor at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

Martin Sebor <msebor at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |msebor at gcc dot gnu.org

--- Comment #2 from Martin Sebor <msebor at gcc dot gnu.org> ---
Since the layout of std::pair members is fully specified, so is the order of
their initialization and destruction.  The output of the test case reflects
this order.

The order of initialization (and destruction) of std:stuple subobjects is less
clearly specified.  At least it's not immediately obvious from my reading of
the spec if any particular order is required.

The reason why the output for std::tuple with libstdc++ is the reverse of
std::pair is because the implementation, which relies on recursive inheritance,
 stores and constructs tuple elements in the reverse order: i.e., the base
class, which stores the last element, is stored and constructed first, followed
by each derived class (each of which stores the last - Nth element).

[Bug libstdc++/66699] Incorrect order of destruction for std::tuple elements

[antoshkka at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

--- Comment #3 from Antony Polukhin <antoshkka at gmail dot com> ---
(In reply to Martin Sebor from comment #2)
> Since the layout of std::pair members is fully specified, so is the order of
> their initialization and destruction.  The output of the test case reflects
> this order.
> 
> The order of initialization (and destruction) of std:stuple subobjects is
> less clearly specified.  At least it's not immediately obvious from my
> reading of the spec if any particular order is required.

I'm pointing out that according to Standard std::pair<First, Second> and
std::tuple<First, Second> must be similar. std::pair destruction order is fully
specified, so that order must be used by tuple too.

[Bug libstdc++/66699] Incorrect order of destruction for std::tuple elements

[msebor at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

--- Comment #4 from Martin Sebor <msebor at gcc dot gnu.org> ---
Being described as similar doesn't imply they are identical in every detail. 
std::pair and std::tuple are distinct classes with different requirements on
each.  If you believe the are required to behave identically in this respect
(i.e., have their subobjects defined in the same order) you need to point to
the specific wording that guarantees it.

[Bug libstdc++/66699] Incorrect order of destruction for std::tuple elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|---                         |INVALID

--- Comment #5 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to Antony Polukhin from comment #3)
> std::pair destruction order is
> fully specified, so that order must be used by tuple too.

No, the standard says no such thing.

[Bug libstdc++/66699] Incorrect order of destruction for std::tuple elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66699

--- Comment #6 from Jonathan Wakely <redi at gcc dot gnu.org> ---
And that's not even what similar means anyway.