标签: overload-resolution

我们正在迁移到Sun Studio 12.1并使用新的编译器[CC:Sun C++ 5.10 SunOS_sparc 2009/06/03].编译使用早期版本的Sun编译器[CC:Sun WorkShop 6 update 2 C++ 5.3 2001/05/15]编译好的代码时,我遇到了编译错误.

这是我得到的编译错误.

"Sample.cc":错误:无法找到main()中所需的LoopThrough(int [2])匹配项.1检测到错误.***错误代码1.

码:

#include <iostream> 

#define PRINT_TRACE(STR) \
std::cout << __FILE__ << ":" << __LINE__ << ":" << STR << "\n";

template<size_t SZ>
void LoopThrough(const int(&Item)[SZ])
{
    PRINT_TRACE("Specialized version");
    for (size_t index = 0; index < SZ; ++index)
    {
        std::cout << Item[index] << "\n";
    }
}


/*     
    template<typename Type, size_t SZ>
    void LoopThrough(const Type(&Item)[SZ])
    {
        PRINT_TRACE("Generic version");        
    }
 */  



int main()
{
    {
       int arr[] …

给定类型,名称和签名,如何使用7.4的C#规则(7.4是C#语言规范中的章节编号)对名称和签名签名的成员进行成员查找(或至少部分)其中......假设我可以在运行时使用完全匹配,无需转换/转换？我需要得到一个MethodInfo/ PropertyInfo/ ...因为那时我必须使用反射(更确切地说,我正在尝试构建一个Expression.ForEach构建器(一个能够创建表示树的表达式代表一个foreach语句的工厂),并且是使用C#完美像素foreach我必须能够进行鸭子输入并搜索GetEnumerator方法(在集合中),Current属性和MoveNext方法(在枚举器中),如8.8.4中所述)

问题(问题的一个例子)

class C1
{
    public int Current { get; set; }

    public object MoveNext()
    {
        return null;
    }
}

class C2 : C1
{
    public new long Current { get; set; }

    public new bool MoveNext()
    {
        return true;
    }
}

class C3 : C2
{
}

var m = …

不确定这是否特定于C#4+,但只是注意到了这一点.

考虑以下类:

class Base
{
  protected void Foo(object bar, DayOfWeek day)
  {
  }
}

class Program : Base
{
  protected void Foo(object bar, object baz)
  {
  }

  void Bar(DayOfWeek day)
  {
    Foo(new { day }, day);
  }
}

在调用Foo中Bar,做出决议Foo(object, object).

将其更改为:

class Base
{

}

class Program : Base
{
  protected void Foo(object bar, object baz)
  {
  }

  protected void Foo(object bar, DayOfWeek day)
  {
  }

  void Bar(DayOfWeek day)
  {
    Foo(new { day }, …

以下是一些重载函数.试着猜出那些被调用的功能.

program Project2;
    {$APPTYPE CONSOLE}

uses
  Types, SysUtils;

procedure Some(const Buf); overload;
  begin
    Writeln('const-typeless')
  end;

//procedure Some(var Buf); overload;
//  begin
//    Writeln('var-typeless')
//  end;

//procedure Some(Buf :TByteDynArray); overload;
//  begin
//    Writeln('Byte dynamic array');
//  end;

procedure Some(Buf :array of Byte); overload;
  begin
    Writeln('Byte open array');
  end;

procedure Some(Buf :TArray<Byte>); overload;
  begin
    Writeln('TBytes AKA byte generic array');
  end;

//procedure Some(Buf :TBytes); overload;
//  begin
//    Writeln('TBytes AKA byte generic array');
//  end;

var p: pointer;

begin
  try
    { TODO …

考虑这两个重载:

template <typename T> void foo(T &) {}
template <typename T> void foo(T &&) {}

它们可能含糊不清吗？

下面的代码用Clang 3.4编译,但是GCC 4.8失败了,它说过载(第一个带有T = int,第二个有T = int&)是不明确的.

int main()
{
    int n = 10;
    foo(n);
}

我意识到"绑定到引用"在重载分辨率方面是一个"完全匹配",所以我想这个问题归结为一个推论T = int/ T = int&优于另一个,或者它们是否同样好.

我有以下代码,可能看似令人费解,但来自真正的代码:

#include <iostream>
using namespace std;

template <class Hrm, class A>
void foo(Hrm& h, A& a)
{
  cout << "generic" << endl;
}

template <template <bool> class Hrg>
void foo(Hrg<false>& h, int& a)
{
  cout << "specialized int" << endl;
}

template <template <bool> class Hrg>
void foo(Hrg<true>& h, const int& a)
{
  cout << "specialized const-int" << endl;
}

template <bool W>
struct what;

template<> struct what<true> { };
template<> struct what<false> { };


int main() {
  what<true> wt; …

我试图了解以下情况下的重载决策规则:

template<typename T>
void f(const T& x) { 
    std::cout << __PRETTY_FUNCTION__ << std::endl; //-
}

template<typename T>
void f(T& x) { // <> Überladung Variante 2
    std::cout << __PRETTY_FUNCTION__ << std::endl; //-
}

int main()
{
    int e1 = 0;
    f(e1);

    const int e2 = 0;
    f(e2); 
}

输出是:

void f(T &) [T = int]
void f(const T &) [T = int]

正如我在第一次致电中所理解的那样,f(e1)导致了可行的功能

void f(const int&)
void f(int&)

从中选择第一个,因为不必删除const限定.

第二次调用f(e2)导致类型扣除/可行功能

void f(const int&); // T -> …

特定

[
    1,"test2"
    3,"test"
]
|> dict
// turn it into keyvaluepair sequence
|> Seq.map id

|> fun x -> x.ToDictionary<_,_,_>((fun x -> x.Key), fun x -> x.Value)

如果我没有明确使用<_,_,_>after ,则无法编译ToDictionary.
Intellisense工作正常,但编译失败并出现错误:基于此程序点之前的信息查找不确定类型的对象 因此,似乎Intellisense知道如何解决方法调用.

这似乎是一个线索

|> fun x -> x.ToDictionary<_,_>((fun x -> x.Key), fun x -> x.Value)

失败了

Type constraint mismatch.  
The type 'b -> 'c  is not compatible with type IEqualityComparer<'a>     
The type 'b -> 'c' is not compatible with the type 'IEqualityComparer<'a>'  
(using external F# …

那么,让我们从一个例子开始吧.假设我们有几种类型可以组合在一起,假设我们正在使用它__add__来实现它.不幸的是,由于我们无法控制的情况,一切都必须"可以为空",所以我们被迫在Optional任何地方使用.

from typing import Optional, List, overload
class Foo:
    value: int
    def __init__(self, value: int) -> None:
        self.value = value
    def __add__(self, other: 'Foo') -> 'Optional[Foo]':
        result = self.value - other.value
        if result > 42:
            return None
        else:
            return Foo(result)

class Bar:
    value: str
    def __init__(self, value: str) -> None:
        self.value = value
    def __add__(self, other: 'Bar') -> 'Optional[Bar]':
        if len(self.value) + len(other.value) > 42:
            return None
        else:
            return Bar(self.value + other.value)

class Baz:
    value: List[str] …

在N4659中16.3.3.1隐式转换序列说

10如果存在几个不同的转换序列，每个转换序列都将自变量转换为参数类型，则与参数关联的隐式转换序列被定义为唯一的转换序列，称为歧义转换序列。为了对16.3.3.2中所述的隐式转换序列进行排名，歧义转换序列被视为与其他任何用户定义的转换序列都没有区别的用户定义的转换序列[注意：此规则可防止函数变为非-viable，因为其参数之一的转换顺序不明确。]如果选择使用歧义转换顺序的函数作为最佳可行函数，则该调用将格式错误，因为该调用中参数之一的转换是模棱两可的。

（当前草案的相应部分为12.3.3.1）

该规则的预期目的是什么，以及引入的歧义转换序列的概念是什么？

文本中提供的注释指出，此规则的目的是“防止功能由于其参数之一的转换顺序不明确而变得不可行 ”。嗯...这实际上是指什么？可行功能的概念在文档的前面部分中定义。它根本不取决于转换的歧义性（每个参数的转换必须存在，但不必明确）。而且似乎没有提供可行的功能以某种方式在以后“变得不可行”的规定（既不是出于某种模棱两可，也不是因为其他原因）。列举了可行的功能，它们相互竞争，成为“最佳”如果有一个“获胜者”，则解决方案成功。在此过程中的任何时候，可行的功能都可能（或需要）变成不可行的功能。

上述段落中提供的示例不是很有启发性（即尚不清楚上述规则在该示例中扮演什么角色）。

这个简单的例子最初引发了这个问题

struct S
{
  operator int() const { return 0; };
  operator long() const { return 0; };
};

void foo(int) {}

int main()
{
  S s;
  foo(s);
}

让我们在这里机械地应用上述规则。foo是可行的功能。从参数类型S到参数类型有两个隐式转换序列int：S -> int和S -> long -> int。这意味着，根据上述规则，我们必须将它们“打包”成单个模糊的转换序列。然后我们得出结论，这foo是最好的可行功能。然后我们发现它使用了我们不明确的转换序列。因此，根据上述规则，代码格式错误。

这似乎没有任何意义。这里的自然期望是，S …