memory leak under GCC (but not Clang) when throwing in the middle of a C++14 initializer list for std::list<shared_ptr>

Question

Consider the following program:

#include <stdexcept>
#include <stdio.h>
#include <memory>
#include <list>
class Foo {
public:
    Foo(){
        if (s_ct==0) {throw std::bad_alloc();}
        --s_ct;
        fprintf(stderr, "ctor %p\n", this);
    }
    ~Foo(){
        fprintf(stderr, "dtor %p\n", this);
    }
private:
    static int s_ct;
};

int Foo::s_ct = 2;

int main(){
    try {
        std::list<std::shared_ptr<Foo>> l = {
            std::make_shared<Foo>(),
            std::make_shared<Foo>(),
            std::make_shared<Foo>()
        };
    } catch (std::bad_alloc&) {
        fprintf(stderr, "caught exception.\n");
    }
    fprintf(stderr, "done.\n");
    return 0;
}

Compiled like this:

[little:~] $ g++ --version
g++ (Ubuntu 5.4.0-6ubuntu1~16.04.2) 5.4.0 20160609
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR     PURPOSE.

[little:~] $ g++ --std=c++14 -o list_init list_init.cc
[little:~] $ 

The output is:

[little:~] $ ./list_init 
ctor 0x1294c30
ctor 0x1294c50
caught exception.
done.
[little:~] $ 

Notice that the destructors are not called. Valgrind correctly complains of the leak as well.

This seems to violate one of the key purposes of std::make_shared -- namely, that if another expression in the statement throws, the shared object gets properly destroyed because it is wrapped by a fully constructed shared pointer object.

Clang does what I would like here:

[little:~] $ clang++ --version
clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
[little:~] $ clang++ --std=c++14 -o foo list_init.cc
[little:~] $ ./foo
ctor 0x1dfec30
ctor 0x1dfec50
dtor 0x1dfec50
dtor 0x1dfec30
caught exception.
done.
[little:~] $ 

So is this a GCC bug, or do I need to fix my program?

Answer 1

Turning my comment into an answer so you can mark the question as answered.

This looks to be a gcc bug

Bug 66139 - destructor not called for members of partially constructed anonymous struct/array

Note in particular the last two test cases which use std::initializer_list to illustrate the problem.