In a class, there can be several methods sharing the same name but differ in Parameter types Number of parameters Order of the parameters declared in the method By depending on the parameters provided for the method, in the run time, compiler determines which version of the method to execute. An overloaded method may or … Read more
§3.6.1/2 (C++03) says An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main: int main() { /* … */ } int main(int argc, char* argv[]) … Read more
Short story: overload when you can, specialise when you need to. Long story: C++ treats specialisation and overloads very differently. This is best explained with an example. template <typename T> void foo(T); template <typename T> void foo(T*); // overload of foo(T) template <> void foo<int>(int*); // specialisation of foo(T*) foo(new int); // calls foo<int>(int*); Now … Read more
If they are related Let’s for a moment assume that B is actually a base of D. Then for the call to check, both versions are viable because Host can be converted to D* and B*. It’s a user defined conversion sequence as described by 13.3.3.1.2 from Host<B, D> to D* and B* respectively. For … Read more
When you call a.foo();, the compiler goes through overload resolution to find the best function to use. When it builds the overload set it finds void foo() const and void foo() Now, since a is not const, the non-const version is the best match, so the compiler picks void foo(). Then the access restrictions are … Read more
It depends on TypeA and TypeB. If exactly one of them is applicable (e.g. there is no conversion from null to TypeB because it’s a value type but TypeA is a reference type) then the call will be made to the applicable one. Otherwise it depends on the relationship between TypeA and TypeB. If there … Read more
Look at the error message from gcc: a.cpp:16: error: call of overloaded ‘function(double, double)’ is ambiguous a.cpp:3: note: candidates are: void function(int, int) a.cpp:9: note: void function(float, float) A call to either function would require truncation, which is why neither is preferred over the other. I suspect you really want void function(double y,double w). Remember … Read more
All right, here’s the plan: we’re going to determine which function object contains the operator() overload that would be chosen if we used a bare-bones overloader based on inheritance and using declarations, as illustrated in the question. We’re going to do that (in an unevaluated context) by forcing an ambiguity in the derived-to-base conversion for … Read more
Its called Name Hiding. When you define a non virtual method with the same name as Base method it hides the Base class method in Derived class so you are getting the error for myDerived.method_A(1,2); To avoid hiding of Base class methods in Derived class use using keyword as you did in Derived2 class. Also … Read more
Varargs and generics do not play nicely together. Varargs methods can cause a warning with generic arguments, and the overloads prevent that warning except in the rare case that you want to add more than 11 items to the immutable list using of(). The comments in the source say: These go up to eleven. After … Read more