首先，我不知道如何恰当地表达这个问题，所以这是一个建议。
假设我们有以下重载方法：
void execute(Callable<Void> callable) {
try {
callable.call();
} catch (Exception e) {
e.printStackTrace();
}
}
<T> T execute(Supplier<T> supplier) {
return supplier.get();
}
void execute(Runnable runnable) {
runnable.run();
}
从这张表出发，我从另一个问题中得到了答案
Supplier () -> x
Consumer x -> ()
BiConsumer x, y -> ()
Callable () -> x throws ex
Runnable () -> ()
Function x -> y
BiFunction x,y -> z
Predicate x -> boolean
UnaryOperator x1 -> x2
BinaryOperator x1,x2 -> x3
以下是我在本地得到的结果：
Supplier () -> …如果我有这两种方法
public Foo Get(string bar) { ... }
public Foo Get(int bar) { ... }
并在不同的方法上编写这段xml文档
/// <summary>
/// Has a close relation to the <see cref="Get"/> methods.
/// </summary>
我得到一个蓝色波浪形Get,说这是一个不明确的参考'得到'.这是真的,但我希望它引用两者.这样做的正确方法是什么？或者我应该只引用单个方法重载？
当我们使用newC#时,我个人认为只是作为一种解决方法来覆盖没有虚拟/可覆盖声明的属性,在VB.NET中我们有两个"概念" Shadows和Overloads.
在哪种情况下喜欢彼此？
今天,看一下手册页open(),我注意到这个函数是'重载':
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
我不认为这是可能的C.实现这个目的的"诀窍"是什么？
LATER EDIT:
所以它并没有真正超载,因为在使用varargs时 - 你只能提供相同类型的多个参数.那么,mode_t幕后是一个int吗？
首先,我正在阅读一些论坛和MSDN中的帮助,并且所有人都说代理人不能超载.
现在,我希望有这样的东西:
public delegate void OneDelegate();
public delegate void OneDelegate(params object[] a);
public void DoNothing(params object[] a) {}
public void DoSomething() { /* do something */ }
private OneDelegate someFunction;
someFunction = new OneDelegate(DoSomething);
someFunction = new OneDelegate(DoNothing);
所以,就像你知道的那样,你不能这样做,因为OneDelegate只引用第一个而不是第二个.但是,有没有办法做到这一点？或类似的东西？
PS1:我希望拥有任意数量的OneDelegate声明,而不仅仅是一两个声明.
我刚刚阅读了关于C11的维基百科文章,这是2011年12月发布的C标准的新版本,我看到其中一个增加的功能是"类型通用表达式":
使用
_Generic关键字的类型泛型表达式.例如,下面的宏CBRT(X)转换为cbrtl(X) ,CBRT(X)或cbrtf(X) 取决于类型X:Run Code Online (Sandbox Code Playgroud)#define cbrt(X) _Generic((X), long double: cbrtl, \ default: cbrt, \ float: cbrtf)(X)
这看起来非常糟糕 - 如果他们要改变语言,为什么不像C++一样添加函数重载？
我刚刚发现了一个非常有趣的Java技巧:
void method1(Integer... a){
}
因此,您可以根据需要为此方法提供尽可能多的整数.
现在,如果我有一个类似的(重载)方法,如下所示:
void method1(int a, int b){
}
执行以下行时运行哪个方法:
method1(1, 2);
好吧,我可以通过用不同的方法指令测试它很容易找到它但是当我想到"重载"方法中的"规则"时,我必须确保每个重载方法必须相同,以便编译器知道究竟要使用哪一个.
在我看来,上面的代码不应该工作,因为编译器应该混淆.但是,当我尝试它时,它的工作原理.
所以..有没有人知道更多关于此的背景信息？
在关于C++的书籍中,当我们在C++中使用模板时,为什么我们会教我们使用函数重载？
展示模板的有效(和正确)使用不是更好吗？与大多数C++书籍中教授函数重载的地方相反？
或者,是否有充分的理由使用一个而不是另一个？
我对C++的这种行为感到困惑:
struct A {
virtual void print() const { printf("a\n"); }
};
struct B : public A {
virtual void print() const { printf("b\n"); }
};
struct C {
operator B() { return B(); }
};
void print(const A& a) {
a.print();
}
int main() {
C c;
print(c);
}
那么,测验是,程序的输出是什么 - a或b？嗯,答案是答案.但为什么？
我试图理解为什么下面的代码不能编译,显然该解决方案依赖于在派生类中明确声明对method_A的依赖.请参考以下代码:
class Base
{
public:
void method_A(int param, int param2)
{
std::cout << "Base call A" << std::endl;
}
};
//does not compile
class Derived : public Base
{
public:
void method_A(int param)
{
std::cout << "Derived call A" << std::endl;
}
};
//compiles
class Derived2 : public Base
{
public:
using Base::method_A; //compile
void method_A(int param)
{
std::cout << "Derived call A" << std::endl;
}
};
int main ()
{
Derived myDerived;
myDerived.method_A(1);
myDerived.method_A(1,2);
Derived2 myDerived2;
myDerived2.method_A(1);
myDerived2.method_A(1,2);
return …