uniform-initialization

Why is the compiler thinking I am trying to convert from an object of type Container to an object of type MoveTest in the following code? Why is the braced constructor being forwarded to the move_things variable? Replacing the {} with () of course solves the problem #include <iostream> #include <array> using namespace std; static constexpr int NUMBER{2}; class MoveTest { public: MoveTest(const MoveTest&) { cout << "MoveTest(const MoveTest&)" << endl; } MoveTest(MoveTest&&) { cout << "MoveTest(MoveTest&&)" << endl; } MoveTest() { cout << "MoveTest()" << endl; } }; class Container { public:

It's possible to construct a vector with an iterator range, like this: std::vector<std::string> vec(std::istream_iterator<std::string>{std::cin}, std::istream_iterator<std::string>{}); But I can also compile and run code using C++11 uniform initialization syntax (note the bracers), like this: std::vector<std::string> vec{std::istream_iterator<std::string>{std::cin}, std::istream_iterator<std::string>{}}; What's really going on here? I know that a constructor taking an initializer list gets priority over other forms of construction . Shouldn't the compiler resolve to the constructor taking an

As part of a bigger project, I'm playing with std::tuple and templates; consider the following code: template <typename ...T> void foo(tuple<T...> t) {} void bar(tuple<int, char> t) {} tuple<int, char> quxx() { return {1, 'S'}; } int main(int argc, char const *argv[]) { foo({1, 'S'}); // error foo(make_tuple(1, 'S')); // ok bar({1, 'S'}); // ok quxx(); // ok return 0; } According to this answer C++17 supports tuple initialization from copy-list-initialization , however it seems such support is limited since I get the following error (GCC 7.2.0): main.cpp: In function 'int main(int, const char*

Explicit copy constructors disallow something like Foo foo = bar; , and enforce the copy usage as Foo foo(bar); . In addition, explicit copy constructors also disallow returning objects by value from a function. However, I tried replacing the copy initialization with braces, like so struct Foo { Foo() = default; explicit Foo(const Foo&) = default; }; int main() { Foo bar; Foo foo{bar}; // error here } and I am getting the error (g++5.2) error: no matching function for call to 'Foo::Foo(Foo&)' or (clang++) error: excess elements in struct initializer Removing the explicit makes the code

This code, with a const A& a member in B , where A has a deleted copy constructor, doesn't compile in GCC 4.8.1, but it works OK in clang 3.4: class A { public: A() = default; A(const A&) = delete; A& operator=(const A&) = delete; }; class B{ public: B(const A& a) : a{a} { } private: const A& a; }; int main() { A a{}; B b{a}; } Which one of the compilers is right? The error in GCC is: prog.cpp: In constructor ‘B::B(const A&)’: prog.cpp:11:14: error: use of deleted function ‘A::A(const A&)’ : a{a} ^ prog.cpp:4:5: error: declared here A(const A&) = delete; ^ Ideone: http://ideone.com/x1CVwx Your