标签: overloading

码

public class TestOverload {

    public TestOverload(int i){System.out.println("Int");}
    public TestOverload(char... c){System.out.println("char");}

    public static void main(String[] args) {
        new TestOverload('a');
        new TestOverload(65);
    }
}

产量

Int
Int

这是预期的行为吗？如果是这样,为什么呢？我期待:char,Int

注意:我使用的是Java 8

如上所述:

http://web.archive.org/web/20090624083829/http://mail.python.org/pipermail/python-list/2003-May/206149.html

Python中没有函数重载.

据我所知,这也是一个很大的障碍,因为它也是一种OO语言.最初我发现无法区分参数类型很困难,但Python的动态特性使其变得容易(例如,列表,元组,字符串非常相似).

然而,计算传递的参数数量然后完成工作就像是一种矫枉过正.

我无法理解为什么使用参数执行构造函数Double[]？

using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            D myD = new D(null);
            Console.ReadLine();           
        }

    }

    public class D
    {
        public D(object o)
        {
            Console.WriteLine("Object");
        }
        public D(double[] array)
        {
            Console.WriteLine("Array");
        }
        public D(int i)
        {
            Console.WriteLine("Int");
        }
    }
}

我认为因为第一个构造函数采用引用类型的参数.带引号参数的第一个构造函数因为null是引用类型的默认值.

但我不明白为什么不object,它也是一个参考类型.

在C++中,函数的签名部分取决于它是否为const.这意味着一个类可以有两个具有相同签名的成员函数,除了一个是const而另一个不是.如果你有这样的类,那么编译器将根据你调用它的对象来决定调用哪个函数:如果它是类的const实例,那么将调用函数的const版本; 如果对象不是const,则将调用另一个版本.

您希望在什么情况下利用此功能？

为什么在类上定义__getitem__使其可迭代？

例如,如果我写:

class b:
  def __getitem__(self, k):
    return k

cb = b()

for k in cb:
  print k

我得到输出:

0
1
2
3
4
5
6
7
8
...

我真的希望看到"for c in cb:"中返回的错误

我想知道:

1. 为什么不能在Java中覆盖静态方法？
2. Java中是否可以重载静态方法？

鉴于所有这三个函数,这个调用是不明确的.

int f( int );
int f( int && );
int f( int const & );

int q = f( 3 );

删除f( int )导致Clang和GCC更喜欢左值引用而不是左值引用.但是,删除任一引用过载都会导致模糊不清f( int ).

过载分辨率通常是根据严格的部分排序来完成的,但int似乎相当于两个彼此不相等的东西.这里的规则是什么？我似乎记得有关此问题的缺陷报告.

在未来的标准中是否有int &&可能优先考虑int？引用必须绑定到初始化程序,而对象类型不受约束.因此,在我之间超载T并且T &&可以有效地表示"如果我已获得所有权,则使用现有对象,否则复制".(这类似于纯通的价值,但移动节省的开销).由于这些编译器目前的工作,这必须通过重载来完成T const &和T &&,并明确复制.但我甚至不确定这是严格的标准.

我有一个基本的继承情况与超类中的重载方法.

public class Person {
    private String name;
    private int dob;
    private String gender;

    public Person(String theName, int birth, String sex){
        name = theName;
        dob = birth;
        gender = sex;
    }

    public void work(){
        getWorkDetail(this);
    }

    public void getWorkDetail(Employee e){
        System.out.println("This person is an Employee");
    }

    public void getWorkDetail(Person p){
        System.out.println("This person is not an Employee");
    }
}

以下Employee类扩展了Person上面的类:

public class Employee extends Person {

    String department;
    double salary;

    public Employee(String theName, int birth, String sex){ …

我希望有一个结构,它接受任意数量的lambda,并作为所有调用运算符的中心调用点.

如果使用与构造中给出的任何lambda都不匹配的参数列表调用调用运算符,则应调用默认调用运算符.

我认为以下代码将完成这一点.每个lambda的调用操作符都被"提升"到Poc类中using.

template <typename ...Lambdas>
struct Poc : Lambdas...
{
    using Lambdas::operator() ...; // Lift the lambda operators into the class

    template <typename ...Ts>
    auto operator() (Ts...)
    {
        std::cout << "general call" << std::endl;
    }
};

// Deduction guide
template <typename ...Ts>
Poc(Ts... ts)->Poc<Ts...>;

int main()
{
    auto l_int = [](int) {std::cout << "int" << std::endl; };

    Poc poc{l_int};
    poc(1);//calls the default operator. why?

    return 0;
}

当我在结构中没有默认的调用操作符时,一切都按预期工作(使用有效的参数列表).如果我将它添加到结构中(如上面的代码中所示),每次调用默认运算符,无论我调用哪个参数.

根据我的理解,lambda-call-operators和structs(默认)call-operator存在于同一范围内.因此,他们都应该考虑重载决议.由于lamdba运算符比通用默认运算符更具体,因此应该选择它.

显然事实并非如此.这是为什么？

我测试了Microsoft Visual C++, …

除非您正在编程操作系统或嵌入式系统的某些部分,否则有任何理由这样做？我可以想象,对于一些特定的类经常重载内存管理函数或引入一个对象池而创建和销毁的类可能会降低开销,但是在全局范围内做这些事情？

另外
我刚刚在重载的删除功能中发现了一个错误 - 内存并不总是被释放.这是一个不那么重要的内存关键应用程序.此外,禁用这些过载会使性能降低约0.5%.