0

如果我重载!=运算符并class!=在其他运算符重载器之一中使用，它会接受它作为非重载还是重载？我正在尝试创建一个 noob_ptr （我正在考虑的一种自定义指针包装器）

class noob_ptr 
 {
      private: //does this change the behaviour? public? protected?
      bool operator!=(noob_ptr x)
       {
         ...
        }
      bool operator,(noob_ptr y)
      {
         ...
         if(y!=z)...
         ...
      }
    ...
      }

下面的示例是否取消了我班级中重载运算符的使用？

class noob_ptr 
 {
      protected: //or public
      bool operator,(noob_ptr y) //yes, z is also a noob_ptr
      {
         ...
         if(y!=z)...
         ...
      }
    ...
      private: 
      bool operator!=(noob_ptr x)
       {
         ...
        }
      }
4

3 回答 3

1

如果您提供的操作数是语言内置的操作数!=，那么这就是使用的操作数。如果它们是用户定义的类型，那么它将搜索为operator!=这些类型（或支持从这些类型进行隐式转换的某些类型）定义的用户定义。

于 2012-09-12T19:19:17.957 回答
1

如果 type ofz也是 a noob_ptr，那么答案是肯定的，它会operator !=为你的类调用重载。另外，我建议您使用此比较方法签名：

bool operator != (const noob_ptr& x) const;

因此它可以用于常量指针，并且在调用重载运算符时也可以避免对象复制。

UPD：如果您声明operator !=为私有，那么它将在类的所有成员函数noob_ptr、朋友类和类的函数中可用noob_ptr，并且对于所有其他用法将导致编译错误，并显示如下消息：“operator != is inaccessible由于其保护级别"

于 2012-09-12T19:24:57.833 回答
1

C++ 将始终使用在限定符、访问说明符（如私有、范围、命名空间等）中最接近的“最佳匹配”。

因此，如果有一个全局命名空间运算符！= 和一个类（缺少左侧参数，如果方法是 const，则假定为 class& 或 const class& - 它应该是），然后在里面类（命名空间），您将在类中获得一个。

如果全局命名空间和类之间只有一个，你显然会得到那个。

以下代码演示了全局和类范围之间的关系。您可以通过添加 const 限定符等来扩展它。

 #include <iostream>
using namespace std;

// Forward declaration to use without the class definition
class X;

bool operator!=(     int lhs, const X& rhs) {
  cout << "bool operator!=(     int lhs, const X& rhs)" << endl;
  return false;
}
bool operator!=(const X& lhs, const X& rhs) {
  cout << "bool operator!=(const X& lhs, const X& rhs)" << endl;
  return false;
}
bool operator!=(const X& lhs,      int rhs) {
  cout << "bool operator!=(const X& lhs,      int rhs)" << endl;
  return false;
}
// Note: Can't do: bool operator!=(int lhs, int rhs) -- already defined

class X {
private:
  int x;
public:
  X(int value) : x(value) { }

  bool operator !=(const X& rhs) {
    cout << "bool X::operator !=(const X& rhs)" << endl;
    return true;
  }

  bool operator !=(int rhs) {
    cout << "bool X::operator !=(int rhs)" << endl;
    return true;
  }

  void f() {
    X compare(1);
    cout << "X::f()" << endl;
    cout << (5 != 3) << endl;         // Uses built-in
    cout << (*this != 3) << endl;     // Uses member function
    cout << (*this != 1) << endl;     // Uses member function
    cout << (1     != *this) << endl; // There can be no member function, uses global namespace
    cout << (*this != compare) << endl;
  }
};


void f(const X& arg) {
  cout << "f()" << endl;
  X compare(1);
  cout << (5 != 3) << endl;         // Uses built in
  cout << (arg != 3) << endl;       // Uses global namespace
  cout << (arg != 1) << endl;       // Uses global namespace
  cout << (1   != arg) << endl;     // Uses global namespace
  cout << (arg != compare) << endl; // Uses global namespace
}

int main(int argc, char **argv) {
  X x(1);
  x.f();
  f(x);
  return 0;
}
于 2012-09-12T19:46:00.440 回答