blocks|key|13669|text|编译器为所有没有定义自己的类生成默认的复制赋值运算符(operator=)。这意味着在任何情况下都不会选择全局重载。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|13670|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The compiler generates a default copy assignment operator (operator=) for all classes that do not define their own. That means that a global overload won't be selected under any circumstances.

blocks|key|4054179|text|=操作符(用作初始化时)与构造函数紧密相关；当您编写SomeClass+a+=+b;代码时，会调用SomeClass的一些构造函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4054180|entityMap^0|0|1|Q|G|1D|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

The <code>=</code> operator (when used as initialization) is deeply tied to constructors; when you code <code>SomeClass a = b;</code> some constructor of <code>SomeClass</code> is called.

blocks|key|13621|text|因为赋值对于任何类型都有明确的含义，所以其他运算符就没有。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|13622|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Because assignment has a clear meaning for any type, the other operators do not.

blocks|key|4054222|text|在没有引用特定实现和私有成员的情况下，从类外部实现operator=()似乎真的很难。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4054223|然而，像'%2B‘这样的运算符有时必须在全局级别定义。考虑一个复数类。我可以从我的类内部定义complex：：operator%2B(浮点数)，但我必须从外部定义operator%2B(浮点数，复杂)，因为第一个操作数没有我的类的类型。|4054224|编辑：我还应该提到，通过使用类中定义的其他运算符，在不引用特定实现细节的情况下定义像operator%2B这样的全局运算符通常很容易。例如：|offset|length|style|BOLD|4054225|complex+operator%2B(float+lhs,+complex+rhs)+{return+complex(lhs,+0)%2Brhs;}|code-block|syntax|javascript|4054226|entityMap^0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Seems like it would be really hard to implement an operator=() from outside the class without reference to the specific implementation and the private members. 

Operators like '+', however, sometimes have to be defined at the global level. Consider a complex number class. I can define complex::operator+(float) from inside my class, but I must define operator+(float, complex) from outside because the first operand doesn't have the type of my class.

Edit: I should have mentioned also that it's often easy to define global operators like operator+ without reference to specific implementation details by using other operators defined in the class. For example:

<pre><code>complex operator+(float lhs, complex rhs) {return complex(lhs, 0)+rhs;}
</code></pre>

blocks|key|1256276|text|为了展开@ildjarn的注释，全局内置=的语义是通用设置的；当初始化具有某种r值的类的新实例时调用它，并调用适当的构造函数(基于r值的编译时类型)，这是提供c风格初始化的一种很好的方法，而不是严格要求所有变量都通过显式调用构造函数进行初始化。重载全局运算符会更改太多语言的底层语义，而提供的实际好处却很少--您将从根本上改变调用构造函数的方式、对象以及是否调用，如果您觉得有理由通过重载全局=来执行此操作，那么您很可能就错了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1256277|类成员operator=是可重载的，因为它操作的是它的类的已经存在的和初始化的左值，并且在修改预先存在的对象时，有明显的情况需要自定义行为(比如只复制来自右值的某些成员，同时重新计算其他成员，而不计算其他成员，或者适当地处理指针持有的资源，以便在不泄漏内存的情况下获得新资源)。|1256278|当成员operator=处理一个完整的左值对象时，内置的开始只有一个适当大小的内存块和一个右值。所有形状和形式的构造器都是由语言提供的接口，用于修改内置+=+的行为，而不会将语义本身的控制权拱手让给您。我很想看看您认为需要通过重载全局=来完成哪些无法使用构造函数完成的任务。|BOLD|1256279|entityMap^0|K|1|5G|1|0|3|9|0|3|9|25|1|39|1|1K|K|25|1|27|M|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|J]|$9|13|A|14|B|J]|$9|15|A|16|B|J]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|L|$]]

To expand @ildjarn's comment, the semantics of the global built-in <code>=</code> are universally set; it is called when initializing a new instance of a class with an rvalue of some kind, and calls the appropriate constructor (based on the compile-time type of the rvalue), which is a nice way of providing c-style initialization instead of strictly requiring all variables to be initialized by an explicit call to a constructor. Overloading the global operator would change too much of the underlying semantics of the language while providing little to know real benefit--you'd be fundamentally changing how, which, and whether constructors are called, and if you feel like you have a reason to do that through overloading the global <code>=</code>, there's a good chance you're wrong.

The class-member <code>operator=</code> is overloadable because it's operating on an already existing and initialized lvalue of its class, and there are obvious cases where you would want custom behavior in modifying a pre-existing object (like only copying certain members from the rvalue while recalculating others and leaving still others alone, or properly disposing of resources held by pointer to take hold of a new resource without leaking memory).

Where the member <code>operator=</code> deals with a complete lvalue object, the built-in starts with nothing but an appropriately sized block of memory and an rvalue. Constructors of all shapes and forms are the language-provided interfaces for modifying the behavior of the built-in <code>=</code> without ceding control of the semantics themselves to you. I'd be interested to see what you feel you need to accomplish by overloading global <code>=</code> that couldn't be done with a constructor.

C++ allows to overload <code>=</code> operator only as a member function not as a global function.

Bruce Eckel says that <code>if it was possible to define operator= globally, then you might attempt to redefine the built-in = sign.</code> and due to this reason you can overload = operator only as a member function.

if C++ has already defined <code>=</code> operator then why the other operators like <code>+</code> <code>-</code> etc... are not defined by C++ as they can be overloaded as a non-member function. ?

Overloading Operator = as a member function

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

C++只允许重载=运算符作为成员函数，而不是全局函数。Bruce Eckel说if it was possible to define operator= globally, then you might attempt to redefine the built-in = sign.，由于这个原因，你只能重载=运算符作为成员函数。如果C++已经定义了=运算符，那么为什么还要定义+、-等其他运算符

问重载运算符=作为成员函数
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问重载运算符=作为成员函数EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问重载运算符=作为成员函数
EN