What are the operators that cannot be overloaded in C++?

There are 5 operators that cannot be overloaded in c: "?:", ".", "::", "sizeof", ".*". Confusion may occur if the "." and "::" operators are overloaded; the "sizeof" operator cannot be overloaded because many pointers internally rely on it; the ".*" operator refers to a pointer to a class member.

The operating environment of this tutorial: Windows 7 system, C 17 version, Dell G3 computer.

There are 5 operators that cannot be overloaded in C, namely: "?:" "." "::" "sizeof" ".*".
Overloading: Allow operators to have new semantics instead of changing the syntax, otherwise it will cause confusion.
Partial rules for overloading: At least one parameter of the operation function must be an object of the class or a reference to the object of the class.

The following explains why these operators cannot be overloaded.

(1)?:
Assuming it can be overloaded, then let’s look at the following code:

exp1 ? exp2 : exp3

The meaning of this operator is to execute exp2 and exp3 If one of them is overloaded, there is no guarantee that one, two, or neither will be executed, and the jump property of the operator will no longer exist. Therefore, "?:" cannot be overloaded.

(2).
Assuming that it can be overloaded, we can assume a situation where we create an object and call the function of the object.

class Y{
   public:
      void fun();
};
class X{
   public:
      Y* p;
      Y& operator.(){
          return *p;
      }
      void fun();
}
void g(X& x){
      x.fun();
}

In this example, x.fun() does not know which fun function is called.
The meaning of the "." operator is to reference object members, but this is no longer guaranteed after being overloaded, leading to confusion about the meaning of the operator.

(3)::
This operator is only domain parsed during compilation and does not participate in operations. According to the overloading rules, if the operator is overloaded, new semantics are given and confusion may occur.

(4) The reason why sizeof
cannot be overloaded is mainly because many internal pointers rely on sizeof.

(5).*
Reference pointer to class member

Extended information:

Overload operation Principles that operators abide by:
1. Overloaded operators cannot be connected to other symbols to create new operators.
2. The overloaded operator must have an operand of class type or enumeration type.
3. The meaning of built-in type operators cannot be changed, such as integer addition ( ).
4. Overloaded operators cannot guarantee the order of operators.
5. The overloaded function of a class member has a default this pointer implicit in its formal parameter.
6. Generally, assignment operators are defined as member functions, and arithmetic operators are defined as non-member functions.
7. When an operator is defined as a member function of a non-class, it is generally defined as a friend of the class.
8. == and != should appear in pairs.
9. Subscript operator []: a non-const member and returns a reference, and a const member and returns a reference.
10. * and -> operators do not display any parameters.
11. Prefix /-- must return a reference that is incremented or decremented.
12. Input operators and output operators must be defined as friend functions of the class.

For more programming-related knowledge, please visit: Introduction to Programming! !

The above is the detailed content of What are the operators that cannot be overloaded in C++?. For more information, please follow other related articles on the PHP Chinese website!