标签: overloading

你能在PowerShell中重载函数吗？

我希望我的函数接受字符串,数组或某些开关.

我想要的一个例子:

• Backup-UsersData singleUser
• Backup-UsersData @('Alice','Bob','Joe')
• Backup-UsersData -all

我升级了我的Java EE Web应用程序以使用更新的PrimeFaces版本,突然在PrimeFaces commandlink的action属性中调用重载的bean方法不再起作用.我试图使用JSF默认的commandlink来测试它,这个也没用.

方法签名如下:

public void updateA(B b);
public void updateA(A a);

它总是试图将A转换为B.

更好奇的是,它在升级之前如何运作？

MSDN 文档包含有关隐式转换的部分:

var s = $"hello, {name}";
System.IFormattable s = $"Hello, {name}";
System.FormattableString s = $"Hello, {name}";

从第一个字符串开始,原始类型的插值字符串就是string.好的,我可以理解它,但是......我意识到字符串没有实现IFormattable.所以它看起来像编译器的一些魔法类似于它对lambdas的作用.

现在猜猜这段代码的输出:

void Main()
{
    PrintMe("Hello World");
    PrintMe($"{ "Hello World"}");
}

void PrintMe(object message)
{
    Console.WriteLine("I am a " + message.GetType().FullName);
}

//void PrintMe(string message)
//{
//  Console.WriteLine("I am a string " + message.GetType().FullName);
//}

void PrintMe(IFormattable message)
{
    Console.WriteLine("I am a " + message.GetType().FullName);
}

暗示:

我是System.String
我是System.Runtime.CompilerServices.FormattableStringFactory + ConcreteFormattableString

如果您从第二种方法中删除评论,您将获得:

我是一个字符串System.String
我是一个字符串System.String

好的
我可能不太了解重载分辨率,但是C#规范的 14.4.2 …

说我有这个构造函数:

/// <summary>
/// Example comment.
/// </summary>
public SftpConnection(string host, string username, 
    string password, int port) {...}

有这些重载:

public SftpConnection(string host, string username, string password) 
    : this(host, username, password, 22) { }

public SftpConnection(string host, string username, int port) 
    : this(host, username, "", port) { }

public SftpConnection(string host, string username) 
    : this(host, username, "", 22) { }

而在现实中,XML注释是相当大的,有param,example和exception元素等等.

有没有办法在重载中添加一个特殊的XML注释单行,这样他们就可以使用完全相同的注释,这样我就不需要复制粘贴整个巨大的原始注释了？

我想的是:<use cref="SftpConnection(string,string,string,int)" />当然不起作用.

我知道这个include元素,但我得到的印象是它从XML文件读取注释,我不想要 - 我希望注释仍然在代码中可见,但只有一次.

谢谢 …

声明如下的内容

void foo(int x)        { std::cout << "foo(int)"         << std::endl; }
void foo(const int &x) { std::cout << "foo(const int &)" << std::endl; }

有意义吗？调用者如何能够区分它们？我试过了

foo(9);  // Compiler complains ambiguous call.

int x = 9;
foo(x);  // Also ambiguous.

const int &y = x;
foo(y);  // Also ambiguous.

（本示例中未使用#include，在带有g ++，选项-O0 -g3 -Wall -c -fmessage-length = 0的MacOS10.14，Eclipse IDE上编译）

假设此变量声明：

int (*fun)(int);

无法使用“ std :: toupper和std :: tolower的无效重载”进行编译。

fun = (1 ? std::toupper : std::tolower);   // ERROR, invalid overload

这样编译就可以了：

if (1) {
    fun = std::toupper;   // OK
}
else {
    fun = std::tolower;   // OK
}

我有一个快速而直接的问题:

我有这个简单的课程:

public class A
{
    public void m(Object o)
    {
      System.out.println("m with Object called");
    }

    public void m(Number n)
    {
       System.out.println("m with Number called");
    }
    public static void main(String[] args)
    {
       A a = new A();
       // why will m(Number) be called?
       a.m(null);
    }
}

更新:实际上是实际调用Number的方法.对此感到抱歉.

如果我调用am(null),则使用Number参数调用方法.

我的问题是:这是为什么？这个指定的java语言规范在哪里？

我正在编写一个方法,它应该接受两个类型之一的对象作为其参数,这两个类型不共享除Object之外的父类型.例如,类型是梦想和大蒜.你都可以做dreams.crush()和garlic.crush().我想要一个方法utterlyDestroy(parameter),它将接受Dreams和Garlic作为它的参数.

utterlyDestroy(parameter) {
    parameter.crush()
}

Garlic和dream都是某个库的一部分,所以让它们实现一个接口ICrushable(这样我可以写utterlyDestroy(ICrushable parameter))不是一个选项.

我的方法体很长,所以重载就意味着重复代码.丑陋.我相信我可以使用反射并做一些类黑客攻击.丑陋.

我尝试使用泛型,但显然我不能写类似的东西

utterlyDestroy(<T instanceof Dreams || T instanceof Garlic> parameter)

是否有可能将大蒜强加给梦想？

utterlyDestroy(Object parameter) {
    ((Dreams)parameter).crush()
}

但这仍然是丑陋的.我的其他选择是什么？处理这种情况的首选方法是什么？

如何选择正确的error()成员函数？我需要以某种方式施展吗？

using namespace std;

struct test
{
   int error();
   void error(int x);
   int fun();
};

int main() {
   auto f1 = &test::error; // how to pick the correct function?
   auto f2 = &test::fun; // works
}

C++ 标准提到了这一点std::size_t：

该类型size_t是实现定义的无符号整数类型，它足够大以包含任何对象的字节大小 ([expr.sizeof])。

现在我的问题是，这种类型是否与其他 unsigned int 类型不同。我的意思是，我是否应该能够有这样的重载：

void myfunc(std::uint16_t) {}
void myfunc(std::uint32_t) {}
void myfunc(std::uint64_t) {}
void myfunc(std::size_t) {}

因为如果它是一个不同的类型，我应该能够拥有这些重载，而如果不是，我应该得到重新定义错误。我总是认为这std::size_t应该是一个不同的类型，但我目前收到重新定义错误，这意味着它不是（至少在 GCC 和 Clang 中）

我问这个问题的原因是我想知道我是否对不同的 unsigned int 大小重载了一个函数，我是否可以安全地假设其中一个将被调用std::size_t或不被调用。