21

Here's a class definition as an example.

#include <string>
#include <map>

template <class T>
class Collection
{
private:
  std::map<std::string, T> data;

public:
  Collection() {}

  Collection(std::map<std::string, T> d)
  {
    data = d;
  }
};

This works fine when initializing Collections with ints, chars, and even vector templated types. However, when initializing a one with a string and calling the second overloaded constructor, like:

Collection<std::string> col({
  { "key", "value" }
});

It does not compile, and throws this exit error:

main.cpp:24:22: error: call to constructor of 'Collection<std::__cxx11::string>'
      (aka 'Collection<basic_string<char> >') is ambiguous
  Collection<string> col({
                     ^   ~
main.cpp:8:7: note: candidate constructor (the implicit move constructor)
class Collection
      ^
main.cpp:8:7: note: candidate constructor (the implicit copy constructor)
main.cpp:16:3: note: candidate constructor
  Collection(map<string, T> d)
  ^

The strange thing is, while this notation is fine with other types, and this breaks, this notation works for string:

Collection<std::string> col(std::map<std::string, std::string>({
  { "key", "value" }
}));

What's going on here?

Improve this question
4
  • 3
    Brace-hell: Collection<std::string> col{{ { "key", "value" } }}; example Commented Feb 28, 2021 at 0:16
  • 1
    It would be far more efficient to write your constructor using std::move and an initializer list instead: Collection(std::map<std::string, T> d) : data(std::move(d)) { }. Doing so would avoid a pointless default initialization and copy-assignment Commented Feb 28, 2021 at 3:11
  • Constructors normally take constant references to non-POD values. You're code will use a copy and move, whereas using a reference will only use a copy Commented Feb 28, 2021 at 11:01
  • 1
    Actually @CSM, constructors which copy their arguments normally take by value and use std::move() so as to copy only once (as shown by @alter igel). I expect that's omitted from the question as it's irrelevant to the ambiguity issue. Commented Feb 28, 2021 at 16:38

2 Answers 2

Reset to default
14

This is a fun one.

A map can be constructed from two iterators:

template<class InputIterator>
  map(InputIterator first, InputIterator last,
      const Compare& comp = Compare(), const Allocator& = Allocator());

Notably, this constructor is not required to check that InputIterator is an iterator at all, let alone that the result of dereferencing it is convertible to the map's value type. Actually trying to construct the map will fail, of course, but to overload resolution, map is constructible from any two arguments of the same type.

So with

Collection<std::string> col({
  { "key", "value" }
});

The compiler sees two interpretations:

  • outer braces initializes a map using the map's initializer-list constructor, inner braces initializes a pair for that initializer-list constructor.
  • outer braces initializes a Collection, inner braces initializes a map using the "iterator-pair" constructor.

Both are user-defined conversions in the ranking, there is no tiebreaker between the two, so the call is ambiguous - even though the second, if chosen, would result in an error somewhere inside map's constructor.

When you use braces on the outermost layer as well:

Collection<std::string> col{{
  { "key", "value" }
}};

There is a special rule in the standard that precludes the second interpretation.

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

Thanks for the helpful explanation. I'm still confused on why using curly brackets instead of parentheses works, though. Is this due to {} as an operator being overloaded and thus not a constructor?
@acikek the {} notation for initialization is called list initialization. For more details, see this amazing answer to a previous question: stackoverflow.com/a/18222927/15284149
@MysteriousUser Thank you, this is all very interesting to learn about. Little intricacies like this are why I like c++.
@acikek This part (the brace-hell) is not why I like C++ :-) It shouldn't be complicated to initialize but ... there are so many layers of things that need to be handled. Uniform initialization - any day now ....
7

In this case, you are missing a {} that encloses the map {{ "key", "value" }}

EDIT: Sorry I can't comment on T.C's answer because of insufficient reputation. In any case, thanks for brilliantly highlighting the point of ambiguity.

I wanted to add on to their answer - to give a complete picture of why constructing with {} does not result in this ambiguity but constructing with () does.

The key difference between braced and parentheses initialization is that during constructor overload resolution, braced initializers are matched to std::initializer_list parameters if at all possible, even if other constructors offer better matches. This is why constructing with {} can resolve the ambiguity.

(This is taken from Item 7 of Scott Myers' Effective Modern C++)

Improve this answer

6 Comments

This works, but why does the lack of this (and putting it in parentheses instead of curly brackets) only affect std::string?
@acikek not sure about the exact logic or explanation here, but the fact {string, string} is homogenous, make it thinks it might be a C-style array.
That's a good question and I am trying to figure it out. It definitely has to do with the subtle differences between constructing with braces vs parentheses. The question of why does it affect std::string - here's my intuition. When you have { {std::string, std::string} } as the parameter, it could be construed as an an array of array<std::string>. I experimented with changing the default key to int and got the same results when both key and values are int.
To make it more unambiguous, you could try Collection<std::string> col(std::map<std::string, std::string> {{"key", "value"}}); and see that it is able to construct Collection correctly.
I did put that in my question as unexpected behavior. I think you're onto something with the arrays.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.