overload-resolution

This problem came up when answering this question about overload resolution with enums . While the case for long long was definitely a bug in MSVC2012NovCTP (according to the standard text and a test with gcc 4.7.1), I cannot figure out why the following behavior occurs: #include <iostream> enum charEnum : char { A = 'A' }; void fct(char) { std::cout << "fct(char)" << std::endl; } void fct(int) { std::cout << "fct(int)" << std::endl; } void fct(long long) { std::cout << "fct(long long)" << std::endl; } int main() { fct('A'); fct(A); } Both MSVC2012NovCTP and gcc 4.7.1 agree on this output: fct

In C++0x SFINAE rules have been simplified such that any invalid expression or type that occurs in the "immediate context" of deduction does not result in a compiler error but rather in deduction failure (SFINAE). My question is this: If I take the address of an overloaded function and it can not be resolved, is that failure in the immediate-context of deduction? (i.e is it a hard error or SFINAE if it can not be resolved)? Here is some sample code: struct X { // template<class T> T* foo(T,T); // lets not over-complicate things for now void foo(char); void foo(int); }; template<class U> struct

I am trying to understand why someone would write a function that takes a const rvalue reference . In the code example below what purpose is the const rvalue reference function (returning "3"). And why does overload resolution preference the const Rvalue above the const LValue reference function (returning "2"). #include <string> #include <vector> #include <iostream> std::vector<std::string> createVector() { return std::vector<std::string>(); } //takes movable rvalue void func(std::vector<std::string> &&p) { std::cout << "1"; } //takes const lvalue void func(const std::vector<std::string> &p)

The following program does not compile, because in the line with the error, the compiler chooses the method with a single T parameter as the resolution, which fails because the List<T> does not fit the generic constraints of a single T . The compiler does not recognize that there is another method that could be used. If I remove the single- T method, the compiler will correctly find the method for many objects. I've read two blog posts about generic method resolution, one from JonSkeet here and another from Eric Lippert here , but I could not find an explanation or a way to solve my problem.

#include <iostream> template<typename T> struct identity { typedef T type; }; template<typename T> void bar(T) { std::cout << "a" << std::endl; } template<typename T> void bar(typename identity<T>::type) { std::cout << "b" << std::endl; } int main () { bar(5); // prints "a" because of template deduction rules bar<int>(5); // prints "b" because of ...? return EXIT_SUCCESS; } I expected bar<int>(5) to result in an ambiguity, at the very least. What crazy rule about template function overload resolution is involved here? Barry Once we get our candidate functions set (both bar s), and then whittle

Consider the following program: #include <cstddef> #include <cstdio> void f(char const*&&) { std::puts("char const*&&"); } // (1) void f(char const* const&) { std::puts("char const* const&"); } // (2) template <std::size_t N> void f(char const (&)[N]) { std::puts("char const(&)[N]"); } // (3) int main() { const char data[] = "a"; f(data); } Which f should be called? Why? The latest released versions of three compilers disagree on the answer to this question: (1) is called when the program is compiled using g++ 4.5.2 (2) is called when the program is compiled using Visual C++ 2010 SP1 (3) is

I noticed this the other day, say you have two overloaded methods: public void Print<T>(IEnumerable<T> items) { Console.WriteLine("IEnumerable T"); } public void Print<T>(T item) { Console.WriteLine("Single T"); } This code: public void TestMethod() { var persons = new[] { new Person { Name = "Yan", Age = 28 }, new Person { Name = "Yinan", Age = 28 } }; Print(persons); Print(persons.ToList()); } prints: Single T Single T Why are Person[] and List<Person> better matched to T than they are to IEnumerable<T> in these cases? Thanks, UPDATE: Also, if you have another overload public void Print<T>