标签: ambiguity

考虑以下类和接口:

    public interface A { string Property { get; set; } }

    public interface B { string Property { get; set; } }

    public interface C : A, B { }

    public class MyClass : C
    {
        public string Property { get; set; }
    }

看起来很简单吧？现在考虑以下程序:

    static void Main(string[] args)
    {
        MyClass myClass = new MyClass();
        myClass.Property = "Test";

        A aTest = myClass;
        B bTest = myClass;
        C cTest = myClass;

        aTest.Property = "aTest";
        System.Console.WriteLine(aTest.Property);
        bTest.Property = "bTest";
        System.Console.WriteLine(bTest.Property);
        cTest.Property …

我的库使用了几个嵌套的命名空间,如下所示:

Library name
    Class name 1
    Class name 2
    Class name 3
    [...]
    Utilities
        Class name 1
            [...]
        Class name 2
            [...]
        Class name 3
            [...]
        [...]

"Utilities"命名空间包含对每个类的有用扩展,这些扩展不保证包含在实际类本身中.

"库名"的命名空间是必要的,因为它避免了与其他库的广泛的冲突,在"工具"命名空间是必要的,以避免歧义,从出现的类型,像这样的事情,而且里面的"类名"的命名空间避免之间的名称冲突为类似的类编写的实用程序

尽管如此,它在实践中仍然是一个巨大的麻烦.举例来说,例如:

MyLibrary::MyContainer<int> Numbers = MyLibrary::Utilities::MyContainer::Insert(OtherContainer, 123, 456);
// Oh God, my eyes...

这让我觉得我做错了.有没有更简单的方法来保持组织,直观和明确的事情？

我正在寻找专门用于处理歧义的算法或数据结构.

在我特定的当前感兴趣的领域,我正在研究对自然语言的模糊解析,但我认为在计算中必须有许多领域,其中模糊性起作用.

我可以找到很多关于试图避免模棱两可的内容,但很少关于如何接受歧义和分析模棱两可的数据.

假设解析器生成这些替代令牌流或解释:

• A B1 C
• A B2 C
• A B3 B4 C

可以看出,流的某些部分在解释(A... B)之间共享,而其他部分则分支到其他解释中,并且经常与主流会合.

当然,可能会有更多的解释,替代方案的嵌套以及没有主流的解释.

这显然是某种带节点的图形.我不知道它是否有确定的名称.

是否存在我可以研究的现有算法或数据结构,旨在处理这种模糊的图形？

我有一些代码暗示类型转换，尽管有转换方法，但它不会编译...

class A
{
public:
    A(void) :_m(0) { }
    A(int val) : _m(val) {}
private:
    int _m;
};
class B
{
public:
    B(void) : _m(0) {}
    B(int val) : _m(val) {}
    B(const A&);
    // there is a direct conversion operator here
    operator A(void) const { return A(_m); }
    operator int(void) const { return _m; }
private:
    int _m;
};
int main()
{
    B b;
    A a = (A)b; // error C2440 here
}

这是错误消息：

error C2440: 'type cast': cannot convert …

假设我有:

public class OuterClass() {

  public class InnerClass {
    public void someMethod(int x) {
      someMethod(x);
    }
  }

  public void someMethod(int x) {
    System.out.println(x);
  }
}

如何解决someMethod()外部类和someMethod()内部类之间的歧义？

更新!

请参阅我对以下C#规范的一部分的剖析; 我想我必须遗漏一些东西,因为对我而言,我在这个问题中描述的行为实际上违反了规范.

更新2!

好的,经过进一步的反思,并根据一些评论,我想我现在明白发生了什么.规范中的"源类型"一词指的是从中转换的类型- 即,Type2在我下面的例子中 - 这只是意味着编译器能够将候选缩小到两个定义的运算符(因为Type2它是源类型)对彼此而言).但是,它无法进一步缩小选择范围.所以规范中的关键词(适用于这个问题)是"源类型",我之前误解(我认为)是指"声明类型".

原始问题

说我定义了这些类型:

class Type0
{
    public string Value { get; private set; }

    public Type0(string value)
    {
        Value = value;
    }
}

class Type1 : Type0
{
    public Type1(string value) : base(value) { }

    public static implicit operator Type1(Type2 other)
    {
        return new Type1("Converted using Type1's operator.");
    }
}

class Type2 : Type0
{
    public Type2(string value) : base(value) { }

    public …

在成功学习RDFa Lite之后,我正在教自己RDFa Core 1.1.开门见山,我不明白两两件事:之间的区别property和rel,和之间的差异resource和about.

请用比规范更简单的术语向我解释:)

我遇到某个任务的问题,这是一个练习,而不是一个真正的程序.任务是定义结构D的复制构造函数,其行为方式与compliler生成的复制构造函数完全相同.

class Ob{
};

struct A {
Ob a;
};

struct B : A {
Ob b;
};

struct C : A, B {
Ob c;
};

struct D : C, A {
Ob d;
};

正如您所看到的,结构A在D结构中间接导出几次导致复制构造函数定义模糊不清的原因如下:

D(const D& _d) : C(_d), A(_d), d(_d.d) {}

我的问题是如何正确定义该复制构造函数？没有上面提到的定义的代码编译,所以它似乎应该是可能的.

MinGW 4.8.1错误消息:

zad3.cpp:12:8: warning: direct base 'A' inaccessible in 'C' due to ambiguity     [enabled by default]
 struct C : A, B {
        ^
zad3.cpp:16:8: warning: direct base 'A' inaccessible in 'D' due to ambiguity …

有人能解释一下这里的含糊之处吗？

template <typename...> struct thing;

template <typename... Rest>
struct thing<int&, Rest&...> {
    thing(int&, Rest&...) { }
};

template <typename First, typename... Rest>
struct thing<First&, Rest&...> {
    thing(First&, Rest&...) { }
};

int main() {
    int myint;
    char mychar;
    thing<int&, char&> t(myint, mychar);
}

常规
使用 Unity 引擎开发游戏模组。

我尝试使用以下代码附加到activeSceneChanged事件的问题：

SceneManager.activeSceneChanged += OnSceneChanged;