By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
448,682 Members | 1,090 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 448,682 IT Pros & Developers. It's quick & easy.

Operators that cannot be Overloaded - WHY?

P: n/a
"The only operators that cannot be overloaded
are :: (scope resolution), . (member selection), and .* (member
selection through pointer to function). Quoting from Stroustrup's 3rd
edition of _The C++ Programming Language_, section 11.2 (page 263),
these three operators 'take a name, rather than a value, as their
second operand and provide the primary means of referring to members.
Allowing them to be overloaded would lead to subtleties.'"

First, I've seen ?: and sizeof added to this list. Someone also
mentioned 'delete' but Stroustrup doesn't refer to it as one. In fact,
it's in the list of overloadable operators.

Second, what is meant by 'take a name'? What is meant by 'subtleties'?
Any thoughts as to the detailed reasoning behind these?
Jul 22 '05 #1
Share this Question
Share on Google+
20 Replies


P: n/a
"Brad Eck" <br******@sitesdynamic.com> wrote...
"The only operators that cannot be overloaded
are :: (scope resolution), . (member selection), and .* (member
selection through pointer to function). Quoting from Stroustrup's 3rd
edition of _The C++ Programming Language_, section 11.2 (page 263),
these three operators 'take a name, rather than a value, as their
second operand and provide the primary means of referring to members.
Allowing them to be overloaded would lead to subtleties.'"

First, I've seen ?: and sizeof added to this list.
The ternary op is excluded probably due to complexity of its relation
to the assignment op. As to sizeof, ::, they're not really operators
in the true sense, I guess.
Someone also
mentioned 'delete' but Stroustrup doesn't refer to it as one. In fact,
it's in the list of overloadable operators.
'delete' can be overloaded. Whoever mentioned it probably didn't know
what he/she was talking about.
Second, what is meant by 'take a name'? What is meant by 'subtleties'?
Well, if you overload the . (member access) then the only way to access
a member would be (&obj)->member. Awkward. Now, if both '&' and -> are
overloaded, what do you get?...
Any thoughts as to the detailed reasoning behind these?


Detailed, 'fraid not. Try "Design and Evolution of C++". There is
a whole chapter on overloading.

V
Jul 22 '05 #2

P: n/a

"Brad Eck" <br******@sitesdynamic.com> wrote in message
news:5e*************************@posting.google.co m...
"The only operators that cannot be overloaded
are :: (scope resolution), . (member selection), and .* (member
selection through pointer to function). Quoting from Stroustrup's 3rd
edition of _The C++ Programming Language_, section 11.2 (page 263),
these three operators 'take a name, rather than a value, as their
second operand and provide the primary means of referring to members.
Allowing them to be overloaded would lead to subtleties.'"

First, I've seen ?: and sizeof added to this list. Someone also
mentioned 'delete' but Stroustrup doesn't refer to it as one. In fact,
it's in the list of overloadable operators.

Second, what is meant by 'take a name'? What is meant by 'subtleties'?
Any thoughts as to the detailed reasoning behind these?


Most normal operator take values, e.g. operator+ might add two integer
values. But the right hand side of operators . .* and :: are names of
things, e.g. name of a class member. Left hand side of :: is a name as well.
Difference between a name and a value seems pretty clear to me, and I guess
the subtleties would be the fact that nowhere else in C++ are you allow to
manipulate the names of class members, variables etc.

john
Jul 22 '05 #3

P: n/a
Victor Bazarov wrote:
'delete' can be overloaded. Whoever mentioned it probably didn't know
what he/she was talking about.


Delete CANNOT be loaded. It's just syntactic stupidity that makes the
deallocation function called "operator delete".
Jul 22 '05 #4

P: n/a
John Harrison wrote:
Most normal operator take values, e.g. operator+ might add two integer
values. But the right hand side of operators . .* and :: are names of
things, e.g. name of a class member.


operator-> works with a member on the rhs.
Jul 22 '05 #5

P: n/a

"Ron Natalie" <ro*@sensor.com> wrote in message
news:41***********************@news.newshosting.co m...
John Harrison wrote:
Most normal operator take values, e.g. operator+ might add two integer
values. But the right hand side of operators . .* and :: are names of
things, e.g. name of a class member.


operator-> works with a member on the rhs.


Use but in terms of how it is overloaded, operator-> is a unary operator
which returns a pointer, to which operator-> is reapplied.

Now Bjarne could have made it that operator. is overloaded as a unary
operator which returns a reference to which operator. is then reapplied. He
didn't and I don't know the reason but it seems like a reasonable decision
to me.

john
Jul 22 '05 #6

P: n/a
John Harrison wrote:
"Ron Natalie" <ro*@sensor.com> wrote in message
news:41***********************@news.newshosting.co m...
John Harrison wrote:

Most normal operator take values, e.g. operator+ might add two integer
values. But the right hand side of operators . .* and :: are names of
things, e.g. name of a class member.


operator-> works with a member on the rhs.

Use but in terms of how it is overloaded, operator-> is a unary operator
which returns a pointer, to which operator-> is reapplied.

Now Bjarne could have made it that operator. is overloaded as a unary
operator which returns a reference to which operator. is then reapplied. He
didn't and I don't know the reason but it seems like a reasonable decision
to me.


class SomeClass {};

class HasArrowOverloaded {
public:
SomeClass* operator->();
};

class HasDotOverloaded {
HasArrowOverloaded& operator &();
SomeClass& operator .(); // impossible in current C++, but
// let's pretend it's OK
void foo();
};

int main() {
HasDotOverloaded hdo;
// I want to call 'foo' for 'hdo'. How?
}

V
Jul 22 '05 #7

P: n/a
Ron Natalie wrote:
Victor Bazarov wrote:
'delete' can be overloaded. Whoever mentioned it probably didn't know
what he/she was talking about.

Delete CANNOT be loaded. It's just syntactic stupidity that makes the
deallocation function called "operator delete".


Whatever you call that ("syntactic stupidity" or "semantic brilliance")
you still can do

class RonDoesntLikeMeBooHoo {
public:
void operator delete(void*, size_t);
};

and when you say

RonDoesntLikeMeBooHoo *foo;
...
delete foo;

the _overloaded_ function will be called. And it has the word "operator"
in its name. If that means that it "CANNOT be loaded", then I'm the last
Chinese emperor.

V
Jul 22 '05 #8

P: n/a
Victor Bazarov wrote:
John Harrison wrote:
"Ron Natalie" <ro*@sensor.com> wrote in message
news:41***********************@news.newshosting.co m...
John Harrison wrote:
Most normal operator take values, e.g. operator+ might add two integer
values. But the right hand side of operators . .* and :: are names of
things, e.g. name of a class member.
operator-> works with a member on the rhs.


Use but in terms of how it is overloaded, operator-> is a unary operator
which returns a pointer, to which operator-> is reapplied.

Now Bjarne could have made it that operator. is overloaded as a unary
operator which returns a reference to which operator. is then
reapplied. He
didn't and I don't know the reason but it seems like a reasonable
decision
to me.

class SomeClass {};

class HasArrowOverloaded {
public:
SomeClass* operator->();
};

class HasDotOverloaded {
HasArrowOverloaded& operator &();
SomeClass& operator .(); // impossible in current C++, but
// let's pretend it's OK
void foo();
};

int main() {
HasDotOverloaded hdo;
// I want to call 'foo' for 'hdo'. How?
}

V

hdo.HasDotOverloaded::foo() ?

--
Regards,
Slava

Jul 22 '05 #9

P: n/a
Victor Bazarov posted:
Ron Natalie wrote:
Victor Bazarov wrote:
'delete' can be overloaded. Whoever mentioned it probably didn't know what he/she was talking about.

Delete CANNOT be loaded. It's just syntactic stupidity that makes the deallocation function called "operator delete".


Whatever you call that ("syntactic stupidity" or "semantic

brilliance") you still can do

class RonDoesntLikeMeBooHoo {
public:
void operator delete(void*, size_t);
};

and when you say

RonDoesntLikeMeBooHoo *foo;
...
delete foo;

the _overloaded_ function will be called. And it has the word "operator" in its name. If that means that it "CANNOT be loaded", then I'm the last Chinese emperor.

V

Now that's the kind of ridiculing debate I like to see!

Handbags at dawn, ladies!
-JKop
Jul 22 '05 #10

P: n/a
Vyacheslav Kononenko wrote:
Victor Bazarov wrote:
John Harrison wrote:
"Ron Natalie" <ro*@sensor.com> wrote in message
news:41***********************@news.newshosting.co m...

John Harrison wrote:
> Most normal operator take values, e.g. operator+ might add two integer
> values. But the right hand side of operators . .* and :: are names of
> things, e.g. name of a class member.

operator-> works with a member on the rhs.


Use but in terms of how it is overloaded, operator-> is a unary operator
which returns a pointer, to which operator-> is reapplied.

Now Bjarne could have made it that operator. is overloaded as a unary
operator which returns a reference to which operator. is then
reapplied. He
didn't and I don't know the reason but it seems like a reasonable
decision
to me.


class SomeClass {};

class HasArrowOverloaded {
public:
SomeClass* operator->();
};

class HasDotOverloaded {
HasArrowOverloaded& operator &();
SomeClass& operator .(); // impossible in current C++, but
// let's pretend it's OK
void foo();
};

int main() {
HasDotOverloaded hdo;
// I want to call 'foo' for 'hdo'. How?
}

V


hdo.HasDotOverloaded::foo() ?


If analogy with operator-> is considered, then the _right_ side of that
operator has no affect on the result.

Generally speaking, I don't know. Shouldn't it actually say "SomeClass
has no 'HasDotOverloaded' member" or something? But let's simply make
it a bit more interesting. Consider the to of the code above corrected
as following:

struct Base {
virtual void foo();
};

class SomeClass : public Base {
void foo();
};

Now, how sould compiler decide what to call if the syntax is

hdo.Base::foo(); // want to call Base::foo for SomeClass&

or

hdo.foo(); // which 'foo'?

See the problem? My post is not intended to spark a discussion that has
a goal to figure out how to overload operator dot correctly. I am just
trying to illustrate the problems that arise if such attempt is made.

V
Jul 22 '05 #11

P: n/a
Victor Bazarov wrote:
RonDoesntLikeMeBooHoo *foo;
...
delete foo;

the _overloaded_ function will be called. And it has the word "operator"
in its name. If that means that it "CANNOT be loaded", then I'm the last
Chinese emperor.


The overloaded fucntion gets called, but it isn't the implementation
of the delete operator. The delete operator does a lot of other stuff
(notably calling destructors) in addition to calling operator delete.
Jul 22 '05 #12

P: n/a
Victor Bazarov wrote:
If analogy with operator-> is considered, then the _right_ side of that
operator has no affect on the result.

By the way, I'm not arguing that operator. should be allowed to
be overloading, I was just pointing out someone's claim that the
fact that the rhs of the . operator was a member name was a reason
(and I pointed out the counterexample).

The main reason is that . would be too darn confusing if overloaded.
You gotta start from somewhere. Frankly, if it were up to me,
you wouldn't be able to overload unary & either.
Jul 22 '05 #13

P: n/a
Ron Natalie wrote:
Victor Bazarov wrote:
RonDoesntLikeMeBooHoo *foo;
...
delete foo;

the _overloaded_ function will be called. And it has the word "operator"
in its name. If that means that it "CANNOT be loaded", then I'm the last
Chinese emperor.


The overloaded fucntion gets called, but it isn't the implementation
of the delete operator. The delete operator does a lot of other stuff
(notably calling destructors) in addition to calling operator delete.


Yes, a good opportunity for a language lawyer to demonstrate the knowledge
of the difference between the delete operator and the operator delete,
isn't it? The memory allocation function ("operator delete") can be
overloaded. That's the point. Are you disputing that? I guess, not.
Jul 22 '05 #14

P: n/a

"Victor Bazarov" <v.********@comAcast.net> wrote in message news:11****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
Yes, a good opportunity for a language lawyer to demonstrate the knowledge
of the difference between the delete operator and the operator delete,
isn't it?

[snip]

Is there any good description of the difference between the delete operator and the operator delete?

By the way, Google "delete operator" in www.parashift.com (Marshall Cline's C++ FAQs Lite) gives
http://www.google.com/search?hl=en&l...te+operator%22
-> "Your search - "delete operator" - did not match any documents"
--
Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

Jul 22 '05 #15

P: n/a
Alex Vinokur wrote:
"Victor Bazarov" <v.********@comAcast.net> wrote in message news:11****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
Yes, a good opportunity for a language lawyer to demonstrate the knowledge
of the difference between the delete operator and the operator delete,
isn't it?


[snip]

Is there any good description of the difference between the delete operator and the operator delete?

By the way, Google "delete operator" in www.parashift.com (Marshall Cline's C++ FAQs Lite) gives
http://www.google.com/search?hl=en&l...te+operator%22
-> "Your search - "delete operator" - did not match any documents"


"Delete operator" is what is used when you delete a pointer in your code:

delete ptr;

"Operator delete" is the deallocation function that you can overload.

The main difference is that "delete operator" invokes (calls) the proper
destructor and then uses "operator delete" to free the memory.

Same thing with "new operator" and "operator new".

V
Jul 22 '05 #16

P: n/a

"Victor Bazarov" <v.********@comAcast.net> wrote in message news:gw****************@newsread1.dllstx09.us.to.v erio.net...
Alex Vinokur wrote:
"Victor Bazarov" <v.********@comAcast.net> wrote in message news:11****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
Yes, a good opportunity for a language lawyer to demonstrate the knowledge
of the difference between the delete operator and the operator delete,
isn't it?


[snip]

Is there any good description of the difference between the delete operator and the operator delete?

By the way, Google "delete operator" in www.parashift.com (Marshall Cline's C++ FAQs Lite) gives
http://www.google.com/search?hl=en&l...te+operator%22
-> "Your search - "delete operator" - did not match any documents"


"Delete operator" is what is used when you delete a pointer in your code:

delete ptr;

"Operator delete" is the deallocation function that you can overload.

The main difference is that "delete operator" invokes (calls) the proper
destructor and then uses "operator delete" to free the memory.

Same thing with "new operator" and "operator new".

V


Here is description og file <new> from
Standard C++ Library Module Reference Guide from Rogue Wave web site:
http://www.roguewave.com/support/doc...ref/new-h.html

Is "new" here "new operator" or "operator new"?
Is "delete" here "delete operator" or "operator delete"?
--
Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

Jul 22 '05 #17

P: n/a
Alex Vinokur wrote:
"Victor Bazarov" <v.********@comAcast.net> wrote in message news:gw****************@newsread1.dllstx09.us.to.v erio.net...
Alex Vinokur wrote:
"Victor Bazarov" <v.********@comAcast.net> wrote in message news:11****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
Yes, a good opportunity for a language lawyer to demonstrate the knowledge
of the difference between the delete operator and the operator delete,
isn't it?

[snip]

Is there any good description of the difference between the delete operator and the operator delete?

By the way, Google "delete operator" in www.parashift.com (Marshall Cline's C++ FAQs Lite) gives
http://www.google.com/search?hl=en&l...te+operator%22
-> "Your search - "delete operator" - did not match any documents"
"Delete operator" is what is used when you delete a pointer in your code:

delete ptr;

"Operator delete" is the deallocation function that you can overload.

The main difference is that "delete operator" invokes (calls) the proper
destructor and then uses "operator delete" to free the memory.

Same thing with "new operator" and "operator new".

V

Here is description og file <new> from
Standard C++ Library Module Reference Guide from Rogue Wave web site:
http://www.roguewave.com/support/doc...ref/new-h.html

Is "new" here "new operator" or "operator new"?


What do you think? What do you see there?

In the following code there are both, can you spot them and tell them
apart?

class Blah {
public:
void* operator new(size_t);
};

int main() {
Blah* blah = new Blah;
}

If not, the one in the class is "operator new" (doesn't it say so in
the actual function declaration?), the one in the 'main' is the "new
operator".
Is "delete" here "delete operator" or "operator delete"?


Well, what do you think?

OK, OK, any function declared using 'operator' and then some other symbol
or word, is the "operator X" function. "operator delete" (when you see
those words in that order in the code) is the deallocation function that
is allowed to be overloaded for custom types and globally. "operator new"
is the one declared in the <new> and one that you can overload in a class
or globally.

"New operator" is what is invoked by the "new expression".

V
Jul 22 '05 #18

P: n/a

"Victor Bazarov" <v.********@comAcast.net> wrote in message news:Zt****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
class Blah {
public: -----------------------------------------
This is declaration of "operator new" void* operator new(size_t); ----------------------------------------- };
This is definition of "operator new"
void* Blah::operator new(size_t)
{
// stuff
}

If we don't define our "operator new" then default "operator new" is used?

int main() { --------------------------------------
This is calling the "new operator". Blah* blah = new Blah; --------------------------------------
Can we directly call "operator new"?
When is it worth doing that (instesd of calling the "new operator")?
}

If not, the one in the class is "operator new" (doesn't it say so in
the actual function declaration?), the one in the 'main' is the "new
operator".

[snip]
--
Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

Jul 22 '05 #19

P: n/a
Alex Vinokur wrote:
"Victor Bazarov" <v.********@comAcast.net> wrote in message news:Zt****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
class Blah {
public:
-----------------------------------------
This is declaration of "operator new"
void* operator new(size_t);


-----------------------------------------
};

This is definition of "operator new"
void* Blah::operator new(size_t)
{
// stuff
}

If we don't define our "operator new" then default "operator new" is used?


Right.

int main() {
--------------------------------------
This is calling the "new operator".
Blah* blah = new Blah;


Basically. It's more appropriate to say "using new operator" instead of
"calling" it.

--------------------------------------
Can we directly call "operator new"?
We can.
When is it worth doing that (instesd of calling the "new operator")?


Probably never.

V
Jul 22 '05 #20

P: n/a

"Victor Bazarov" <v.********@comAcast.net> wrote in message news:tZ****************@newsread1.dllstx09.us.to.v erio.net...
Alex Vinokur wrote:
"Victor Bazarov" <v.********@comAcast.net> wrote in message news:Zt****************@newsread1.dllstx09.us.to.v erio.net...
[snip]
class Blah {
public:


-----------------------------------------
This is declaration of "operator new"
void* operator new(size_t);


-----------------------------------------
};

This is definition of "operator new"
void* Blah::operator new(size_t)
{
// stuff
}

If we don't define our "operator new" then default "operator new" is used?


Right.

int main() {


--------------------------------------
This is calling the "new operator".
Blah* blah = new Blah;


Basically. It's more appropriate to say "using new operator" instead of
"calling" it.

--------------------------------------
Can we directly call "operator new"?


We can.
When is it worth doing that (instesd of calling the "new operator")?


Probably never.

V


Here are some samples of using overloaded and original "operator new".

Done under impression by
http://www.icce.rug.nl/documents/cpl...lusplus09.html
(C++ Annotations Version 6.1.2 by Frank B. Brokken)

--------- C++ code : BEGIN ---------
// File foo.cpp
#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;
struct Foo
{
int var1;
int var2;
void show ()
{
cout << "Values: var1 = " << var1 << ", var2 = " << var2 << endl;
}
Foo() {}
Foo (int var1_i, int var2_i) : var1 (var1_i), var2 (var2_i) {}
static void* operator new(size_t size_i);
static void* operator new(size_t size_i, int var1_i, int var2_i);
};

void* Foo::operator new(size_t size_i)
{
cout << __PRETTY_FUNCTION__ << "; size = " << size_i << endl;
void *ptr = new char[size_i];
return ptr;
}

void* Foo::operator new(size_t size_i, int var1_i, int var2_i)
{
cout << __PRETTY_FUNCTION__ << "; size = " << size_i << "; var1_i = " << var1_i << ", var2_i = " << var2_i << endl;
void *ptr = new char[size_i];
memcpy (ptr, (char*)&var1_i, sizeof var1_i);
memcpy ((char*)ptr + sizeof var1_i, (char*)&var2_i, sizeof var2_i);
return ptr;
}

int main()
{
Foo* foo1 = new Foo;
foo1->show();

cout << endl;
Foo* foo2 = new Foo();
foo2->show();

cout << endl;
Foo* foo3 = new Foo(100, 200);
foo3->show();

cout << endl;
Foo* foo4 = new(300, 400) Foo;
foo4->show();

cout << endl;
Foo* foo5 = new(500, 600) Foo ();
foo5->show();
cout << endl;
cout << endl;
Foo* foo6 = ::new Foo;
foo6->show();

cout << endl;
Foo* foo7 = ::new Foo();
foo7->show();

cout << endl;
Foo* foo8 = ::new Foo(700, 800);
foo8->show();

cout << endl;
Foo* foo9 = ::new Foo(900, 1000);
foo9->show();

// --------------------------------------------------------
// Using/calling 'new' as it shown below is not recommended
// --------------------------------------------------------

cout << endl;
cout << endl;
Foo* foo10 = (Foo*)Foo::operator new(sizeof (Foo));
foo10->show();

cout << endl;
Foo* foo11 = (Foo*)Foo::operator new(sizeof (Foo), 1100, 1200);
foo11->show();
return 0;
}

--------- C++ code : END -----------

--------- Compilation & Run : BEGIN ---------

$ g++ -v
[omitted]
gcc version 3.3.3 (cygwin special)
$ g++ foo.cpp
// No errors/warnings
$ a

static void* Foo::operator new(unsigned int); size = 8
Values: var1 = 1628570148, var2 = 1628570148

static void* Foo::operator new(unsigned int); size = 8
Values: var1 = 0, var2 = 0

static void* Foo::operator new(unsigned int); size = 8
Values: var1 = 100, var2 = 200

static void* Foo::operator new(unsigned int, int, int); size = 8; var1_i = 300, var2_i = 400
Values: var1 = 300, var2 = 400

static void* Foo::operator new(unsigned int, int, int); size = 8; var1_i = 500, var2_i = 600
Values: var1 = 500, var2 = 600
Values: var1 = 0, var2 = 0

Values: var1 = 0, var2 = 0

Values: var1 = 700, var2 = 800

Values: var1 = 900, var2 = 1000
static void* Foo::operator new(unsigned int); size = 8
Values: var1 = 0, var2 = 0

static void* Foo::operator new(unsigned int, int, int); size = 8; var1_i = 1100, var2_i = 1200
Values: var1 = 1100, var2 = 1200

--------- Compilation & Run : END -----------
--
Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

Jul 22 '05 #21

This discussion thread is closed

Replies have been disabled for this discussion.