Boost C++ Libraries: Ticket #5419: assign fails with C++0x compilers

anonymous — Tue, 05 Apr 2011 21:53:27 GMT

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

attachment set

Mon, 18 Jul 2011 15:39:17 GMT

attachment → list_of_cxx0x.patch

A patch for list_of.hpp (against trunk)

Mon, 18 Jul 2011 15:42:14 GMT

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.

attachment set

Tue, 19 Jul 2011 15:49:20 GMT

attachment → list_of_cxx0x_2.patch

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

Tue, 19 Jul 2011 15:50:41 GMT

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

attachment set

Sat, 13 Aug 2011 00:10:29 GMT

attachment → assign_cxx0x.patch

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

Sat, 13 Aug 2011 00:22:57 GMT

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&>;

Sat, 13 Aug 2011 00:23:47 GMT

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.

type changed

Thu, 29 Sep 2011 14:31:18 GMT

type Bugs → Patches

Thu, 16 Jan 2014 12:36:23 GMT

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.

owner changed

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

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

status changed; resolution set

James E. King, III — Mon, 08 Oct 2018 02:13:28 GMT

status new → closed
resolution → wontfix

Please use gcc 4.8 or later.

milestone changed

James E. King, III — Mon, 08 Oct 2018 02:23:29 GMT

milestone To Be Determined → Boost 1.69

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

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

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

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