标签: overloading

我正在与一个奇怪的,至少对我来说,重载.net的分辨率方法摔跤.我写了一个小样本来重现这个问题:

class Program
{
    static void Main(string[] args)
    {
        var test = new OverloadTest();
        test.Execute(0);
        test.Execute(1);

        Console.ReadLine();
    }
}

public class OverloadTest
{
    public void Execute(object value)
    {
        Console.WriteLine("object overload: {0}", value);
    }

    public void Execute(MyEnum value)
    {
        Console.WriteLine("enum overload: {0}", value);
    }
}

public enum MyEnum
{ 
    First = 1, Second = 2, Third = 3
}

将打印:

enum overload: 0
object overload: 1

基本上,调用的重载因值(0,1)而不是给定的数据类型而不同.

有人能解释一下吗

更新

我应该指出C#2和C#3之间存在不同的行为

Do((long)0) => object overload //C# 2
Do((long)0) => enum overload   //C# …

从C++ 11草案,7.5(第1段):

具有不同语言链接的两种函数类型是不同的类型,即使它们在其他方面是相同的.

所以我可以根据语言链接做过载:

extern "C" typedef void (*c_function)();
typedef void (*cpp_function)();

void call_fun(c_function f)
{
}
void call_fun(cpp_function f)
{
}

extern "C" void my_c()
{
}
void my_cpp()
{
}
int main()
{
    call_fun(my_c);
    call_fun(my_cpp);
}

但是,使用GCC 4.7.1,此示例代码提供了错误消息:

test.cpp: In function 'void call_fun(cpp_function)':
test.cpp:7:6: error: redefinition of 'void call_fun(cpp_function)'
test.cpp:4:6: error: 'void call_fun(c_function)' previously defined here

使用CLang ++:

test.cpp:7:6: error: redefinition of 'call_fun'
void call_fun(cpp_function f)
     ^
test.cpp:4:6: note: previous definition is here
void call_fun(c_function f)
     ^

现在的问题是: …

我不明白这种Java行为.我有两节课:

class C1 {
    public void m1(double num) {
        System.out.println("Inside C1.m1(): " + num);
    }
}

class C2 extends C1 {
    public void m1(int num) {
        System.out.println("Inside C2.m1(): " + num);
    }
}

这是我的主要内容:

public class Main {

    public static void main(String[] args) {
        C1 c = new C2();
        c.m1(10);
    }
}

结果是:

Inside C1.m1(): 10.0

当我预料到:

Inside C2.m1(): 10

当我尝试完成代码语法时,我发现了这个:

C2类的其他m1在哪里？

我还检查了我的Main.class的字节码,我看到了这个:

Compiled from "Main.java"
public class com.company.Main {
  public com.company.Main();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method …

参数类型相同的静态和非静态成员函数不能重载。但是，如果成员函数是模板并且其中之一有requires子句，那么所有编译器都允许它。但是当调用这两个成员函数时就会出现问题：

struct A {
    static int f(auto) { return 1; }
    int f(auto) requires true { return 2; }
};

int main() {
    [[maybe_unused]] int (A::*y)(int) = &A::f; // ok everywhere (if no below line)
    [[maybe_unused]] int (*x)(int) = &A::f; //ok in GCC and Clang (if no above line)
}

如果只剩下一行（任意），main()则 GCC 和 Clang 接受该程序。但是当两行都main()存在时，Clang 会打印

error: definition with same mangled name '_ZN1A1fIiEEiT_' as another definition

GCC 报告内部编译器错误。演示： https: //gcc.godbolt.org/z/4c1z7fWvx

所有编译器在接受struct …

有没有办法在JavaScript中创建类似数组的对象,而不使用内置数组？我特别关注这样的行为:

var sup = new Array(5);
//sup.length here is 0
sup[0] = 'z3ero';
//sup.length here is 1
sup[1] = 'o3ne';
//sup.length here is 2
sup[4] = 'f3our';        
//sup.length here is 5

我在这里看到的特殊行为是sup.length更改而没有调用任何方法.我从这个问题中了解到,在数组的情况下,[]运算符会被重载,这就解释了这种行为.有没有一种纯粹的JavaScript方式来复制这种行为,或者语言是不是足够灵活？

根据Mozilla文档,正则表达式返回的值也可以用这个索引做一些时髦的事情.用普通的javascript可以实现吗？

我打字的时候遇到了这个问题man 2 open.它说开放有两种,一种有两个args,一种有三种!上次我检查时我们无法在C中重载功能.他们是怎么做到的？他们用C++写的吗？

int open(const char * pathname, int flags);
int open(const char * pathname, int flags, mode_t mode);

可能重复:
使用count()实现ArrayAccess的对象的计数元素？

在PHP 5中,您可以使用魔术方法,重载某些类等.在C++中,只要参数类型不同,就可以实现存在的函数.有没有办法在PHP中执行此操作？

我想做的一个例子是:

class a {
    function a() {
        $this->list = array("1", "2");
    }
}

$blah = new a();

count($blah);

我想要等待返回2. IE计算类中特定数组的值.所以在C++中,我这样做的方式可能如下所示:

int count(a varName) { return count(varName->list); }

基本上,我正在尝试简化大型应用程序的数据调用,所以我可以调用:

count($object);

而不是

count($object->list);

该列表可能是一个对象列表,因此根据它的使用方式,如果有人必须以当前的方式执行它,那么它可能是非常令人讨厌的声明:

count($object->list[0]->list[0]->list);

那么,我可以制作类似的东西:

function count(a $object) {
    count($object->list);
}

我知道PHP的计数接受混合var,所以我不知道我是否可以覆盖单个类型.

给定以下具有重载版本的伴随对象apply:

object List {
  def apply[T](): List[T] = new Nil
  def apply[T](x1: T): List[T] = new Cons(x1, new Nil)
  def apply[T](x1: T, x2: T): List[T] = new Cons(x1, new Cons(x2, new Nil))
  def apply[T](elems: T*): List[T] = 
    elems.foldRight(List[T])((elem, l) => new Cons(elem, l))
}

和两个实例

List(1) // Error - Ambiguity 
List('a', 'b') // Works fine

scalac抱怨第一个实例化(对重载定义的模糊引用),因为单个参数和varargs方法都是同样具体的.

搜索stackoverflow我发现可以强制使用单个参数方法.List[Int](1)将使编译器使用def apply[T](x1: T).

我的问题是为什么第二个实例化def apply[T](x1: T, x2: T)没有额外的"提示" 匹配？换句话说,为什么两个参数方法比单个参数方法不是的varargs方法更 …

理解关于重载解析的C#语言规范显然很难,现在我想知道为什么这个简单的情况失败了:

void Method(Func<string> f)
{
}
void Method(Func<object> f)
{
}
void Call()
{
    Method(() => { throw new NotSupportedException(); });
}

这给出了编译时错误CS0121,以下方法或属性之间的调用是不明确的:后跟我的两个Method函数成员(重载).

我本来期望的是,Func<string>是一个更好的转换目标比Func<object>,然后应使用第一个重载.

由于.NET 4和C#4(2010),通用委托类型Func<out TResult>已协变中TResult,并且由于该原因的隐式转换从存在Func<string>于Func<object>同时明确的隐式转换可以从存在Func<object>于Func<string>.那么它会产生Func<string>更好的转换目标,而重载分辨率应该选择第一个过载？

我的问题很简单:我在这里错过了C#规范的哪一部分？

增加:这很好用:

void Call()
{
    Method(null); // OK!
}

任何人都可以这么好,并解释为什么这个代码显示Derived.DoWork(double).我可以为这种行为提出一些解释,但我希望有人为我澄清这一点.

using System;

public class Base
{
    public virtual void DoWork(int param) {
        Console.WriteLine("Base.DoWork");
    }
}

public class Derived : Base
{
    public override void DoWork(int param) {
        Console.WriteLine("Derived.DoWork(int)");
    }

    public void DoWork(double param) {
        Console.WriteLine("Derived.DoWork(double)");
    }

    public static void Main() {
        int val = 5;
        Derived d = new Derived();
        d.DoWork(val);
    }
}