标签: ambiguity

好的,这是避免歧义的最佳方法吗？

template <class T>
inline void swap(T &a, T &b)
{
    T c; c = a; a = b; b = c;
}
/* blah blah blah (inside of a function:) */
for (itv = vals.begin(); itv != vals.end(); ++itv)
{
    if (at < (*itv)) { swap(at, (*itv)); }
    if (at % (*itv) == 0) atadd = false;
}
/* blah blah blah */

使用交换调用也不起作用,因为它说无法解决它是否是"void swap(T&,T&)","void std :: swap(_Ty&,_ Ty&)"或......

顺便说一下,itv是一个vector <int> :: iterator.

谢谢.

如果之前已经问过这个问题,请原谅我,但是我试着搜索它并没有令人满意的结果.

我正在学习PHP(来自C++背景),并且遇到了以下歧义.以下两位代码完全相同:

class A
{
    public $myInteger;
    public function __get($name) 
    { 
        return $this->$name; 
    }
    public function __set($name, $value)
    {
        $this->$name = $value;
    }
}

和

class A
{
    public $myInteger;
    public function __get($name) 
    { 
        return $this->name; 
    }
    public function __set($name, $value)
    {
        $this->name = $value;
    }
}

也就是说,在类的方法$this->$name,并$this->name具有完全相同的功能.我发现这有点令人困惑,特别是考虑到如果你添加以下代码,

$myA = new A();
$myA->myInteger = 5;
$hereInt = $myA->myInteger;

echo "<p>" . $hereInt . "</p>";

它只有$在以前没有的情况下才有效myInteger.有人可以解释一下这背后的理由吗？

pass-by-reference函数通常如何区分pass-by-value函数？例如:

template <typename T>
void sort(std::vector<T>& source); // Sorts source.

// Versus...

template <typename T>
std::vector<T> sort(std::vector<T> source); // Returns a sorted copy of source.

这两个功能含糊不清; 其中一个必须重命名或完全删除.

如何避免这种情况？一种形式应该优先于另一种吗？或者是否有任何共同的命名准则来区分它们？

下面是单例类的代码

class single{
private:
    int i;
    single(int x): i(x){ 

    }
public:
    static single& getInstance(){
        static single s(10);
        return s;
    }

    void incPrint(){
        ++i;
        cout i  " ";
    }
};

现在相同的代码为2个不同的代码提供了两个不同的结果

single d1 = single::getInstance();
    d1.incPrint();
    d1.incPrint();

    single d2 = single::getInstance();
    d2.incPrint();
    d2.incPrint();

此代码生成输出:

11 12 11 12

而这段代码

    single & d1 = single::getInstance();
    d1.incPrint();
    d1.incPrint();

    single & d2 = single::getInstance();
    d2.incPrint();
    d2.incPrint();

产生结果

11 12 13 14

后者是所需的输出.由于设计问题或用户编码问题,这是异常吗？如何确保只获得第二个结果？

谢谢

我在重载operator + ia模板化类时遇到问题。假设我有

template<typename T>
struct point{

    //Ctors:
    point(){};
    point(T _x, T _y):x(_x),y(_y){};
    point(const point<T>& p):x(p.x),y(p.y){};

    template<typename T2>
    point(const point<T2>& p):x(static_cast<T>(p.x)),y(static_cast<T>(p.y)){};



   //Coordinates:
   T x;
   T y;


   //Operator overloads:
   friend point<T> operator+(point<T> left,point<T> right ){
       return point<T>(left.x+right.x, left.y+right.y);
   }

   template<class T2>
   friend point<T> operator+(point<T2> left,point<T> right){
       return point<T>(left)+right;

   }

   template<class T3>
   friend point<T> operator+(point<T> left,point<T3> right){
       return point<T>(right)+left;
   }


};

这给我打电话时造成的歧义错误。

point<float> p1(1.2,1.4);
point<int> p2(1,2);    
point<float> p3 =p1+p2;    

这是有道理的，但是您能告诉我如何解决的好方法吗？

我需要3个运算符，因为否则转换可能会朝错误的方向进行。例如，忽略最后一个运算符重载将导致p3.x=2和p3.y=4。

非常感谢！

鉴于以下代码：

#include <string>
#include <sstream>

class SomeClass {
public:
    SomeClass& operator<<(long value) { return *this; }

    SomeClass& operator<<(unsigned long value) { return *this; }

    SomeClass& operator<<(float value) { return *this; }

    SomeClass& operator<<(double value) { return *this; }

    SomeClass& operator<<(long double value) { return *this; }

    SomeClass& operator<<(bool value);
    { return *this; }

    SomeClass& operator<<(const void* value);
    { return *this; }

    SomeClass& operator<<(::std::string aString) { return *this; }
};

int main() {
    SomeClass aClass;
    std::ostringstream aStream;

    aClass << 2;
    aClass …

在C++中,我可以这样做:

void func(void *something) {
    cout << "something" << endl;
}

void func(nullptr_t) {
    cout << "nullptr_t" << endl;
}

int main() {
    int nothing = 5;
    func(&nothing);
    func(nullptr);
    return 0;
}

哪个输出:

东西
nullptr_t

所以我可以特殊情况nullptr_t.

在D中,我有两个功能:

void func(void* pod) {
    cout << "pod" << endl;
}

void func(Object obj) {
    cout << "Object" << endl;
}

那么如何解决调用时的歧义func(null)？

代码

default ()
h :: Bool
h = 1.0 == 1.0 --Error. Ambiguity.

不编译.这是预料之中的,因为存在歧义.它可能是Float或者Double和Haskell不知道我们想要哪一个.

但是代码

default ()
foo :: (Fractional a, Eq a) => a -> Bool
foo x = x == 1.0

编译成功.我不完全明白为什么.为什么这也不明确？

我有一种感觉,这是因为每当我们打电话foo,我们都保证到位的已经选择了一个具体类型a,即,我们都保证有固定a要么Float或Double(有两个实例,或者我们的自定义类型Fractional和Eq编译) - 时间,因此没有歧义.

但这只是一种感觉,我不知道它是否100%准确.

在numpy.ndarray这样的一个:

myarray=
array([[ 0.47174344,  0.45314669,  0.46395022,  0.47440382,  0.50709627,
         0.53350065,  0.5233444 ,  0.49974663,  0.48721607,  0.46239652,
         0.4693633 ,  0.47263569,  0.47591957,  0.436558  ,  0.43335574,
         0.44053621,  0.42814804,  0.43201894,  0.43973886,  0.44125302,
         0.41176999],
       [ 0.46509004,  0.46221505,  0.48824086,  0.50088744,  0.53040384,
         0.53592231,  0.49710228,  0.49821022,  0.47720381,  0.49096272,
         0.50438366,  0.47173162,  0.48813669,  0.45032002,  0.44776794,
         0.43910269,  0.43326132,  0.42064458,  0.43472954,  0.45577299,
         0.43604956]])

我想计算有多少单元格超过给定值,比方说0.5,并设置那些不超过给定值的单元格0.0.这就是我做的:

count=0 
value=0.5
for i in range(myarray.shape[0]):
   for j in range(myarray.shape[1]):
       if myarray[i][j]<value:
          myarray[i][j]=0 
       elif myarray[i][j]>=value:     
          count=count+1 
percentage=round(100*count/(myarray.shape[0]*myarray.shape[1]),2)

但是,我收到这个错误:ValueError: The truth value of an …

我需要使用javascript操纵某些具有一些ID的元素.我不控制代码,所以不幸的是我不能用唯一的ID重写代码.例如:

<div id="abc">
     <p class="xyz">10</p>
</div>

<div id="abc">
   <p class="xyz">20</p>
</div>

p标签内的内容保证是唯一的.所以,我需要根据p标签内的内容执行一些操作.

但是,如果我使用DOM来选择id,那么将选择哪个div,我如何确保选择所需的元素？