Solved

Explain: why certain operators cannot be overloaded

Posted on 2008-10-01
1
1,809 Views
Last Modified: 2010-10-05
.
.*
::
?:
#
##

the above c++ operators i know, cannot be overloaded. I am looking for an explanation behind this reasoning.
0
Comment
Question by:vaavoom
1 Comment
 
LVL 45

Accepted Solution

by:
sunnycoder earned 500 total points
ID: 22621762
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

ScreenConnect 6.0 Free Trial

Discover new time-saving features in one game-changing release, ScreenConnect 6.0, based on partner feedback. New features include a redesigned UI, app configurations and chat acknowledgement to improve customer engagement!

Question has a verified solution.

If you are experiencing a similar issue, please ask a related question

The following diagram presents a diamond class hierarchy: As depicted, diamond inheritance denotes when two classes (e.g., CDerived1 and CDerived2), separately extending a common base class (e.g., CBase), are sub classed simultaneously by a fourt…
In Easy String Encryption Using CryptoAPI in C++ (http://www.experts-exchange.com/viewArticle.jsp?aid=1193) I described how to encrypt text and recommended that the encrypted text be stored as a series of hexadecimal digits -- because cyphertext may…
Microsoft Active Directory, the widely used IT infrastructure, is known for its high risk of credential theft. The best way to test your Active Directory’s vulnerabilities to pass-the-ticket, pass-the-hash, privilege escalation, and malware attacks …
This video shows how to use Hyena, from SystemTools Software, to bulk import 100 user accounts from an external text file. View in 1080p for best video quality.

770 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question