标签: ambiguity

所以,这里有一些基本代码说明了我的问题:

#include <functional>

int func(int x) {
    return x;
}

int func(int x, int y) {
    return x + y;
}

int main() {
    std::ptr_fun<int, int>(func);
}

对于具有不同参数数量的函数,我们有2个重载.然后我尝试在仿函数中转换单个参数版本.当然,我遇到以下错误:

test.cc: In function 'int main()':
test.cc:13:29: error: call of overloaded 'ptr_fun()' is ambiguous
/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.2/include/g++-v4/bits/stl_function.h:437:5: note: candidates are: std::pointer_to_unary_function std::ptr_fun(_Result (*)(_Arg)) [with _Arg = int, _Result = int]
/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.2/include/g++-v4/bits/stl_function.h:463:5: note:                 std::pointer_to_binary_function std::ptr_fun(_Result (*)(_Arg1, _Arg2)) [with _Arg1 = int, _Arg2 = int, _Result = int]

我知道我可以投出func并完成它,但它让我想到为什么这是模棱两可的？这两个版本std::ptr_fun都没有模板定义中的默认参数,我已经明确地说过两个模板参数int …

我正在尝试为类似于以下内容的XML生成一个非常简单的XML模式:

<messages>
  <item>
    <important_tag></important_tag>
  </item>
  <item>
    <important_tag></important_tag>
    <tag2></tag2>
  </item>
  <item>
    <tag2></tag2>
    <tag3></tag3>
  </item>
</messages>

这个想法是<important_tag>具有特定的定义,它可能会也可能不会出现<item>.它也可能出现不止一次.此外,在<important_tag>我之前或之后可能还有其他标签,我无法提前命名.

我想给出一个具体的定义<important_tag>.例如,定义它必须包含的属性.我的意思是,如果 important_tag存在,它必须符合我的定义.任何其他标签不必符合任何定义.

我尝试使用以下方案:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="messages">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="item" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="item">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="important_tag" minOccurs="0"/>
        <xs:any minOccurs="0"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="important_tag">
    <xs:complexType>
      <xs:simpleContent>
        ... specific definitions for important_tag ...
      </xs:simpleContent>
    </xs:complexType>
  </xs:element>
</xs:schema>

这会导致错误,表明架构不明确.

确切的错误消息是:

cos-nonambig: '<xs:element ref="important_tag">' makes the content model non-deterministic against '<xs:any>'. Possible causes: name …

Observation: the codes pasted below were tested only with GCC 4.4.1, and I'm only interested in them working with GCC.

你好,

我偶然发现了一些我不理解的对象构造语句,而且直到今天我才注意到它引入的模糊性.我将解释如何重现它,并想知道是否有办法解决它(允许C++ 0x).在这里.

假设有一个类,其构造函数只接受一个参数,而这个参数的类型是另一个具有默认构造函数的类.例如:

struct ArgType {};

class Class
{
public:
    Class(ArgType arg);
};

如果我尝试Class在堆栈上构造一个类型的对象,我会产生歧义:

Class c(ArgType()); // is this an object construction or a forward declaration
                    // of a function "c" returning `Class` and taking a pointer
                    // to a function returning `ArgType` and taking no arguments
                    // as argument? (oh yeh, loli haets awkward syntax in …

以下是纯粹学术上发明的类层次结构.

struct X{
        void f1();
        void f2();
        void f3();
};

struct Y : private X{
        void f4();
};

struct Z : X{
};

struct D : Y, Z{
        using X::f2;
        using Z::X::f3;
};

int main(){}

我期望使用X :: f2的声明是模糊的,因为'X'是'D'的可模糊基础(可见性与X的可访问性).但是g ++(ideone.com)编译得很好.

我使用Online Comeau进行了检查,并且在预期使用X :: f2的声明时出错.但是,它也为使用Z :: X :: f3的声明提供了歧义.

那么预期的行为是什么？

编辑1:

请参考标准的相应部分.

编辑2:

我查看了VS 2010,它只对使用声明X :: f2提出异议.然而,它不是关于'X'的歧义(如gcc和Comeau的情况).这是关于"错误C2876:'X':并非所有重载都可以访问".

编辑3:

struct X{
    void f(){}
};

struct Y : X{
    struct trouble{
        void f(){}
    };

};

struct trouble : X{
};

struct letscheck : Y, …

考虑以下类和接口:

    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 …

考虑以下:

class A
{
private:
    A() {}
public:
    A(int x = 0) {}
};


int main()
{
    A a(1);
    return 0;
}

我有两个构造函数,一个是默认值,另一个是使用默认参数转换构造函数.当我尝试编译代码时,我预计会出现歧义错误,但编译器不会产生错误.

即使我没有创建实例A,它也不会产生歧义错误.

int main()
{
    return 0;
}

这是为什么？

我很确定以前曾经问过,但是我找不到正确的答案:

我试图消除以下示例代码段中的歧义:

{-# LANGUAGE MultiParamTypeClasses #-}

class FooBar a b where
    foo :: a -> a
    foo = id
    bar :: a -> a
    bar = foo        -- ERROR AT THIS LINE

我收到如下错误消息:

Ambiguous type variable `b0' in the constraint:
      (FooBar a b0) arising from a use of `foo'
    Probable fix: add a type signature that fixes these type variable(s)
    In the expression: foo
    In an equation for `bar': bar = foo

这是可以理解的.但请注意,我实际上无法遵循编译器的建议并修复有问题的类型变量:在其类型签名foo中不包含b类型变量.这也行不通:

    bar = (foo …

是什么意思,比较在二郎山功能与运营商=:=,==,<,>,=<,>=？我正在玩翻译,并得到了这些结果:

Eshell V5.9.2  (abort with ^G)
1> X = fun() -> {} end.
#Fun<erl_eval.20.82930912>
2> Y = fun() -> {} end.
#Fun<erl_eval.20.82930912>
3> 
3> {X == X, X =:= X}.
{true,true}
4> {X >= X, X =< X}.
{true,true}
5> {X > X, X < X}.
{false,false}
6> 
6> {X == Y, X =:= Y}.
{true,true}
7> {X >= Y, X =< Y}.
{true,true}
8> {X > Y, …

一段时间以来,我一直在努力解决这个设计问题.我将尽我所能来解释我正在尝试做什么以及我所看到的各种接近,我正在尝试什么以及为什么.

我在科学计算环境中工作,在那里我反复处理相同类型的对象.想象一个包含太阳系的星系,每个太阳系都包含行星系统,每个行星系统都包含卫星.为此,我将这种情况视为一种"有"的情况,因此我使用组合来让银河系进入其太阳系,并且每个太阳系都可以进入可以进入卫星的行星系统:每个类别是自己的阶级.

通常情况下,我正在处理的各种问题包含有关这些对象的不同类型的数据.而且,随着不同类型的数据变得可用,我可以使用我的对象做某些事情.所以,当我有数据类型1可供我使用时,我创建以下类

class GalaxyOne { /* … */ };
class SolarSystemOne { /* … */ };
class PlanetOne{ /* … */ };
class MoonOne{ /* … */ };

当我有数据类型2可供我使用时,我创建

class GalaxyTwo { /* … */ };
class SolarSystemTwo { /* … */ };
class PlanetTwo{ /* … */ };
class MoonTwo{ /* … */ };

每个类的复合方面通过使用容器变量来处理,例如包含指向所包含类的指针的向量.例如,在每个Galaxy类中都可以找到.

class GalaxyTwo{ /* … */
protected:
std::vector<SolarSystemTwo*> solarSystems;
/* … */
};

当我想将类组合成高阶类时,困难就出现了.

class GalaxyOneTwo: public GalaxyOne, public GalaxyTwo{
/* Additional methods */ …

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

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

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

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

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

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

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

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

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