overloading

In resolving ambiguities between function template overloads, partial ordering is performed (see here for some explanations). In that website, we also learn that In case of a tie, if one function template has a trailing parameter pack and the other does not, the one with the omitted parameter is considered to be more specialized than the one with the empty parameter pack. Now, I wonder what precisely a trailing parameter pack is. Which if any of template<class ...> struct tuple { /* ... */ }; template<class T, class...Ts> void foo(tuple<T,Ts...>); template<class T, class...Ts> void bar(T, Ts..

I have base class A public class A { public virtual void Method(A parameter) { Console.WriteLine(MethodBase.GetCurrentMethod()); } public virtual void Method(B parameter) { Console.WriteLine(MethodBase.GetCurrentMethod()); } } Inhereted B public class B : A { public virtual void Method(object parameter) { Console.WriteLine(MethodBase.GetCurrentMethod()); } public override void Method(A parameter) { Console.WriteLine(MethodBase.GetCurrentMethod()); } public override void Method(B parameter) { Console.WriteLine(MethodBase.GetCurrentMethod()); } } Static class S with extension method public

I'm trying to make a design for some sort of IExecutable interface. I will not get into details, but the point is that I have several Actions that need to be executed from a base class. They may take different parameters (no big deal), and they may/may not return a value. So far, this is my design: public abstract class ActionBase { // ... snip ... } public abstract class ActionWithResultBase<T>: ActionBase { public abstract T Execute(); } public abstract class ActionWithoutResultBase: ActionBase { public abstract void Execute(); } So far, each of my concrete actions need to be a child from

I was trying to understand java overloading rules. Everything seems fine except following, public static void main(String[] args) { long aLong = 123L; foo(aLong); } private static void foo(double aDouble) { System.out.println("Foo aDouble"); } private static void foo(Long aWrapperLong) { System.out.println("Foo Wrapper Long"); } private static void foo(int anInt) { System.out.println("Foo Int"); } private static void foo(float aFloat) { System.out.println("Foo Float"); } Why does the call resolve to foo(float aFloat) . I understand the following from JLS, This step uses the name of the method

In my library I have a lot of function overloads of the form: /// \brief Does thing. /// /// \details The thing that is done is very special. template<typename T> void do_stuff(const T& t); /// \brief Does thing repeatedly. /// \copydetails do_stuff() template<typename T> void do_stuff(const T& t, std::size_t x); This, in general, works and is quite nice but creates the same documentation section multiple times. What I want is, to group those functions together. Have on detail description and each of the overloads annotated with it's brief description. I'm also not averse to aliases that could

In Fortran 90, we can overload functions with an interface. However, according to this site , we cannot define these functions with the same arguments name. With gfortran, it does not seem to be a problem as the following code works well enough: interface check module procedure check_int, check_real end interface contains subroutine check_int(cur, dname, func_name, fname) integer, allocatable, intent(in) :: cur(:) character(*) :: dname, func_name, fname ... end subroutine subroutine check_real(cur, dname, func_name, fname) real, allocatable, intent(in) :: cur(:) character(*) :: dname, func