为什么缩小转换不会阻止不正确类型的map.insert（）失败？

Question

Background

When inserting a std::pair<uint64_t, uint64_t> to a C++ std::map<uint64_t, int> , neither the compiler nor the program complains, even if the passed values are not possible for the data type uint64_t .

In other words, the narrowing conversion of std::pair<uint64_t, uint64_t>(2, -2) isn't working and is defaulting to the map's type std::map<uint64_t, int>

Code

When I compile and execute the following code with g++ -Wall -Wconversion -Wextra -pedantic test/test_wrong_insert.cpp && ./a.out :

#include<map>
#include<iostream>

void print_map(std::map<uint64_t, int> & m){
  std::cout << "The map is now: {";
  for (const auto & n: m){
    std::cout << '(' << n.first << ',' << n.second << ") ";
  }
  std::cout << "}\n";
}

int main(){
  std::map<uint64_t, int> m;

  auto ret = m.insert(std::pair<uint64_t, uint64_t>(2,-2));
  std::cout << "Tried to insert std::pair<uint64_t, uint64_t>(2,-2). ";
  std::cout << "Return: " << ret.second << '\n';
  print_map(m);
}

Result

... this is the output:

Tried to insert std::pair<uint64_t, uint64_t>(2,-2). Return: 1
The map is now: {(2,-2) }

Question

Why does std::pair<uint64_t,uint64_t> x{-1,-2} not produce an error, and how do I make it cause an error?

Answer 1

Why does std::pair<uint64_t,uint64_t> x{-1,-2} not produce an error?

This is caused by a constructor template that participates in overload resolution when both arguments can be used to construct objects of uint64_t (or whatever type you instantiated std::pair with). It is overload (3) in the list of std::pair constructors , and its template argument deduction leads to a conversion that is taken as intentional (as in auto n = uint64_t{-42}; or static_cast<uint64_t>(-42); ) - hence no warning. There's not much you can do about it, as the template parameters of a constructor template can't be given explicitly, as explained here .

[...] how to make it cause an error?

Use std::make_pair and don't rely on template argument deduction:

auto p = std::make_pair<uint64_t, uint64_t>(-42, -42);
//         Be explicit: ^^^^^^^^  ^^^^^^^^

When you compile the above snippet with -Wsign-conversion (important: -Wconversion won't cath it!), it will give you a warning (obviously, add -Werror to treat it as an error).

The issue with std::map::insert is the same, see overload (2) here . This turns any usable given argument into a value_type object, and treats it as any conversion would be the caller's intention. Interestingly, the equivalent member function on a std::set is more restricted. So this is caught:

std::set<uint64_t> s;

s.insert(-42); // complains with -Wsign-conversion