Operators that cannot be Overloaded - WHY?
Brad Eck
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?
Victor Bazarov
> "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
John Harrison
"Brad Eck" <brad...@sitesdynamic.com> wrote in message
news:5e89cb4.04102...@posting.google.com...
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
Ron Natalie
> '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".
Ron Natalie
> 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.
John Harrison
"Ron Natalie" <r...@sensor.com> wrote in message
news:417f81ca$0$28236$9a6e...@news.newshosting.com...
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
Victor Bazarov
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
Victor Bazarov
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
Vyacheslav Kononenko
hdo.HasDotOverloaded::foo() ?
--
Regards,
Slava
JKop
Now that's the kind of ridiculing debate I like to see!
Handbags at dawn, ladies!
-JKop
Victor Bazarov
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
Ron Natalie
> 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.
Ron Natalie
> 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.
Victor Bazarov
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.
Alex Vinokur
"Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:11Rfd.7248$Ae....@newsread1.dllstx09.us.to.verio.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?
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&lr=&c2coff=1&sitesearch=www.parashift.com&q=%22delete+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
Victor Bazarov
> "Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:11Rfd.7248$Ae....@newsread1.dllstx09.us.to.verio.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&lr=&c2coff=1&sitesearch=www.parashift.com&q=%22delete+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
Alex Vinokur
"Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:gw6gd.7632$Ae....@newsread1.dllstx09.us.to.verio.net...
Here is description og file <new> from
Standard C++ Library Module Reference Guide from Rogue Wave web site:
http://www.roguewave.com/support/docs/SourcePro/stdlibref/new-h.html
Is "new" here "new operator" or "operator new"?
Is "delete" here "delete operator" or "operator delete"?
Victor Bazarov
> "Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:gw6gd.7632$Ae....@newsread1.dllstx09.us.to.verio.net...
>
>>Alex Vinokur wrote:
>>
>>>"Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:11Rfd.7248$Ae....@newsread1.dllstx09.us.to.verio.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&lr=&c2coff=1&sitesearch=www.parashift.com&q=%22delete+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/docs/SourcePro/stdlibref/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
Alex Vinokur
"Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:Ztwgd.7712$Ae....@newsread1.dllstx09.us.to.verio.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]
Victor Bazarov
> "Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:Ztwgd.7712$Ae....@newsread1.dllstx09.us.to.verio.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
Alex Vinokur
"Victor Bazarov" <v.Aba...@comAcast.net> wrote in message news:tZxgd.7716$Ae....@newsread1.dllstx09.us.to.verio.net...
Here are some samples of using overloaded and original "operator new".
Done under impression by
http://www.icce.rug.nl/documents/cplusplus/cplusplus09.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 -----------