assign fails with C++0x compilers

[Chris Jefferson]

Assign is failing to compile with a clang and libc++ when in C++0x mode. I believe this is because C++0x has two operator= for each container, for example vector has:

operator=(const std::vector<T>&) operator=(initialiser_list<T>)

And the technique of using (from list_of.hpp)

template< class Container >

operator Container() const {

return this-> BOOST_NESTED_TEMPLATE convert_to_container<Container>();

}

Can't choose between these two options.

I don't know the best, or really any good way, to fix this unfortunately.

[anonymous]

Hm. That could be problematic.

Since initializer lists only take on template argument, we should be able to do the following:

replace

template< class Container > operator Container() const

with

template< template<class,class> Container, class T, class A > operator Container<T,A>() const

Furthermore, this only takes care of templates with two arguments like standard sequence. Therefore, we also need to add overloads with 3 and four arguments.

A bigger problem arises with something like boost::multi_index_container which may have many template arguments ... hm ... maybe the C++11 solution is to use variadic templates to cover all cases with more than one template argument.

If you can make a patch and test it, I'd be happy to apply it.

regards

-Thorsten

[Michel MORIN <mimomorin@…>]

A patch for list_of.hpp (against trunk)

[Michel MORIN <mimomorin@…>]

Attached a patch for this ticket.
I use C++0x's "default template arguments for function templates" feature to SFINAE out the conversion operator to initializer_list. (While Container is required to have difference_type nested-type, initializer_list does not have it.

[Michel MORIN <mimomorin@…>]

A new patch for list_of.hpp (previous patch is incomplete).

[Michel MORIN <mimomorin@…>]

A new patch attached. The previous patch only fixes generic_list, but this patch fixes both generic_list and static_generic_list.

[Michel MORIN <mimomorin@…>]

A patch for boost/assign/list_of.hpp and libs/assign/test/. This patch includes the previous fixes.

[Michel MORIN <mimomorin@…>]

A patch attached. I believe it's the final patch for this problem ;)

With this patch, the test (libs/assign/test) runs successfully on

• gcc-4.3.6, gcc-4.4.6, gcc-4.5.3, gcc-4.6.1
• clang (trunk)

The test runs in both C++03 and C++0x modes.

The previous patch fixes the problem of ambiguity with std::initializer_list<T>. However, in order to pass all the test, this is not enough. I added the following fixes:

• (boost/assign/list_of.hpp) The ambiguity problem is also happened with std::allocator<T>. Adding dummy template parameter to the conversion function can avoid this ambiguity:

  template
  < 
      class Container
    , class Dummy1 = typename Container::difference_type
    , class Dummy2 = typename Container::iterator
  >
  operator Container() const
  {
      // ...
  }
  

  std::initializer_list<T> is SFINAE'ed out by Dummy1 and std::allocator<T> is SFINAE'ed out by Dummy2.

• (libs/assign/test/std.cpp) In C++0x mode of some compilers, the code

  using namespace std;
  // ...
  typedef pair<string,int> tuple; 
  

  interact badly with std::tuple<Args…> and causes compiler errors. Simply changing the typedef fixes the problem:

  using namespace std;
  // ...
  typedef pair<string,int> two; 
  

• (libs/assign/test/list_inserter.cpp) In C++0x mode of gcc-4.3, std::vector<T> does not have

  void push_back(const T&);
  

  but it has

  template <typename Args...>
  void push_back(Args&&...);
  

  So the code

  push_back_t push_back_func = &vector<int>::push_back;
  

  should be changed to

  push_back_t push_back_func = &vector<int>::push_back<const int&>;
  

[Michel MORIN <mimomorin@…>]

The rationale for using SFINAE by "default template arguments for function templates" rather than restricting the number of template parameters by variadic templates is that

• User-defined containers can have only one template parameter. In this case, the variadic template approach breaks the existing code.

• Variadic templates cannot handle ordinary (type) template parameters and non-type template parameters simultaneously. This means that we have to define different overloads for different patterns of non-type template parameters. It's a mess.

[Adam Romanek <romanek.adam@…>]

Why was the type of this ticket changed to Patches? For me it's kind of a bug. The problem appears when trying to compile a code that uses Boost.Assign, in C++11 mode (in my case the problem is with assignment boost::assign::map_list_of() to boost::unordered_map).

What are the chances to push this forward? Is there any workaround? I may provide a test case if it helps.

[James E. King, III]

Please use gcc 4.8 or later.

[James E. King, III]

So it looks like I cannot reopen this, but it was reported in #7364 so I will submit a PR

[James E. King, III]

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