标签: overloading

可能重复:
NULL参数的方法重载

在下面的代码输出是

串

如果我用类型参数删除方法,String那么输出是

宾语

我知道当参数类型不完全匹配时方法的重载如何起作用但我无法理解如何将null视为Object和/或String参数.

对此有何解释？

class C {

    static void m1(Object x) {
        System.out.print("Object");
    }
    static void m1(String x) {
        System.out.print("String");
    }

    public static void main(String[] args) {
        m1(null);
    }
}

在Fortran 90中,我们可以通过接口重载功能.但是,根据此站点,我们无法使用相同的参数名称定义这些函数.使用gfortran,它似乎不是一个问题,因为以下代码运行良好:

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_name, fname
  ...
end subroutine

那么,这样做是不好的做法吗？

编辑:使用关键字调用函数不会改变任何内容.

我知道类型擦除使它们在运行时看起来相同,类型,所以:

class Bar {
    def foo[A](xs: A*) { xs.foreach(println) }
    def foo[A, B](xs: (A, B)*) { xs.foreach(x => println(x._1 + " - " + x._2)) }
}   

给出以下编译器错误:

<console>:7: error: double definition:
method foo:[A,B](xs: (A, B)*)Unit and
method foo:[A](xs: A*)Unit at line 6
have same type after erasure: (xs: Seq)Unit
        def foo[A,B](xs: (A, B)*) { xs.foreach(x => println(x._1 + " - " + x._2)
) }
            ^

但是有一种简单的方法可以写:

bar.foo(1, 2, 3)
bar.foo(1 -> 2, 3 -> 4)

并让这些调用foo的不同重载版本,而不必明确命名它们:

bar.fooInts(1, 2, …

stl充满了这样的定义:

iterator begin ();
const_iterator begin () const;

由于返回值不参与重载分辨率,因此这里唯一的区别就是函数的存在const.这是超载机制的一部分吗？什么是编译器解析线的算法,如:

vector<int>::const_iterator it = myvector.begin();

当调用用于存储对象的泛型方法时,偶尔需要以不同方式处理特定类型.我知道你不能基于约束重载,但任何其他替代方案似乎都存在自己的问题.

public bool Save<T>(T entity) where T : class
{ ... some storage logic ... }

我喜欢做的事情如下:

public bool Save<SpecificClass>(T entity)
{ ... special logic ... }

在过去,我们的团队已经创建了"一次性"方法来保存这些类,如下所示:

public bool SaveSpecificClass(SpecificClass sc)
{ ... special logic ... }

但是,如果您不知道该函数存在,并且您尝试使用泛型(保存),那么您可能遇到一系列问题,即"一次性"应该修复.如果一个新的开发人员出现,看到通用的问题,并决定他将用他自己的一次性功能来解决它,这可能会变得更糟.

所以...

解决这个看似常见的问题有哪些选择？

我已经看过了,并且使用了UnitOfWork,现在它似乎是实际解决问题的唯一选择 - 但似乎是用大锤攻击苍蝇.

我明白使用templates是一种值得赞赏的重载方式,但我想知道为什么auto不能用于函数参数类型推导,从而有助于重载函数？

N3690 在7.6.1.4/3中说,使用auto可以使lambda表达式成为通用的,提供此示例

auto glambda = [](int i, auto a) { return i; };//OK: a generic lambda

(注意:N3485中没有提到)

1).为什么我不能为例如正常功能做类似的事情

void swap(auto& param1, decltype(param1)& param2)
{
     decltype(param1) temp = param1;
     param1 = param2;
     param2 = temp;
}

这给出了错误error : parameters declared auto.

来自N3690 7.1.6.4/4

使用auto或decltype(auto)声明的变量的类型是从其初始化程序推导出来的.在块(6.3),命名空间范围(3.3.6)和for-init-statement(6.5.3)中声明变量时,允许使用此方法.[...]

我错了在假设param1和param2归入块范围,因此有资格自动扣除？

2).如果允许这样的功能会有什么陷阱？

我正在使用gcc 4.8.1.

谢谢

考虑这个代码示例:

#include <iostream>
#include <functional>

typedef std::function<void()> func1_t;
typedef std::function<void(int)> func2_t;

struct X
{
   X (func1_t f)
   { }

   X (func2_t f)
   { }
};

int main ( )
{
   X x([](){ std::cout << "Hello, world!\n"; });
}

我确信它不应该编译,因为编译器不应该能够选择两个构造函数中的一个.g ++ - 4.7.3显示了这种预期的行为:它表示重载构造函数的调用是不明确的.但是,g ++ - 4.8.2成功编译了它.

这个代码在C++ 11中是正确的还是这个版本的g ++的bug /功能？

我正在尝试制定下面方案中使用的规则.请解释为什么我得到2个不同的输出.

场景1输出:我是一个对象.

class Test {

    public static void main (String[] args) {

        Test t = new Test(); 
        byte b_var = 10;
        t.do_the_test(b_var);
    }

    public void do_the_test(Character c) {

       System.out.println("I am a character.");
    }

    public void do_the_test(Integer i) {

      System.out.println("I am an integer.");
    }

    public void do_the_test(Object obj) {

      System.out.println("I am an object.");
    }
}

场景2输出:我是一个整数.

class Test {

    public static void main (String[] args) {

        Test t = new Test(); 
        byte b_var = 10;
        t.do_the_test(b_var);
    }

    public void …

在解决函数模板重载之间的歧义时,会执行部分排序(有关解释,请参见此处).在那个网站上,我们也了解到了这一点

在平局的情况下,如果一个函数模板具有尾随参数包而另一个没有,则具有省略参数的那个被认为比具有空参数包的那个更专业.

现在,我想知道什么是尾随参数包.如果有的话

template<class ...> struct tuple { /* ... */ };

template<class T, class...Ts> void foo(tuple<T,Ts...>);

template<class T, class...Ts> void bar(T, Ts...);

是和哪个不是为什么？还要注意clang认为

template<class T> void f(tuple<T>);

template<class T, class...Ts> void f(tuple<T,Ts...>);

int main()
{  f(tuple<int>());  }   // ambiguous call?

含糊不清,暗示foo没有尾随参数包.

我遇到了奇怪的错误消息，我认为这可能是不正确的。考虑以下代码：

public class Overloaded {
    public interface Supplier {
        int get();
    }

    public interface Processor {
        String process(String s);
    }

    public static void load(Supplier s) {}
    public static void load(Processor p) {}

    public static int genuinelyAmbiguous() { return 4; }
    public static String genuinelyAmbiguous(String s) { return "string"; }

    public static int notAmbiguous() { return 4; }
    public static String notAmbiguous(int x, int y) { return "string"; }

    public static int strangelyAmbiguous() { return 4; }
    public static String strangelyAmbiguous(int …