注册
登录
idea
运算符重载的基本规则和习惯用法是什么？
返回
运算符重载的基本规则和习惯用法是什么？
作者:
biu~额
发布时间:
2025-03-03 06:53:06 (17小时前)
转自：
<div class =“excerpt”> ?? ?????????????????并删除 （注意：这是Stack Overflow的C ++ FAQ的一个条目。如果你想批评那个 ??<span class =“result-highlight”> ????理念 ??</跨度> ???在这种形式下提供常见问题解答，然后发布所有这一切的元数据的发布将是这样做的地方。该问题的答案在C ++聊天室中进行监控，其中包含常见问题解答 ??<span class =“result-highlight”> ????理念 ??</跨度> ???从一开始就开始了，所以你的答案很可能会被那些提出答案的人阅读 ??<span class =“result-highlight”> ????理念 ??</跨度> ??。） ??????????? ?鈥 ???????????? </DIV>
收藏
举报
4 条回复
0#
回复此人
❀⚘粉༵红༵回༵忆༵⚘❀
|
2019-08-31 10-32
<div class =“post-text”itemprop =“text”> ??<H1> ????常见的运算符超载 ??</H1> ??<P> ????超载运营商的大部分工作都是锅炉板代码。这并不奇怪，因为操作符只是语法糖，它们的实际工作可以通过（通常转发到）普通函数来完成。但重要的是你要正确使用这种锅炉板代码。如果您失败，您的运营商代码将赢得编译或您的用户代码不会编译或您的用户代码将出乎意料地行事。 ??</p> ??<H2> ????分配操作员 ??</H2> ??<P> ????关于任务有很多话要说。但是，大部分内容已经在说过了 ????<a href="https://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom"> ??????GMan着名的Copy-And-Swap常见问题解答 ????</A> ????，所以我将在这里跳过大部分内容，仅列出完美的赋值运算符以供参考： ??</p> ???<pre> <code> X& X::operator=(X rhs) { swap(rhs); return *this; } </code> </pre> ??<H2> ????Bitshift运算符（用于流I / O） ??</H2> ??<P> ????bitshift运算符 ?????<code> << </code> ?????和 ?????<code> >> </code> ????尽管仍然在硬件接口中用于从C继承的位操作函数，但在大多数应用程序中，它们作为重载流输入和输出运算符变得更加普遍。有关作为位操作运算符的指导重载，请参阅下面的二进制算术运算符部分。要在对象与iostream一起使用时实现自己的自定义格式和解析逻辑，请继续。 ??</p> ??<P> ????流运算符（最常见的是重载运算符）是二进制中缀运算符，其语法对它们应该是成员还是非成员没有限制。 由于他们改变了他们的左参数（他们改变了流的状态），根据经验法则，他们应该被实现为他们的左操作数的类型。但是，它们的左操作数是来自标准库的流，虽然标准库定义的大多数流输出和输入操作符确实被定义为流类的成员，但当您为自己的类型实现输出和输入操作时，无法更改标准库的流类型。这就是为什么你需要为你自己的类型实现这些运算符作为非成员函数。 这两者的规范形式是： ??</p> ???<pre> <code> std::ostream& operator<<(std::ostream& os, const T& obj) { // write obj to stream return os; } std::istream& operator>>(std::istream& is, T& obj) { // read obj from stream if( /* no valid object of T found in stream */ ) is.setstate(std::ios::failbit); return is; } </code> </pre> ??<P> ????实施时 ?????<code> operator>> </code> ????，只有当读取本身成功时才需要手动设置流状态，但结果不是预期的结果。 ??</p> ??<H2> ????函数调用运算符 ??</H2> ??<P> ????用于创建函数对象的函数调用操作符（也称为函子）必须定义为a ????的<strong> ??????<EM> ????????会员 ??????</EM> ????</强> ?????函数，所以它总是有隐含的 ?????<code> this </code> ?????成员职能的论点。除此之外，它可以重载以获取任意数量的附加参数，包括零。 ??</p> ??<P> ????这是一个语法示例： ??</p> ???<pre> <code> class foo { public: // Overloaded call operator int operator()(const std::string& y) { // ... } }; </code> </pre> ??<P> ????用法： ??</p> ???<pre> <code> foo f; int a = f("hello"); </code> </pre> ??<P> ????在整个C ++标准库中，始终复制函数对象。因此，您自己的功能对象应该便宜复制。如果函数对象绝对需要使用复制成本高昂的数据，最好将该数据存储在其他地方并让函数对象引用它。 ??</p> ??<H2> ????比较运算符 ??</H2> ??<P> ????根据经验法则，二进制中缀比较运算符应实现为非成员函数 ????<SUP> ??????1 ????</SUP> ????。一元前缀否定 ?????<code> ! </code> ?????应该（根据相同的规则）实现为成员函数。 （但重载它通常不是一个好主意。） ??</p> ??<P> ????标准库的算法（例如 ?????<code> std::sort() </code> ????）和类型（例如 ?????<code> std::map </code> ????）永远只会期待 ?????<code> operator< </code> ?????在场。然而 ????<EM> ??????您的类型的用户将期望所有其他运营商在场 ????</EM> ????，所以，如果你定义 ?????<code> operator< </code> ????，一定要遵循运算符重载的第三个基本规则，并定义所有其他布尔比较运算符。实现它们的规范方法是： ??</p> ???<pre> <code> inline bool operator==(const X& lhs, const X& rhs){ /* do actual comparison */ } inline bool operator!=(const X& lhs, const X& rhs){return !operator==(lhs,rhs);} inline bool operator< (const X& lhs, const X& rhs){ /* do actual comparison */ } inline bool operator> (const X& lhs, const X& rhs){return operator< (rhs,lhs);} inline bool operator<=(const X& lhs, const X& rhs){return !operator> (lhs,rhs);} inline bool operator>=(const X& lhs, const X& rhs){return !operator< (lhs,rhs);} </code> </pre> ??<P> ????这里要注意的重要一点是，这些操作符中只有两个实际上做了任何事情，其他操作符只是将它们的参数转发给这两个中的任何一个来完成实际工作。 ??</p> ??<P> ????重载剩余二进制布尔运算符的语法（ ?????<code> || </code> ????， ?????<code> && </code> ????）遵循比较运算符的规则。但是，确实如此 ????<EM> ??????非常 ????</EM> ?????你不太可能找到合理的用例 ????<SUP> ??????2 ????</SUP> ????。 ??</p><P> ????<SUP> ??????1 ????</SUP> ????<子> ??????与所有经验法则一样，有时也可能有理由打破这一个。如果是这样，不要忘记二进制比较运算符的左侧操作数，对于成员函数将是 ???????<code> *this </code> ??????， 需要是 ???????<code> const </code> ??????也是。因此，作为成员函数实现的比较运算符必须具有以下签名： ????</子> ??</p> ???<pre> <code> bool operator<(const X& rhs) const { /* do actual comparison with *this */ } </code> </pre> ??<P> ????<子> ??????（注意 ???????<code> const </code> ???????在末尾。） ????</子> ??</p> ??<P> ????<SUP> ??????2 ????</SUP> ????<子> ??????应该注意的是内置版本 ???????<code> || </code> ???????和 ???????<code> && </code> ???????使用快捷语义。虽然用户定义的（因为它们是方法调用的语法糖）不使用快捷语义。用户希望这些运算符具有快捷语义，并且它们的代码可能依赖于它，因此强烈建议永远不要定义它们。 ????</子> ??</p> ??<H2> ????算术运算符 ??</H2> ??<H3> ????一元算术运算符 ??</H3> ??<P> ????一元递增和递减运算符有前缀和后缀两种风格。为了告诉另一个，后缀变体采用额外的伪int参数。如果重载增量或减量，请确保始终实现前缀和后缀版本。 这是增量的规范实现，减量遵循相同的规则： ??</p> ???<pre> <code> class X { X& operator++() { // do actual increment return *this; } X operator++(int) { X tmp(*this); operator++(); return tmp; } }; </code> </pre> ??<P> ????请注意，后缀变体是根据前缀实现的。另请注意，postfix会额外复制。 ????<SUP> ??????2 ????</SUP> ??</p> ??<P> ????重载一元减号和加号不是很常见，可能最好避免。如果需要，它们可能应该作为成员函数重载。 ??</p> ??<P> ????<SUP> ??????2 ????</SUP> ????<子> ??????另请注意，后缀变体功能更多，因此使用效率低于前缀变量。这是一个很好的理由，通常更喜欢前缀增量而不是后缀增量。虽然编译器通常可以优化内置类型的后缀增量的额外工作，但是它们可能无法对用户定义的类型执行相同的操作（这可能是像列表迭代器那样无辜地看起来的东西）。一旦你习惯了 ???????<code> i++ </code> ??????，记得这么做很难 ???????<code> ++i </code> ???????相反 ???????<code> i </code> ???????不是内置类型（加上你必须在更改类型时更改代码），所以最好养成一直使用前缀增量的习惯，除非明确需要postfix。 ????</子> ??</p> ??<H3> ????二元算术运算符 ??</H3> ??<P> ????对于二进制算术运算符，不要忘记遵守第三个基本规则运算符重载：如果提供 ?????<code> + </code> ????，还提供 ?????<code> += </code> ????，如果你提供 ?????<code> - </code> ????，不要省略 ?????<code> -= </code> ????据说Andrew Koenig是第一个观察到复合赋值算子可以作为非复合对应物的基础的人。那就是运营商 ?????<code> + </code> ?????是以实施的方式实施的 ?????<code> += </code> ????， ?????<code> - </code> ?????是以实施的方式实施的 ?????<code> -= </code> ?????等等 ??</p> ??<P> ????根据我们的经验法则， ?????<code> + </code> ?????及其同伴应该是非成员，而他们的复合作业同行（ ?????<code> += </code> ?????改变他们的左派论点，应该是一个成员。这是示例代码 ?????<code> += </code> ?????和 ?????<code> + </code> ????，其他二进制算术运算符应以相同的方式实现： ??</p> ???<pre> <code> class X { X& operator+=(const X& rhs) { // actual addition of rhs to *this return *this; } }; inline X operator+(X lhs, const X& rhs) { lhs += rhs; return lhs; } </code> </pre> ??<P> ?????<code> operator+= </code> ?????返回每个引用的结果，而 ?????<code> operator+ </code> ?????返回其结果的副本。当然，返回引用通常比返回副本更有效，但是在返回的情况下 ?????<code> operator+ </code> ????，没有办法绕过复制。当你写作 ?????<code> a + b </code> ????，你希望结果是一个新值，这就是原因 ?????<code> operator+ </code> ?????必须返回一个新值。 ????<SUP> ??????3 ????</SUP> ???? 另请注意 ?????<code> operator+ </code> ?????采取左操作数 ????的<strong> ??????<EM> ????????通过复制 ??????</EM> ????</强> ?????而不是通过const引用。其原因与给出的理由相同 ?????<code> operator= </code> ?????每个副本采取其论点。 ??</p> ??<P> ????位操作运算符 ?????<code> ~ </code> ?????<code> & </code> ?????<code> | </code> ?????<code> ^ </code> ?????<code> << </code> ?????<code> >> </code> ?????应该以与算术运算符相同的方式实现。但是，（超载除外 ?????<code> << </code> ?????和 ?????<code> >> </code> ?????对于输出和输入，很少有合理的用例来重载这些。 ??</p> ??<P><SUP> ??????3 ????</SUP> ????<子> ??????同样，从中可以得到的教训是 ???????<code> a += b </code> ???????通常，效率高于 ???????<code> a + b </code> ???????如果可能的话应该是首选。 ????</子> ??</p> ??<H2> ????数组订阅 ??</H2> ??<P> ????数组下标运算符是二元运算符，必??须作为类成员实现。它用于容器类型，允许通过键访问其数据元素。 提供这些的规范形式是这样的： ??</p> ???<pre> <code> class X { value_type& operator[](index_type idx); const value_type& operator[](index_type idx) const; // ... }; </code> </pre> ??<P> ????除非您不希望您的类的用户能够更改返回的数据元素 ?????<code> operator[] </code> ?????（在这种情况下，您可以省略非const变量），您应该始终提供运算符的两种变体。 ??</p> ??<P> ????如果已知value_type引用内置类型，则运算符的const变量应返回副本而不是const引用。 ??</p> ??<H2> ????指针类型的运算符 ??</H2> ??<P> ????要定义自己的迭代器或智能指针，必须重载一元前缀解引用运算符 ?????<code> * </code> ?????和二进制中缀指针成员访问运算符 ?????<code> -> </code> ????： ??</p> ???<pre> <code> class my_ptr { value_type& operator*(); const value_type& operator*() const; value_type* operator->(); const value_type* operator->() const; }; </code> </pre> ??<P> ????请注意，这些也几乎总是需要const和非const版本。 为了 ?????<code> -> </code> ?????运营商，如果 ?????<code> value_type </code> ?????是的 ?????<code> class </code> ?????（要么 ?????<code> struct </code> ?????要么 ?????<code> union </code> ????）类型，另一个 ?????<code> operator->() </code> ?????被称为递归，直到 ?????<code> operator->() </code> ?????返回非类类型的值。 ??</p> ??<P> ????一元地址运算符永远不应该重载。 ??</p> ??<P> ????对于 ?????<code> operator->*() </code> ?????看到 ????<a href="https://stackoverflow.com/q/8777845/140719"> ??????这个问题 ????</A> ????。它很少使用，因此很少超载。事实上，即使是迭代器也不会使它超载。 ??</p> ??<HR /> ??<P> ????继续 ????<a href="https://stackoverflow.com/questions/4421706/operator-overloading/16615725#16615725"> ??????转换运算符 ????</A> ??</p> </DIV>
编辑
1#
回复此人
無口君
|
2019-08-31 10-32
<div class =“post-text”itemprop =“text”> ??<H1> ????超载 ?????<code> new </code> ?????和 ?????<code> delete </code> ??</H1> ??<P> ????<SUP> ??????的<strong> ????????<EM> ??????????注意： ????????</EM> ??????</强> ???????这只涉及到 ??????的<strong> ????????<EM> ??????????句法 ????????</EM> ??????</强> ???????超载 ???????<code> new </code> ???????和 ???????<code> delete </code> ??????，而不是 ??????的<strong> ????????<EM> ??????????履行 ????????</EM> ??????</强> ???????这样的重载运营商。我认为重载的语义 ??????的<strong> ????????<EM> ??????????<a href="https://stackoverflow.com/questions/7149461/"> ?????????????<code> new </code> ?????????????和 ?????????????<code> delete </code> ?????????????值得拥有自己的FAQ ??????????</A> ????????</EM> ??????</强> ??????在运算符重载的主题内，我永远不能正义。 ????</SUP> ??</p> ??<H2> ????基本 ??</H2> ??<P> ????在C ++中，当你写一个 ????的<strong> ??????<EM> ????????新的表达 ??????</EM> ????</强> ?????喜欢 ?????<code> new T(arg) </code> ?????评估此表达式时会发生两件事：第一 ????的<strong> ??????<EM> ?????????<code> operator new </code> ??????</EM> ????</强> ?????被调用以获取原始内存，然后是相应的构造函数 ?????<code> T </code> ?????被调用以将此原始内存转换为有效对象。同样，当你删除一个对象时，首先调用它的析构函数，然后返回内存 ?????<code> operator delete </code> ????。 ????<BR/> ???? C ++允许您调整这两个操作：内存管理以及在分配的内存中构造/销毁对象。后者是通过为类编写构造函数和析构函数来完成的。微调内存管理是通过编写自己的内容来完成的 ?????<code> operator new </code> ?????和 ?????<code> operator delete </code> ????。 ??</p> ??<P> ????运算符重载的第一个基本规则是 ????<EM> ??????不要这样做 ????</EM> ?????特别适用于超载 ?????<code> new </code> ?????和 ?????<code> delete </code> ????。几乎是使这些运算符超载的唯一原因是 ????的<strong> ??????<EM> ????????性能问题 ??????</EM> ????</强> ?????和 ????的<strong> ??????<EM> ????????记忆约束 ??????</EM> ????</强> ????，在许多情况下，其他行动，如 ????<EM> ??????更改算法 ????</EM> ?????用过，会提供很多 ????的<strong> ??????<EM> ????????更高的成本/收益率 ??????</EM> ????</强> ?????而不是试图调整内存管理。 ??</p> ??<P> ????C ++标准库附带一组预定义的 ?????<code> new </code> ?????和 ?????<code> delete </code> ?????运营商。最重要的是这些： ??</p> ???<pre> <code> void* operator new(std::size_t) throw(std::bad_alloc); void operator delete(void*) throw(); void* operator new[](std::size_t) throw(std::bad_alloc); void operator delete[](void*) throw(); </code> </pre> ??<P> ????前两个为对象分配/释放内存，后两个为对象数组。如果您提供自己的版本，他们会 ????的<strong> ??????<EM> ????????不过载，但更换 ??????</EM> ????</强> ?????来自标准库的那些。 ????<BR/> ???? 如果你超载 ?????<code> operator new </code> ????，你应该总是重载匹配 ?????<code> operator delete </code> ????即使你从不打算打电话给它。原因是，如果构造函数在评估新表达式时抛出，则运行时系统会将内存返回给 ?????<code> operator delete </code> ?????匹配 ?????<code> operator new </code> ?????被调用来分配内存来创建对象。如果你没有提供匹配 ?????<code> operator delete </code> ????，调用默认值，这几乎总是错误的。 ????<BR/> ???? 如果你超载 ?????<code> new </code> ?????和 ?????<code> delete </code> ????，你也应该考虑重载数组变体。 ??</p> ??<H2> ????放置 ?????<code> new </code> ??</H2> ??<P> ????C ++允许new和delete运算符采用其他参数。 ????<BR/> ???? 所谓的placement new允许你在某个地址创建一个对象，该地址传递给： ??</p> ???<pre> <code> class X { /* ... */ }; char buffer[ sizeof(X) ]; void f() { X* p = new(buffer) X(/*...*/); // ... p->~X(); // call destructor } </code> </pre> ??<P> ????标准库附带了new和delete运算符的相应重载： ??</p> ???<pre> <code> void* operator new(std::size_t,void* p) throw(std::bad_alloc); void operator delete(void* p,void*) throw(); void* operator new[](std::size_t,void* p) throw(std::bad_alloc); void operator delete[](void* p,void*) throw(); </code> </pre> ??<P> ????请注意，在上面给出的新安置示例代码中， ?????<code> operator delete </code> ?????永远不会被调用，除非X的构造函数抛出异常。 ??</p> ??<P> ????你也可以超载 ?????<code> new </code> ?????和 ?????<code> delete </code> ?????与其他论点。与放置new的附加参数一样，这些参数也列在关键字后面的括号内 ?????<code> new </code> ????。仅仅由于历史原因，这些变体通常也称为放置新的，即使它们的参数不是用于将对象放置在特定地址。 ??</p> ??<H2> ????特定于类的新建和删除 ??</H2> ??<P> ????最常见的是，您需要微调内存管理，因为测量已经表明，经常创建和销毁特定类或一组相关类的实例，并且针对一般性能而调整的运行时系统的默认存储器管理在这种特定情况下效率低下。要改进这一点，您可以为特定类重载new和delete： ??</p> ???<pre> <code> class my_class { public: // ... void* operator new(); void operator delete(void*,std::size_t); void* operator new[](size_t); void operator delete[](void*,std::size_t); // ... }; </code> </pre> ??<P> ????因此重载，new和delete的行为类似于静态成员函数。对象 ?????<code> my_class </code> ????， ?????<code> std::size_t </code> ?????争论永远是 ?????<code> sizeof(my_class) </code> ????。但是，这些运算符也被称为动态分配的对象 ????的<strong> ??????<EM> ????????派生类 ??????</EM> ????</强> ????，在这种情况下，它可能大于那个。 ??</p> ??<H2> ????全局新增和删除 ??</H2> ??<P> ????要重载全局new和delete，只需用我们自己的标准库替换标准库的预定义运算符。但是，这很少需要完成。 ??</p> </DIV>
编辑
2#
回复此人
一别而尽几念深i
|
2019-08-31 10-32
<div class =“post-text”itemprop =“text”> ??<P> ????<a href="https://stackoverflow.com/questions/34953523/overloading-the-insertion-operator-questions-theoretical"> ??????为什么不能 ???????<code> operator<< </code> ???????流对象的功能 ???????<code> std::cout </code> ???????或者文件是会员功能？ ????</A> ??</p> ??<P> ????假设你有： ??</p> ???<pre> <code> struct Foo { int a; double b; std::ostream& operator<<(std::ostream& out) const { return out << a << " " << b; } }; </code> </pre> ??<P> ????鉴于此，你不能使用： ??</p> ???<pre> <code> Foo f = {10, 20.0}; std::cout << f; </code> </pre> ??<P> ????以来 ?????<code> operator<< </code> ?????作为成员函数重载 ?????<code> Foo </code> ????，运营商的LHS必须是 ?????<code> Foo </code> ?????宾语。这意味着，您将被要求使用： ??</p> ???<pre> <code> Foo f = {10, 20.0}; f << std::cout </code> </pre> ??<P> ????这是非常不直观的。 ??</p> ??<P> ????如果将其定义为非成员函数， ??</p> ???<pre> <code> struct Foo { int a; double b; }; std::ostream& operator<<(std::ostream& out, Foo const& f) { return out << f.a << " " << f.b; } </code> </pre> ??<P> ????您将能够使用： ??</p> ???<pre> <code> Foo f = {10, 20.0}; std::cout << f; </code> </pre> ??<P> ????这非常直观。 ??</p> </DIV>
编辑
登录
后才能参与评论
