gcc 4.8.2在此默认默认构造函数中调用复制构造函数时是否正确？

Question

Here's a simple, self-contained, non-compilable-on-gcc-4.8.2 example of what I'm trying to accomplish:

#include <atomic>

template <typename T>
class ValueParameter
{
public:
    ValueParameter() = default;

    ValueParameter(T initialValue) :
        _val(initialValue)
    {
    }

private:
    std::atomic<T> _val{T()};
};

ValueParameter<int> x;

I've compiled this successfully on several other gcc versions, including 5.3, but gcc 4.8.2 fails with the following error:

/tmp/gcc-explorer-compiler11658-82-1cqz6ui/example.cpp: In constructor 'ValueParameter<T>::ValueParameter() [with T = int]':
7 : error: use of deleted function 'std::atomic<int>::atomic(const std::atomic<int>&)'
ValueParameter() = default;
^
In file included from /tmp/gcc-explorer-compiler11658-82-1cqz6ui/example.cpp:1:0:

You can see the results online here .

I understand that std::atomic<T> is non-copyable, but it doesn't make any sense to me why the compiler would be trying to use the copy constructor within the default constructor. I did discover that changing the line:

    std::atomic<T> _val{T()};

to

    std::atomic<T> _val;

makes the file compile successfully. The uniform initialization was a relic from a previous version of the class that didn't have the constructor taking an initial value.

Should this be an error? Furthermore, what behavior should I expect in this case, where the member is initialized both inline to the class and within a constructor initializer list? I would like the default constructor to initialize val to T() , so I think I need the brace initializer there.

Answer 1

This is definitely a gcc bug, and one that they've fixed by 4.9. At no point is your code invoking the copy constructor of ValueParameter<T> - so that member function should not be instantiated. Using a default member initializer for atomic<T> is fine - it is, indeed, constructible from a T .

Furthermore, what behavior should I expect in this case, where the member is initialized both inline to the class and within a constructor initializer list?

Default member initializers are just that - defaults. If you provided an initializer in the mem-initializer-list (as you do in the ValueParameter(T ) constructor), then the default is ignored. If you do not provide such an initializer (as you don't in ValueParameter() ), then the default is used.

I would like the default constructor to initialize val to T() , so I think I need the brace initializer there.

Your code should do precisely what you want it to do. gcc 4.8 just has a bug here.