overload-resolution

This complete C# program illustrates the issue: public abstract class Executor<T> { public abstract void Execute(T item); } class StringExecutor : Executor<string> { public void Execute(object item) { // why does this method call back into itself instead of binding // to the more specific "string" overload. this.Execute((string)item); } public override void Execute(string item) { } } class Program { static void Main(string[] args) { object item = "value"; new StringExecutor() // stack overflow .Execute(item); } } I ran into a StackOverlowException that I traced back to this call pattern where

I have the following code: #include <iostream> template <typename T> void f (T) { std::cout << "f(T)" << std::endl; } template <typename T> void f (bool) { std::cout << "f(bool)" << std::endl; } int main ( ) { f(true); // #1 prints f(T) f<bool>(true); // #2 prints f(bool) } The #1 line calls f(T) , while #2 line calls f(bool) . Why does this happen? And what are the rules for selecting an overloaded template function? UPDATE I understood that in the first call compiler is just unable to deduce T while trying to call the second function, so the first is chosen. In the second call second

I am trying to understand why std::function is not able to distinguish between overloaded functions. #include <functional> void add(int,int){} class A {}; void add (A, A){} int main(){ std::function <void(int, int)> func = add; } In the code shown above, function<void(int, int)> can match only one of these functions and yet it fails. Why is this so? I know I can work around this by using a lambda or a function pointer to the actual function and then storing the function pointer in function. But why does this fail? Isn't the context clear on which function I want to be chosen? Please help me

I'm playing with a trick to overload lambdas in C++. Specifically: // For std::function #include <functional> // For std::string #include <string> // For std::cout #include <iostream> template <class... F> struct overload : F... { overload(F... f) : F(f)... {} }; template <class... F> auto make_overload(F... f) { return overload<F...>(f...); } int main() { std::function <int(int,int)> f = [](int x,int y) { return x+y; }; std::function <double(double,double)> g = [](double x,double y) { return x+y; }; std::function <std::string(std::string,std::string)> h = [](std::string x,std::string y) {