Boost C++ Libraries: Ticket #7364: ambiguity error constructing std::vector from assign::list_of

zadirion@… — Wed, 19 Sep 2012 15:29:53 GMT

Ok, since my report was closed as a duplicate, I'll be letting people know here that a temporary fix for this is the following:

Adding a to_container(dummy) call on the second list_of fixes the issue, where dummy is a dummy object of the same type as the container.

Eric Niebler — Wed, 19 Sep 2012 15:35:26 GMT

Below is an implementation of list_of that addresses the issue for C++11 compilers.

#include <iostream>
#include <iterator>
#include <algorithm>
#include <deque>
#include <vector>
#include <utility>
#include <type_traits>
template<typename T>
using uncvref = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
template<typename T>
struct generic_list;
template<typename T>
generic_list<uncvref<T>> list_of(T && t);
template<typename T>
struct generic_list
{
private:
    std::deque<T> values;
    friend generic_list<T> list_of<>(T && t);
    friend generic_list<T> list_of<>(T & t);
    friend generic_list<T> list_of<>(T const & t);
    generic_list() = default;
public:
    generic_list(generic_list &&) = default;
    generic_list(generic_list const &) = delete;
    generic_list &operator=(generic_list &&) = delete;
    generic_list &operator=(generic_list const &) = delete;
    template<typename U>
    generic_list & operator()(U && t) noexcept(noexcept(values.push_back(static_cast<U &&>(t))))
    {
        values.push_back(static_cast<U &&>(t));
        return *this;
    }
    template<typename Container, typename = decltype(Container(std::make_move_iterator(values.begin()), std::make_move_iterator(values.end())))>
    operator Container() noexcept(noexcept(Container(Container(std::make_move_iterator(values.begin()), std::make_move_iterator(values.end())))))
    {
        return Container(std::make_move_iterator(values.begin()), std::make_move_iterator(values.end()));
    }
};
template<typename T>
inline generic_list<uncvref<T>> list_of(T && t)
{
    return std::move(generic_list<uncvref<T>>()(static_cast<T &&>(t)));
}
struct moveable
{
    moveable() = default;
    moveable(moveable &&) = default;
    moveable(moveable const &) = delete;
    moveable &operator=(moveable &&) = default;
    moveable &operator=(moveable const &) = delete;
};
int main()
{
    std::vector<int> i(list_of(1));
    std::copy(i.begin(), i.end(), std::ostream_iterator<int>(std::cout, "\n"));
    std::vector<moveable> j = list_of(moveable())(moveable());
}

The trick to fixing the ambiguity error is the defaulted template parameter on operator Container that only allows the conversion if the container can be constructed from a pair of iterators.

HTH.

zadirion@… — Wed, 26 Sep 2012 09:41:33 GMT

Replying to eric_niebler:

Below is an implementation of list_of that addresses the issue for C++11 compilers.

#include <iostream>
#include <iterator>
#include <algorithm>
#include <deque>
#include <vector>
#include <utility>
#include <type_traits>
template<typename T>
using uncvref = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
template<typename T>
struct generic_list;
template<typename T>
generic_list<uncvref<T>> list_of(T && t);
template<typename T>
struct generic_list
{
private:
    std::deque<T> values;
    friend generic_list<T> list_of<>(T && t);
    friend generic_list<T> list_of<>(T & t);
    friend generic_list<T> list_of<>(T const & t);
    generic_list() = default;
public:
    generic_list(generic_list &&) = default;
    generic_list(generic_list const &) = delete;
    generic_list &operator=(generic_list &&) = delete;
    generic_list &operator=(generic_list const &) = delete;
    template<typename U>
    generic_list & operator()(U && t) noexcept(noexcept(values.push_back(static_cast<U &&>(t))))
    {
        values.push_back(static_cast<U &&>(t));
        return *this;
    }
    template<typename Container, typename = decltype(Container(std::make_move_iterator(values.begin()), std::make_move_iterator(values.end())))>
    operator Container() noexcept(noexcept(Container(Container(std::make_move_iterator(values.begin()), std::make_move_iterator(values.end())))))
    {
        return Container(std::make_move_iterator(values.begin()), std::make_move_iterator(values.end()));
    }
};
template<typename T>
inline generic_list<uncvref<T>> list_of(T && t)
{
    return std::move(generic_list<uncvref<T>>()(static_cast<T &&>(t)));
}
struct moveable
{
    moveable() = default;
    moveable(moveable &&) = default;
    moveable(moveable const &) = delete;
    moveable &operator=(moveable &&) = default;
    moveable &operator=(moveable const &) = delete;
};
int main()
{
    std::vector<int> i(list_of(1));
    std::copy(i.begin(), i.end(), std::ostream_iterator<int>(std::cout, "\n"));
    std::vector<moveable> j = list_of(moveable())(moveable());
}

The trick to fixing the ambiguity error is the defaulted template parameter on operator Container that only allows the conversion if the container can be constructed from a pair of iterators.

HTH.

I must point out the fix you posted does not compile in Visual Studio 2012. The templated using syntax and the = default and = delete modifiers are not implemented in VS2012

anonymous — Mon, 28 Jan 2013 08:13:07 GMT

How come this hasn't been fixed yet? This is pretty serious.

Eric Niebler — Wed, 30 Jan 2013 18:17:19 GMT

To be fair to Thorsten, I think this is impossible to fix in C++98. At least, I wasn't able to think of a way.

anonymous — Thu, 01 Aug 2013 04:25:36 GMT

Replying to zadirion@…:

Adding a to_container(dummy) call on the second list_of fixes the issue

or more succinctly convert_to_container< container_type >().

Tue, 06 Aug 2013 12:32:37 GMT

Any plans when this issue will be fixed?

asaliheddine@… — Tue, 21 Jan 2014 08:59:16 GMT

Hi Guys

is there any update on this issue? any fix for VS2012?

Thanks Ahmed

abhinuke@… — Tue, 07 Apr 2015 13:23:52 GMT

Hi Guys,

Is there any update on this issue? Any fix for VS2013?

Thanks, Abhishek D

Michel Morin — Tue, 07 Apr 2015 14:30:57 GMT

My patch (assign_cxx0x.patch) in #5419 fixes this problem on clang and gcc. I've not tested with VS, but I believe it works fine on VS 2013.

Fri, 13 Nov 2015 16:15:24 GMT

Any chance we can get this fix into boost 1.60? I found it solves the issue as well.

anonymous — Thu, 01 Sep 2016 00:45:28 GMT

Is this fixed yet?

anonymous — Thu, 01 Feb 2018 19:42:38 GMT

Had to use workaround

using namespace boost::assign; std::vector<int> data; data += 1,2,3;

owner changed

James E. King, III — Mon, 08 Oct 2018 02:24:25 GMT

owner changed from Thorsten Ottosen to James E. King, III

status changed; resolution set

James E. King, III — Mon, 08 Oct 2018 02:24:40 GMT

status new → closed
resolution → duplicate

See trac-5419

version, milestone changed

James E. King, III — Mon, 08 Oct 2018 02:24:59 GMT

version Boost Development Trunk → Boost 1.53.0
milestone To Be Determined → Boost 1.69

James E. King, III — Mon, 08 Oct 2018 02:26:22 GMT

https://github.com/boostorg/assign/pull/20