Boost C++ Libraries: Ticket #6711: with unordered_map using interprocess basic_string in shared memory, find and [] are annoying

status changed; resolution set

Daniel James — Wed, 21 Mar 2012 21:31:05 GMT

status new → closed
resolution → wontfix

Closing as "won't fix", since boot unordered is an implementation of the standard unordered containers, and this would be a break from the standard. It would also be worse when using std::equal_to or boost::hash since it would have to cast for every call to those function objects rather than just once for the call to operator[].

olafvdspek@… — Wed, 21 Mar 2012 22:04:19 GMT

The standard doesn't require you to not have extra find() overloads, does it?

Daniel James — Wed, 21 Mar 2012 23:00:50 GMT

It does, because it can break valid code. Consider this:

#include <cassert>
#include <functional>
struct source {};
struct value {
    value(source&&) {}
};
void foo(value const& x) { std::equal_to<value>(x); }
#if defined(ADD_TEMPLATE)
template <typename T>
void foo(T const& x) { std::equal_to<value>(x); }
#endif
int main() {
    foo(source());
}

Note that ADD_TEMPLATE adds a template overload, as you're suggesting. Defining ADD_TEMPLATE causes it to fail:

$ g++-mp-4.7 --std=c++0x demo.cpp
$ g++-mp-4.7 --std=c++0x demo.cpp -DADD_TEMPLATE
demo.cpp: In instantiation of 'void foo(const T&) [with T = source]':
demo.cpp:19:17:   required from here
demo.cpp:15:24: error: invalid initialization of reference of type 'const value&' from expression of type 'const source'
demo.cpp:9:6: error: in passing argument 1 of 'void f(const value&)'

The same could happen if a template overload was added for find.

Fri, 23 Mar 2012 12:35:26 GMT

VC11 says "error C2082: redefinition of formal parameter 'x'" for the first "std::equal_to<value>(x);"

Without equal_to(), it compiles fine.

Even if it didn't, why not just replace the original find() with a template variant?

anonymous — Fri, 23 Mar 2012 12:58:07 GMT

Sorry, I messed up that example, here's a better one. This one doesn't use rvalue references because I don't have access to an appropriate compiler at the moment, but it demonstrates why a template method would break valid code (foo calls std::equal_to in the same way that find does):

#include <functional>
struct source {};
struct value {
    value(source&) {}
    bool operator==(value const&) const { return true; }
};
struct pseudo_container
{
    std::equal_to<value> eq;
#if defined(USE_A_TEMPLATE)
    template <typename T>
    void foo(T const& x) {
        eq(x, x);
    }
#else
    void foo(value const& x) {
        eq(x, x);
    }
#endif
};
int main() {
    pseudo_container x;
    source s;
    x.foo(s);
}

Fri, 23 Mar 2012 13:09:39 GMT

Isn't that because the value constructor takes a non-const & to source? With const& it works.

anonymous — Fri, 23 Mar 2012 13:14:18 GMT

But value types are allowed to use non-const constructors from arbitrary types, I can't stop them doing that.

anonymous — Fri, 23 Mar 2012 13:14:54 GMT

Sorry, 'are allowed to construct with non-const references from arbitrary types'.

Fri, 23 Mar 2012 13:42:42 GMT

Hmm, equal_to is the real problem, as it requires the two types to be the same. You'd need an equal_to variant that doesn't.

Daniel James — Sun, 25 Mar 2012 21:10:02 GMT

Yes, but equal_to is actually a template parameter, whose concept is defined by the standard so I can't change it.

Tue, 27 Mar 2012 11:56:06 GMT

That sucks :p