当前位置：文江博客话题详情

为什么你不能超载“.” C++ 中的运算符？

发布于 2024-07-13 10:29:33 字数 149 浏览 6 评论 0原文

能够重载 . C++ 中的运算符并返回对对象的引用。

您可以重载 operator-> 和 operator*，但不能重载 operator。

这有技术原因吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

瘫痪情歌 2024-07-20 10:29:33

请参阅Bjarne Stroustrup 的这句话：

操作员。（点）原则上可以使用相同的重载
用于->的技术。然而，这样做可能会引起问题
关于某个操作是否适用于对象重载。或一个
所引用的对象。例如：
Y 类 { 
  民众： 
      无效 f(); 
      // ... 
  }; 

  class X { // 假设您可以重载 . 
      Y*p； 
      Y&   运算符。() { 返回*p;   } 
      无效 f(); 
      // ... 
  }; 

  无效g(X&x) 
  { 
      xf();   // X::f 或 Y::f 还是错误？ 
  } 
  
这个问题可以通过多种方式解决。在那个时间
标准化，目前尚不清楚哪种方式最好。了解更多
详细信息，请参阅C++ 的设计和演变。

See this quote from Bjarne Stroustrup:

Operator . (dot) could in principle be overloaded using the same
technique as used for ->. However, doing so can lead to questions
about whether an operation is meant for the object overloading . or an
object referred to by . For example:
class Y {
public:
    void f();
    // ...
};

class X {    // assume that you can overload .
    Y* p;
    Y& operator.() { return *p; }
    void f();
    // ...
};

void g(X& x)
{
    x.f();    // X::f or Y::f or error?
}
This problem can be solved in several ways. At the time of
standardization, it was not obvious which way would be best. For more
details, see The Design and Evolution of C++.

回复收藏 0 原文

不交电费瞎发啥光 2024-07-20 10:29:33

Stroustrup 说 C++ 应该是一种可扩展的、但不是可变的语言。

点（属性访问）运算符被认为距离语言核心太近，不允许重载。

请参阅C++ 的设计和演变，第 242 页，11.5.2 智能参考部分。

当我决定允许重载运算符 -> 时，我自然会考虑运算符 . 是否可以类似地重载。
当时，我认为以下论点是结论性的：如果 obj 是一个类对象，那么 obj.m 对每个成员 m 都有含义该对象的类的代码>。我们尽量不通过重新定义内置操作来使语言可变（尽管出于迫切需要，= 和一元 & 违反了该规则）。 p>
如果我们允许类 X 重载 .，我们将无法通过正常方式访问 X 的成员；我们必须使用指针和 ->，但是 -> 和 & 也可能已被重新定义。我想要一种可扩展的语言，而不是可变的语言。
这些论点很有分量，但不是结论性的。特别是，在 1990 年，Jim Adcock 提议允许重载运算符 。 完全运算符 -> 的方式。

这句话中的“我”是 Bjarne Stroustrup。你没有比这更权威的了。

如果你想真正理解 C++（如“为什么会这样”），你绝对应该阅读这本书。

回复收藏 0 原文

不乱于心 2024-07-20 10:29:33

Stroustrup 对此问题有答案：

操作员。（点）原则上可以是
使用与以下相同的技术进行重载
用于->。然而，这样做可以
引发关于是否
操作是针对对象的
超载。或引用的对象
经过。例如：
Y 类 { 
  民众： 
      无效 f(); 
      // ... 
  }; 
  class X { // 假设您可以重载 . 
      Y*p； 
      Y&   运算符。() { 返回*p;   } 
      无效 f(); 
      // ... 
  }; 
  无效g(X&x) 
  { 
      xf();   // X::f 或 Y::f 还是错误？ 
  } 
  
这个问题可以通过多种方式解决
方法。在标准化的时候，
不清楚哪条路会是
最好的。有关更多详细信息，请参阅D&E。

Stroustrup has an answer for this question:

Operator . (dot) could in principle be
overloaded using the same technique as
used for ->. However, doing so can
lead to questions about whether an
operation is meant for the object
overloading . or an object referred to
by . For example:
class Y {
public:
    void f();
    // ...
};
class X {   // assume that you can overload .
    Y* p;
    Y& operator.() { return *p; }
    void f();
    // ...
};
void g(X& x)
{
    x.f();  // X::f or Y::f or error?
}
This problem can be solved in several
ways. At the time of standardization,
it was not obvious which way would be
best. For more details, see D&E.

回复收藏 0 原文

狼性发作 2024-07-20 10:29:33

很容易理解，如果你了解一下运算符函数调用的内部机制，
假设一个类复形可以有两个成员 r 代表实部， i 代表虚部。
说 Complex C1(10,20),C2(10,2) // 我们假设类中已经有一个两个参数的构造函数。
现在，如果您将 C1+C2 编写为语句，则编译器会尝试在复数上查找 + 运算符的重载版本。现在我们假设我重载了 + 运算符，所以
C1+C2 内部翻译为 c1.operator+(c2)
现在暂时假设您可以重载 '.' 操作员。
所以现在考虑以下调用 C1.disp()//显示复杂对象的内容现在尝试表示为内部表示
C1.operator.(------) ，创建了完全混乱的东西。这就是为什么我们不能重载 '.' 的原因。操作员