我认为这是现代c++定义中的一个GAP……为什么?

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”中的代码??

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

int func();
string func();

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

void main() 
{
    func();
}

由于这个原因，语言设计者通常不允许返回值重载。

然而，有些语言(如MSIL)允许按返回类型重载。当然，它们也面临上述困难，但它们有变通办法，为此您必须查阅它们的文档。

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

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

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

Cf也是奇异值分解。

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

如果你稍微换个角度来看，这个重载特性并不难管理。考虑以下几点:

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

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

main (){
f(x)
}

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

在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打印循环 对反射编程的支持