Why can not be overloaeded

[Rajesh1978]

HI,
I have some doubt. Why some of the operators can not be overloaeded.
like .,::,*::, ? and sizeof.

Is there any specific reason.
Please someone explain
Thanks

[Abhishek Chauhan]

Its a text That I had copied from some white paper . hope this will help you

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?
}

[Rajesh1978]

Still it is hard to understand.
Any other explanation plz

[JohnW@Wessex]

Still it is hard to understand. Any other explanation plz

The overloads either make no sense (useless), or cause the meaning to become ambiguous.