overload-resolution

In trying to compile the following code which would copy a map s keys to a vector : map<string, string> mss; vector<string> vs; transform(mss.begin(), mss.end(), back_inserter(vs), get<0>); VS2013 can't distinguish which get is intended but this simpler usage works just fine: vs.push_back(get<0>(*mss.begin())); Specifying get<0, string, string> didn't help. What am I missing? There are many overloads of std::get , where, in addition, each is a function template itself, therefore the compiler can't tell which one you want at the call site where you request for the address of one of them. If you

We've recently moved from VS2013 to VS2017 in our company. After the upgrade our codebase would no longer build. We would get the following error: The call is ambiguous between the following methods or properties: 'IRepository<T>.Get(object, params Expression<Func<T, object>>[])' and 'IRepository<T>.Get(object, params string[])' Here is the call itself: this.mainRepository.Get(newEntity.Id); ...and the interface definition: public interface IRepository<T> where T : class { T Get(object id, params Expression<Func<T, object>>[] includeExprs); T Get(object id, params string[] includeExprs); } I

In an answer to this question: Initializing vector<string> with double curly braces it is shown that vector<string> v = {{"a", "b"}}; will call the std::vector constructor with an initializer_list with one element . So the first (and only) element in the vector will be constructed from {"a", "b"} . This leads to undefined behavior, but that is beyond the point here. What I have found is that std::vector<int> v = {{2, 3}}; Will call std::vector constructor with an initializer_list of two elements . Why is the reason for this difference in behavior? The rules for list initialization of class

When overloading a templated function, how should the compiler chose which version of the function to call if it has the option to either: Call a templated version of the function (such as func<T>(foo) ). Call an overloaded version of the function which is not itself templated but where the type of the parameter being passed to the function inherits from the type specified in the overloaded function template. Consider the following C++ code: #include <stdio.h> struct Parent {}; struct Child : public Parent {}; template <typename T> void func(T) { printf("func(T)\n"); } void func(Parent) {