overloading

In the following code, the main function uses normal function instead of Template function. #include <iostream> using namespace std; template <class T> void num(T t){cout<<"T : "<<t;} void num(int a){cout<<"wT : "<<a;} int main() { num(5); return 0; } What is the possible reason behind this? To call the template method in this case, you need to invoke the method explicitly with num<int>(5) instead of num(5) . Although the compiler can infer, non-generic method is preferred to a generic one. You can take a look at this behavior here http://ideone.com/ccDJP . Take a look at Herb Sutter's

Here is the corresponding question, what I want to know is, Is it possible to bring global function into the overload resolution with member function? I tried in 2 ways, but both don't work: void foo(double val) { cout << "double\n";} class obj { public: using ::foo; // (1) compile error: using-declaration for non-member at class scope void callFoo() { using ::foo; // (2）will cause the global version always be called foo(6.4); foo(0); } private: void foo(int val) {cout << "class member foo\n"; } }; This is plain old unqualified name lookup, specified in §3.4.1 [basic.lookup.unqual]: 1 In all

Consider this simple example code: #include <functional> #include <iostream> void f(bool _switch) { std::cout << "Nothing really" << std::endl; } void f(std::function<double (int)> _f) { std::cout << "Nothing really, too" << std::endl; } int main ( int argc, char* argv[] ) { f([](int _idx){ return 7.9;}); return 0; } It fails to compile: $ g++ --std=c++11 main.cpp main.cpp: In function ‘int main(int, char**)’: main.cpp:15:33: error: call of overloaded ‘f(main(int, char**)::<lambda(int)>)’ is ambiguous main.cpp:15:33: note: candidates are: main.cpp:6:6: note: void f(bool) main.cpp:10:6: note:

In the following piece of code, I'm trying to build a lattice of types. For instance, between float and int , promote the result to float : float join(float f, int) { return f; } float join(float f, float) { return f; } Then I introduce a wrapper type: template <typename Inner> struct wrapper { using inner_t = Inner; inner_t value; }; whose behavior with the join operation quite natural: template <typename Inner1, typename Inner2> auto join(const wrapper<Inner1>& w1, const wrapper<Inner2>& w2) -> wrapper<decltype(join(w1.value, w2.value))> { return {join(w1.value, w2.value)}; } It can also be

I have the following class(prototipe): class Token { public: //members, etc. friend std::stringstream& operator<< (std::stringstream &out, Token &t); }; And the operator is implemented like this: std::stringstream & operator<< (std::stringstream &out, Token &t) { out << t.getValue(); //class public method return out; } Now, I'm trying to use it like this: std::stringstream out; Token t; //initialization, etc. out << t; And VS gives me error, saying that there is no match for << operator. What am I wrong in? std::stringstream & operator<< (std::stringstream &out, Token &t) should be std:

Using VC++ 2010, given the following: class Base { }; class Derived : public Base { }; template<class T> void foo(T& t); // A void foo(Base& base); // B Derived d; foo(d); // calls A foo(static_cast<Base&>(d)); // calls B I would like "B" to be called above. I can achieve this with a cast to Base , but why is this necessary? I want the template function to be called for all types not derived from Base (built-in types, etc.), but I want the non-template overload to be called for types derived from Base , without requiring the client to explicitly cast. I also tried making the overload a