Go Premium for a chance to win a PS4. Enter to Win

x
  • Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 1818
  • Last Modified:

Explain: why certain operators cannot be overloaded

.
.*
::
?:
#
##

the above c++ operators i know, cannot be overloaded. I am looking for an explanation behind this reasoning.
0
vaavoom
Asked:
vaavoom
1 Solution
 
sunnycoderCommented:
Hello vaavoom,

From Stroustrup himself
www.research.att.com/~bs/bs_faq2.html


Most operators can be overloaded by a programmer. The exceptions are

      . (dot)  ::  ?:  sizeof

There is no fundamental reason to disallow overloading of ?:. I just didn't see the need to introduce the special case of overloading a ternary operator. Note that a function overloading expr1?expr2:expr3 would not be able to guarantee that only one of expr2 and expr3 was executed.

Sizeof cannot be overloaded because built-in operations, such as incrementing a pointer into an array implicitly depends on it. Consider:

      X a[10];
      X* p = &a[3];
      X* q = &a[3];
      p++;      // p points to a[4]
            // thus the integer value of p must be
            // sizeof(X) larger than the integer value of q

Thus, sizeof(X) could not be given a new and different meaning by the programmer without violating basic language rules.

In N::m neither N nor m are expressions with values; N and m are names known to the compiler and :: performs a (compile time) scope resolution rather than an expression evaluation. One could imagine allowing overloading of x::y where x is an object rather than a namespace or a class, but that would - contrary to first appearances - involve introducing new syntax (to allow expr::expr). It is not obvious what benefits such a complication would bring.

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.



Regards,
sunnycoder
0

Featured Post

How to Use the Help Bell

Need to boost the visibility of your question for solutions? Use the Experts Exchange Help Bell to confirm priority levels and contact subject-matter experts for question attention.  Check out this how-to article for more information.

Tackle projects and never again get stuck behind a technical roadblock.
Join Now