按返回类型重载函数？

Question

为什么更主流的静态类型语言不支持按返回类型重载函数/方法？ 我想不出有什么可以做到的。 它看起来并不比支持参数类型重载有用或合理。 怎么人气这么低？

Answer 1

与其他人所说的相反，返回类型重载是是可能的，并且是由一些现代语言完成的。 通常的反对意见是，在这样的代码中，

int func();
string func();
int main() { func(); }

您无法判断正在调用哪个 func() 。 这可以通过以下几种方式解决：

1. 采用可预测的方法来确定在这种情况下调用哪个函数。
2. 每当出现这种情况时，就会出现编译时错误。 然而，有一个允许程序员消除歧义的语法，例如 int main() { (string)func(); }。
3. 不要有副作用。 如果没有副作用并且从不使用函数的返回值，那么编译器可以避免首先调用该函数。

我经常 (ab) 使用重载的两种语言返回类型：Perl 和 Haskell。 让我描述一下他们的工作。

在Perl中，标量和列表上下文（以及其他上下文，但我们假设有两个）之间存在根本区别。 Perl 中的每个内置函数都可以执行不同的操作，具体取决于调用它的上下文。 例如，join 运算符强制列表上下文（在被连接的事物上），而​​ scalar 运算符强制标量上下文，因此比较：

print join " ", localtime(); # printed "58 11 2 14 0 109 3 13 0" for me right now
print scalar localtime(); # printed "Wed Jan 14 02:12:44 2009" for me right now.

Perl 中的每个运算符都在标量上下文中执行某些操作以及列表上下文中的某些内容，它们可能不同，如图所示。 （这不仅仅适用于像localtime这样的随机运算符。如果您在列表上下文中使用数组@a，它会返回该数组，而在标量上下文中，它会返回例如，print @a 打印出元素，而 print 0+@a 则打印大小。）此外，每个运算符都可以强制< /em> 上下文，例如加法 + 强制标量上下文。 man perlfunc 中的每个条目都记录了这一点。 例如，以下是 glob EXPR 条目的一部分：

在列表上下文中，返回一个（可能是
空）文件名扩展列表
EXPR 的值如标准
Unix shell /bin/csh 就可以了。 在
标量上下文，glob 迭代
这样的文件名扩展，返回
当列表耗尽时 undef。

现在，列表和标量上下文之间的关系是什么？ 嗯，man perlfunc 说

请记住以下重要规则：
没有相关的规则
列表中表达式的行为
其标量行为的上下文
上下文，反之亦然。 它可能会做
两个完全不同的事情。 每个
运算符和函数决定哪个
这是最有价值的
适合以标量返回
语境。 一些运算符返回
列表的长度
在列表上下文中返回。 一些
运算符返回第一个值
列表。 一些运算符返回
列表中的最后一个值。 一些
运算符返回成功​​的计数
运营。 一般来说，他们做什么
你想要的，除非你想要一致性。

所以这不是一个简单的问题，只有一个函数，然后在最后进行简单的转换。 事实上，出于这个原因，我选择了 localtime 示例。

不仅仅是内置程序具有这种行为。 任何用户都可以使用 wantarray 定义这样的函数，它允许您区分列表、标量和 void 上下文。 因此，例如，如果您在 void 上下文中被调用，您可以决定不执行任何操作。

现在，您可能会抱怨这不是true返回值重载，因为您只有一个函数，该函数被告知调用它的上下文，然后对该信息进行操作。 然而，这显然是等价的（类似于 Perl 不允许通常的字面重载，但函数只能检查其参数）。 而且，它很好地解决了本回复开头提到的模棱两可的情况。 Perl 不会抱怨它不知道调用哪个方法；而是抱怨它不知道调用哪个方法。 它只是调用它。 它所要做的就是弄清楚函数被调用的上下文，这总是可能的：（

sub func {
    if( not defined wantarray ) {
        print "void\n";
    } elsif( wantarray ) {
        print "list\n";
    } else {
        print "scalar\n";
    }
}

func(); # prints "void"
() = func(); # prints "list"
0+func(); # prints "scalar"

注意：当我指的是函数时，我有时可能会说 Perl 运算符。这对于本次讨论来说并不重要。）

Haskell 采用另一种方法，即不产生副作用。 它还具有强大的类型系统，因此您可以编写如下代码：

main = do n <- readLn
          print (sqrt n) -- note that this is aligned below the n, if you care to run this

该代码从标准输入读取浮点数，并打印其平方根。 但这有什么令人惊讶的呢？ 那么，readLn 的类型是 readLn :: Read a => IO a。 这意味着对于任何可以 Read 的类型（正式来说，是 Read 类型类的每个实例），readLn可以阅读。 Haskell 如何知道我想读取浮点数？ 那么，sqrt 的类型是 sqrt :: Floating a => 一个-> a，这本质上意味着 sqrt 只能接受浮点数作为输入，因此 Haskell 推断出了我想要的。

当 Haskell 无法推断我想要什么时会发生什么？ 嗯，有几种可能性。 如果我根本不使用返回值，Haskell 一开始就不会调用该函数。 但是，如果我确实使用返回值，那么 Haskell 会抱怨它无法推断类型：

main = do n <- readLn
          print n
-- this program results in a compile-time error "Unresolved top-level overloading"

我可以通过指定我想要的类型来解决歧义：

main = do n <- readLn
          print (n::Int)
-- this compiles (and does what I want)

无论如何，整个讨论的含义是通过返回值进行重载是可能的并且已经完成，这回答了您的部分问题。

你问题的另一部分是为什么更多的语言不这样做。 我会让其他人来回答这个问题。 然而，有几点评论：主要原因可能是这里产生混淆的机会确实比按参数类型重载更大。 您还可以查看各个语言的基本原理：

Ada ：“看起来最简单的重载解析规则是使用所有内容 - 来自尽可能广泛的上下文的所有信息 - 来解析重载引用。这个规则可能很简单，但没有帮助。它要求人类读者扫描任意大的文本片段，并做出任意复杂的推论（例如上面的（g）），我们认为更好的规则是明确人类读者或编译器必须执行的任务，并且使该任务如下：对人类读者来说尽可能自然。”

C++（Bjarne Stroustrup 的“C++ 编程语言”第 7.4.1 小节）：“在重载解析中不考虑返回类型。原因是保持单个运算符或函数调用的解析与上下文无关。考虑：

float sqrt(float);
double sqrt(double);

void f(double da, float fla)
{
    float fl = sqrt(da);     // call sqrt(double)
    double d = sqrt(da); // call sqrt(double)
    fl = sqrt(fla);            // call sqrt(float)
    d = sqrt(fla);             // call sqrt(float)
}

如果返回类型是考虑到这一点，将不再可能单独查看 sqrt() 的调用并确定调用了哪个函数。” （请注意，为了比较，在 Haskell 中没有隐式转换。）

Java (Java 语言规范 9.4.1): "其中一个继承方法必须是可替换所有其他继承方法的返回类型，或者否则会发生编译时错误。” （是的，我知道这并没有给出一个基本原理。我确信 Gosling 在“Java 编程语言”中给出了基本原理。也许有人有一份副本？我敢打赌这本质上是“最小惊喜原则”。 ）然而，关于 Java 的一个有趣的事实是：JVM允许通过返回值进行重载！ 例如，它在 Scala< 中使用/a>，并且可以访问 直接通过 Java 以及通过内部操作。

附言。 最后一点，实际上可以通过 C++ 中的返回值通过技巧进行重载。 证人：

struct func {
    operator string() { return "1";}
    operator int() { return 2; }
};

int main( ) {
    int x    = func(); // calls int version
    string y = func(); // calls string version
    double d = func(); // calls int version
    cout << func() << endl; // calls int version
    func(); // calls neither
}

Answer 2

如果函数由返回类型重载并且您有这两个重载，

int func();
string func();

那么编译器在看到这样的调用时无法确定要调用这两个函数中的哪一个。

void main() 
{
    func();
}

因此，语言设计者通常不允许返回值重载。

然而，某些语言（例如 MSIL）允许按返回类型进行重载。 当然，他们也面临上述困难，但他们有解决方法，您必须查阅他们的文档。

Answer 3

在这样的语言中，您将如何解决以下问题：

f(g(x))

如果 f 重载了 void f(int) 和 void f(string) 和 < code>g 重载了 int g(int) 和 string g(int)？ 你需要某种消歧器。

我认为，在您可能需要此功能的情况下，为该函数选择一个新名称会更好。

Answer 4

要窃取 C++ 特定的另一个非常相似的问题的答案（欺骗？）：

---

函数返回类型在重载解析中不起作用，仅仅是因为 Stroustrup（我假设有其他 C++ 架构师的输入）希望重载解析“上下文无关”。 请参阅《C++ 编程语言，第三版》中的 7.4.1 -“重载和返回类型”。

原因是保持单个运算符或函数调用的解析与上下文无关。

他们希望它仅基于重载的调用方式，而不是结果的使用方式（如果使用的话）。 事实上，许多函数在不使用结果的情况下被调用，或者结果将被用作更大表达式的一部分。 当他们决定这一点时，我确信发挥作用的一个因素是，如果返回类型是解析的一部分，则会有许多对重载函数的调用，这些函数需要使用复杂的规则来解析，或者必须让编译器抛出调用不明确的错误。

而且，上帝知道，C++ 重载解析就其现状来说已经足够复杂了……

Answer 5

在 haskell 中，即使它没有函数重载，也是可能的。 Haskell 使用类型类。 在程序中你可以看到：

class Example a where
    example :: Integer -> a

instance Example Integer where  -- example is now implemented for Integer
    example :: Integer -> Integer
    example i = i * 10

函数重载本身并不那么流行。 我见过的大多数语言是 C++，也许是 java 和/或 C#。 在所有动态语言中，它都是以下内容的简写：

define example:i
  ↑i type route:
    Integer = [↑i & 0xff]
    String = [↑i upper]


def example(i):
    if isinstance(i, int):
        return i & 0xff
    elif isinstance(i, str):
        return i.upper()

因此，它没有多大意义。 大多数人不感兴趣语言是否可以帮助你在使用它的地方放下一行。

模式匹配有点类似于函数重载，我想有时工作原理也类似。 但它并不常见，因为它只对少数程序有用，并且在大多数语言上实现起来很棘手。

您会看到，还有无数其他更好、更易于实现的功能可以实现到该语言中，包括：

• 动态类型
• 对列表、字典和 unicode 字符串的内部支持
• 优化（JIT、类型推断、编译）
• 集成部署工具
• 库支持
• 社区支持和收集丰富
• 的标准库
• 良好的语法
• 读取eval打印循环
• 支持反射编程

Answer 6

好的答案！ A.Rex 的回答尤其非常详细且具有启发性。 正如他指出的，C++ 在编译 lhs = func(); 时确实会考虑用户提供的类型转换运算符（其中 func 实际上是结构体的名称） ）。 我的解决方法有点不同 - 不是更好，只是不同（尽管它基于相同的基本思想）。

虽然我想要写...

template <typename T> inline T func() { abort(); return T(); }

template <> inline int func()
{ <<special code for int>> }

template <> inline double func()
{ <<special code for double>> }

.. etc, then ..

int x = func(); // ambiguous!
int x = func<int>(); // *also* ambiguous!?  you're just being difficult, g++!

我最终得到了一个使用参数化结构的解决方案（T = 返回类型）：

template <typename T>
struct func
{
    operator T()
    { abort(); return T(); } 
};

// explicit specializations for supported types
// (any code that includes this header can add more!)

template <> inline
func<int>::operator int()
{ <<special code for int>> }

template <> inline
func<double>::operator double()
{ <<special code for double>> }

.. etc, then ..

int x = func<int>(); // this is OK!
double d = func<double>(); // also OK :)

该解决方案的一个好处是包含这些模板定义的任何代码可以为更多类型添加更多专业化。 您还可以根据需要对结构进行部分特化。 例如，如果您想要对指针类型进行特殊处理：

template <typename T>
struct func<T*>
{
    operator T*()
    { <<special handling for T*>> } 
};

作为否定，您不能使用我的解决方案编写 int x = func(); 。 您必须编写int x = func();。 您必须明确说明返回类型是什么，而不是要求编译器通过查看类型转换运算符来弄清楚它。 我想说，“我的”解决方案和 A.Rex 的解决方案都属于

Answer 7

如果你想重载具有不同返回类型的方法，只需添加一个带有默认值的虚拟参数即可允许重载执行，但不要忘记参数类型应该不同，以便重载逻辑接下来的工作是delphi 上的一个例子：

type    
    myclass = class
    public
      function Funct1(dummy: string = EmptyStr): String; overload;
      function Funct1(dummy: Integer = -1): Integer; overload;
    end;

像这样使用它

procedure tester;
var yourobject : myclass;
  iValue: integer;
  sValue: string;
begin
  yourobject:= myclass.create;
  iValue:= yourobject.Funct1(); //this will call the func with integer result
  sValue:= yourobject.Funct1(); //this will call the func with string result
end;

Answer 8

如前所述 - 仅返回类型不同的函数的模糊调用会引入歧义。
歧义会导致有缺陷的代码。
必须避免有缺陷的代码。

试图模糊性所带来的复杂性表明这不是一个好的破解方法。
除了智力练习之外 - 为什么不使用带有参考参数的程序。

procedure(reference string){};
procedure(reference int){};
string blah;
procedure(blah)

Answer 9

如果您以稍微不同的方式看待它，那么这种重载功能并不难管理。 考虑以下情况，

public Integer | String f(int choice){
if(choice==1){
return new string();
}else{
return new Integer();
}}

如果一种语言确实返回重载，它将允许参数重载，但不允许重复。
这将解决以下问题：

main (){
f(x)
}

因为只有一个 f(int choice) 可供选择。

Answer 10

在 .NET 中，有时我们使用一个参数来指示通用结果所需的输出，然后进行转换以获得我们期望的结果。

C#

public enum FooReturnType{
        IntType,
        StringType,
        WeaType
    }

    class Wea { 
        public override string ToString()
        {
            return "Wea class";
        }
    }

    public static object Foo(FooReturnType type){
        object result = null;
        if (type == FooReturnType.IntType) 
        {
            /*Int related actions*/
            result = 1;
        }
        else if (type == FooReturnType.StringType)
        {
            /*String related actions*/
            result = "Some important text";
        }
        else if (type == FooReturnType.WeaType)
        {
            /*Wea related actions*/
            result = new Wea();
        }
        return result;
    }

    static void Main(string[] args)
    {
        Console.WriteLine("Expecting Int from Foo: " + Foo(FooReturnType.IntType));
        Console.WriteLine("Expecting String from Foo: " + Foo(FooReturnType.StringType));
        Console.WriteLine("Expecting Wea from Foo: " + Foo(FooReturnType.WeaType));
        Console.Read();
    }

也许这个例子也有帮助：

C++

    #include <iostream>

enum class FooReturnType{ //Only C++11
    IntType,
    StringType,
    WeaType
}_FooReturnType;

class Wea{
public:
    const char* ToString(){
        return "Wea class";
    }
};

void* Foo(FooReturnType type){
    void* result = 0;
    if (type == FooReturnType::IntType) //Only C++11
    {
        /*Int related actions*/
        result = (void*)1;
    }
    else if (type == FooReturnType::StringType) //Only C++11
    {
        /*String related actions*/
        result = (void*)"Some important text";
    }
    else if (type == FooReturnType::WeaType) //Only C++11
    {
        /*Wea related actions*/
        result = (void*)new Wea();
    }
    return result;
}

int main(int argc, char* argv[])
{
    int intReturn = (int)Foo(FooReturnType::IntType);
    const char* stringReturn = (const char*)Foo(FooReturnType::StringType);
    Wea *someWea = static_cast<Wea*>(Foo(FooReturnType::WeaType));
    std::cout << "Expecting Int from Foo: " << intReturn << std::endl;
    std::cout << "Expecting String from Foo: " << stringReturn << std::endl;
    std::cout << "Expecting Wea from Foo: " << someWea->ToString() << std::endl;
    delete someWea; // Don't leak oil!
    return 0;
}

Answer 11

根据记录，Octave 根据返回元素是标量还是数组允许不同的结果。

x = min ([1, 3, 0, 2, 0])
   ⇒  x = 0

[x, ix] = min ([1, 3, 0, 2, 0])
   ⇒  x = 0
      ix = 3 (item index)

还请参阅 奇异值分解 。

Answer 12

这对于 C++ 来说略有不同； 不知道直接按返回类型算不算重载。 它更像是一种以以下方式起作用的模板专业化。

util.h

#ifndef UTIL_H
#define UTIL_H

#include <string>
#include <sstream>
#include <algorithm>

class util {
public: 
    static int      convertToInt( const std::string& str );
    static unsigned convertToUnsigned( const std::string& str );
    static float    convertToFloat( const std::string& str );
    static double   convertToDouble( const std::string& str );

private:
    util();
    util( const util& c );
    util& operator=( const util& c );

    template<typename T>
    static bool stringToValue( const std::string& str, T* pVal, unsigned numValues );

    template<typename T>
    static T getValue( const std::string& str, std::size_t& remainder );
};

#include "util.inl"

#endif UTIL_H

util.inl

template<typename T>
static bool util::stringToValue( const std::string& str, T* pValue, unsigned numValues ) {
    int numCommas = std::count(str.begin(), str.end(), ',');
    if (numCommas != numValues - 1) {
        return false;
    }

    std::size_t remainder;
    pValue[0] = getValue<T>(str, remainder);

    if (numValues == 1) {
        if (str.size() != remainder) {
            return false;
        }
    }
    else {
        std::size_t offset = remainder;
        if (str.at(offset) != ',') {
            return false;
        }

        unsigned lastIdx = numValues - 1;
        for (unsigned u = 1; u < numValues; ++u) {
            pValue[u] = getValue<T>(str.substr(++offset), remainder);
            offset += remainder;
            if ((u < lastIdx && str.at(offset) != ',') ||
                (u == lastIdx && offset != str.size()))
            {
                return false;
            }
        }
    }
    return true;    
}

util.cpp

#include "util.h"

template<>
int util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stoi( str, &remainder );
} 

template<>
unsigned util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stoul( str, &remainder );
}

template<>
float util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stof( str, &remainder );
}     

template<>   
double util::getValue( const std::string& str, std::size_t& remainder ) {
    return std::stod( str, &remainder );
}

int util::convertToInt( const std::string& str ) {
    int i = 0;
    if ( !stringToValue( str, &i, 1 ) ) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to int";
        throw strStream.str();
    }
    return i;
}

unsigned util::convertToUnsigned( const std::string& str ) {
    unsigned u = 0;
    if ( !stringToValue( str, &u, 1 ) ) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to unsigned";
        throw strStream.str();
    }
    return u;
}     

float util::convertToFloat(const std::string& str) {
    float f = 0;
    if (!stringToValue(str, &f, 1)) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to float";
        throw strStream.str();
    }
    return f;
}

double util::convertToDouble(const std::string& str) {
    float d = 0;
    if (!stringToValue(str, &d, 1)) {
        std::ostringstream strStream;
        strStream << __FUNCTION__ << " Bad conversion of [" << str << "] to double";
        throw strStream.str();
    }
    return d;
}

这个示例并不完全使用返回类型的函数重载解析，但是这个 C++ 非对象类是使用模板专门化通过私有静态方法的返回类型来模拟函数重载解析。

每个 convertToType 函数都调用函数模板 stringToValue()，如果您查看此函数模板的实现细节或算法，它会调用 getValue;( param, param ) 返回类型 T 并将其存储到传递给 stringToValue() 的 T* 中 函数模板作为其参数之一。

除了这样的事情之外； C++ 并没有真正具有通过返回类型进行函数重载解析的机制。 可能还有其他我不知道的构造或机制可以通过返回类型模拟解析。

Answer 13

我认为这是现代 C++ 定义中的一个差距……为什么？

int func();
double func();

// example 1. → defined
int i = func();

// example 2. → defined
double d = func();

// example 3. → NOT defined. error
void main() 
{
    func();
}

为什么 C++ 编译器不能在示例“3”中抛出错误
接受示例“1+2”中的代码？

Answer 14

大多数静态语言现在也支持泛型，这可以解决您的问题。 如前所述，如果没有参数差异，就无法知道要调用哪一个。 因此，如果您想这样做，只需使用泛型即可。