Signature for managed operators

[Edward Diener]

The documentation states the names of the various managed operators but does
not give the signature for them. Is there some documentation which I have
missed that gives the correct signature ? In particular I want to implement
the op_Assign (=) operator for a __value struct.

[Jay B. Harlow [MVP - Outlook]]

Edward,
See Figure 2 at
http://msdn.microsoft.com/msdnmag/is...C/default.aspx

A more complete list can be found in the "Common Language Infrastructure
Standard" installed in "\Program Files\Microsoft Visual Studio .NET
2003\SDK\v1.1\T ool Developers Guide\docs" on VS.NET 2003.

For a printed copy see "The Common Language Infrastructure Annotated
Standard" from Addison Wesley by James S. Miller & Susann Ragsdale.

However I understand it is more then just the signature you need, you
actually add the overloaded operator to your class or structure and the
compile will add the properly named method to the assembly. As it requires
"a special bit in the MetaData (SpecialName) so that they do not collide
with the user's namespace" to be set in the IL.

missed that gives the correct signature ? In particular I want to implement the op_Assign (=) operator for a __value struct. I see op_Assign on the list, however it is supported?

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:eh******** ******@TK2MSFTN GP12.phx.gbl... The documentation states the names of the various managed operators but does not give the signature for them. Is there some documentation which I have
missed that gives the correct signature ? In particular I want to implement the op_Assign (=) operator for a __value struct.

[Edward Diener]

Jay B. Harlow [MVP - Outlook] wrote:

Edward,
See Figure 2 at
http://msdn.microsoft.com/msdnmag/is...C/default.aspx
Good article.

A more complete list can be found in the "Common Language
Infrastructure Standard" installed in "\Program Files\Microsoft
Visual Studio .NET 2003\SDK\v1.1\T ool Developers Guide\docs" on
VS.NET 2003.
Where in these .doc files is the information ?

For a printed copy see "The Common Language Infrastructure Annotated
Standard" from Addison Wesley by James S. Miller & Susann Ragsdale.

However I understand it is more then just the signature you need, you
actually add the overloaded operator to your class or structure and
the compile will add the properly named method to the assembly. As it
requires "a special bit in the MetaData (SpecialName) so that they do
not collide with the user's namespace" to be set in the IL.
I want to implement an assignment operator and an equality operator for
__value and __gc structs and classes, so that programmers can use syntax
such as:

----------------------------------------
AValue av;
AValue anv;

if (av == anv) { // etc. }
av = anv;

AClass __gc * ac;
AClass __gc * anc;

if (*ac == *anc) { // etc. }
*ac = *anc;
----------------------------------------

Is this possible using op_Equality (==) and op_Assign (=) ? If so, how do I
do it, and what is the signature of the op_Equality (==) and op_Assign (=)
static functions in my AValue or AClass classes ?

Furthermore, there is a virtual System::Object Equals method. Should I
override that and provide my own Equals implementation ? If I do so for my
class above, does Equals mean that the pointers are equal or does it mesn
that the objects are equal ? The doc was really vague about this.

Finally, what about copy constructors. The doc says that a __gc or __value
class can not have one. Is there a good reason for this ? It seems like a
really odd limitation.

missed that gives the correct signature ? In particular I want to
implement the op_Assign (=) operator for a __value struct.

I see op_Assign on the list, however it is supported?

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:eh******** ******@TK2MSFTN GP12.phx.gbl...

The documentation states the names of the various managed operators
but does not give the signature for them. Is there some
documentation which I have missed that gives the correct signature ?
In particular I want to implement the op_Assign (=) operator for a
__value struct.

[Jay B. Harlow [MVP - Outlook]]

Edward,

Where in these .doc files is the information ?
Partition I Architecture
9.3 Operator Overloading.

Did you check the table of contents?

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:ut******** *****@TK2MSFTNG P11.phx.gbl... Jay B. Harlow [MVP - Outlook] wrote:

Edward,
See Figure 2 at
http://msdn.microsoft.com/msdnmag/is...C/default.aspx
Good article.

A more complete list can be found in the "Common Language
Infrastructure Standard" installed in "\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\T ool Developers Guide\docs" on VS.NET 2003.

Where in these .doc files is the information ?

For a printed copy see "The Common Language Infrastructure Annotated
Standard" from Addison Wesley by James S. Miller & Susann Ragsdale.

However I understand it is more then just the signature you need, you
actually add the overloaded operator to your class or structure and
the compile will add the properly named method to the assembly. As it
requires "a special bit in the MetaData (SpecialName) so that they do
not collide with the user's namespace" to be set in the IL.

I want to implement an assignment operator and an equality operator for
__value and __gc structs and classes, so that programmers can use syntax
such as:

----------------------------------------
AValue av;
AValue anv;

if (av == anv) { // etc. }
av = anv;

AClass __gc * ac;
AClass __gc * anc;

if (*ac == *anc) { // etc. }
*ac = *anc;
----------------------------------------

Is this possible using op_Equality (==) and op_Assign (=) ? If so, how do

I do it, and what is the signature of the op_Equality (==) and op_Assign (=)
static functions in my AValue or AClass classes ?

Furthermore, there is a virtual System::Object Equals method. Should I
override that and provide my own Equals implementation ? If I do so for my
class above, does Equals mean that the pointers are equal or does it mesn
that the objects are equal ? The doc was really vague about this.

Finally, what about copy constructors. The doc says that a __gc or __value
class can not have one. Is there a good reason for this ? It seems like a
really odd limitation.

missed that gives the correct signature ? In particular I want to
implement the op_Assign (=) operator for a __value struct.

I see op_Assign on the list, however it is supported?

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:eh******** ******@TK2MSFTN GP12.phx.gbl...

The documentation states the names of the various managed operators
but does not give the signature for them. Is there some
documentation which I have missed that gives the correct signature ?
In particular I want to implement the op_Assign (=) operator for a
__value struct.

[Jay B. Harlow [MVP - Outlook]]

Edward,
The only other item I can offer is:

http://msdn.microsoft.com/library/de...onsSpec_20.asp

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:ut******** *****@TK2MSFTNG P11.phx.gbl...

Jay B. Harlow [MVP - Outlook] wrote:

Edward,
See Figure 2 at
http://msdn.microsoft.com/msdnmag/is...C/default.aspx
Good article.

A more complete list can be found in the "Common Language
Infrastructure Standard" installed in "\Program Files\Microsoft
Visual Studio .NET 2003\SDK\v1.1\T ool Developers Guide\docs" on
VS.NET 2003.

Where in these .doc files is the information ?

For a printed copy see "The Common Language Infrastructure Annotated
Standard" from Addison Wesley by James S. Miller & Susann Ragsdale.

However I understand it is more then just the signature you need, you
actually add the overloaded operator to your class or structure and
the compile will add the properly named method to the assembly. As it
requires "a special bit in the MetaData (SpecialName) so that they do
not collide with the user's namespace" to be set in the IL.

I want to implement an assignment operator and an equality operator for
__value and __gc structs and classes, so that programmers can use syntax
such as:

----------------------------------------
AValue av;
AValue anv;

if (av == anv) { // etc. }
av = anv;

AClass __gc * ac;
AClass __gc * anc;

if (*ac == *anc) { // etc. }
*ac = *anc;
----------------------------------------

Is this possible using op_Equality (==) and op_Assign (=) ? If so, how do

I do it, and what is the signature of the op_Equality (==) and op_Assign (=)
static functions in my AValue or AClass classes ?

Furthermore, there is a virtual System::Object Equals method. Should I
override that and provide my own Equals implementation ? If I do so for my
class above, does Equals mean that the pointers are equal or does it mesn
that the objects are equal ? The doc was really vague about this.

Finally, what about copy constructors. The doc says that a __gc or __value
class can not have one. Is there a good reason for this ? It seems like a
really odd limitation.

missed that gives the correct signature ? In particular I want to
implement the op_Assign (=) operator for a __value struct.

I see op_Assign on the list, however it is supported?

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:eh******** ******@TK2MSFTN GP12.phx.gbl...

The documentation states the names of the various managed operators
but does not give the signature for them. Is there some
documentation which I have missed that gives the correct signature ?
In particular I want to implement the op_Assign (=) operator for a
__value struct.

[Edward Diener]

Jay B. Harlow [MVP - Outlook] wrote:

Edward,

Where in these .doc files is the information ?

Partition I Architecture
9.3 Operator Overloading.

Did you check the table of contents?

Hope this helps

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work:

_gc class AC
{
public:
static bool op_Equality(AC * first,AC* second)
{ bool ret; /* some code which sets ret based on values in each AC */
return(ret); }
};

AC * fac = new AC();
AC * sac = new AC();
// Code which changes some values in each AC etc.
if (fac == sac) { } // Compares the pointers, not the values
if (*fac == *sac ) { } // Does this match my op_Equality above ? I think
not.

It would have been better if op_Equality ( and binary operators in general )
for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second);

then "if (*fac == *sac ) { }" would work. Because of this, implementing the
operators using the op_XXX seems to be a waste of time. The only advantage
in doing so for __gc classes/structs is that the user can call op_XXX
directly instead of using infix notation.

[Jay B. Harlow [MVP - Outlook]]

Edward,

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work: My mistake, I read your question as wanting the names, not the signatures.

I haven't tried it, An easy way to get this signatures may be to simply
define all the operators in a C# project, reference this project in your
Managed C++ project, then use object browser, to see the syntax, or use
ILDASM to see the syntax.
then "if (*fac == *sac ) { }" would work. Because of this, implementing the operators using the op_XXX seems to be a waste of time. The only advantage
in doing so for __gc classes/structs is that the user can call op_XXX
directly instead of using infix notation. Reading the various links I gave, specifically the Managed C++ spec page, I
would agree with that statement.

However if you do define the op_XXX in the correct format, then those
routines are usable for other language such as C# & VB.NET (VB.NET the
Whidbey edition). Seeing as most of my managed C++ would be for libraries to
be consumed by C# or VB.NET, this makes sense to me. I do agree, if I were
attempting an entire Managed C++ solution, this may get really annoying,
really quick! ;-)

I'm really curious as to why one needs to use the op_XXX syntax as oppose to
the normal operator+ syntax. I would expect in a __gc class that operator+
(or __gc operator+) would create the proper routine with the proper
parameters, and then the rest of your code would work as one would expect!

I have not looked at the Whidbey version of C++ to know if MS has improved
this yet or not...
It would have been better if op_Equality ( and binary operators in general ) for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second); Reading the Managed C++ spec page I gave in my other post, I get the
impression this should be:
static bool op_Equality(T first,T second);
Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:uu******** *****@TK2MSFTNG P11.phx.gbl... Jay B. Harlow [MVP - Outlook] wrote:

Edward,

Where in these .doc files is the information ?
Partition I Architecture
9.3 Operator Overloading.

Did you check the table of contents?

Hope this helps

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work:

_gc class AC
{
public:
static bool op_Equality(AC * first,AC* second)
{ bool ret; /* some code which sets ret based on values in each AC */
return(ret); }
};

AC * fac = new AC();
AC * sac = new AC();
// Code which changes some values in each AC etc.
if (fac == sac) { } // Compares the pointers, not the values
if (*fac == *sac ) { } // Does this match my op_Equality above ? I think
not.

It would have been better if op_Equality ( and binary operators in

general ) for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second);

then "if (*fac == *sac ) { }" would work. Because of this, implementing the operators using the op_XXX seems to be a waste of time. The only advantage
in doing so for __gc classes/structs is that the user can call op_XXX
directly instead of using infix notation.

[Edward Diener]

Jay B. Harlow [MVP - Outlook] wrote:

Edward,

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work: My mistake, I read your question as wanting the names, not the
signatures.

No, the signatures. The MSDN doc on Managed C++ doesn't have that
information.

I haven't tried it, An easy way to get this signatures may be to
simply define all the operators in a C# project, reference this
project in your Managed C++ project, then use object browser, to see
the syntax, or use ILDASM to see the syntax.
I found the signatures in one of the online articles you mentioned. I am
going to pick up Richard Grimes' book on Managed C++ today. Although the
MSDN docs on it are decent, there are too many incomplete areas and, aside
from this thread, most of my other queries on this NG have gone unanswered.

then "if (*fac == *sac ) { }" would work. Because of this,
implementing the operators using the op_XXX seems to be a waste of
time. The only advantage in doing so for __gc classes/structs is
that the user can call op_XXX directly instead of using infix
notation. Reading the various links I gave, specifically the Managed C++ spec
page, I would agree with that statement.

However in another part of the MSDN doc, it is suggested that if the
signature were changed to use references, then the infix notation in __gc
classes would work. Trying to figure out what is true or not regarding this
is a PITA. Furthermore my code is a component and needs to be CLS compliant.
The doc for Managed C++ is almost completely vague on what __gc class member
function usages are CLS compliant or not. This is easily the weakest part of
the doc. Evidently attempting to write .NET components in MC++, rather than
MS's darling C#, was something that MS doesn't encourage greatly.

However if you do define the op_XXX in the correct format, then those
routines are usable for other language such as C# & VB.NET (VB.NET the
Whidbey edition). Seeing as most of my managed C++ would be for
libraries to be consumed by C# or VB.NET, this makes sense to me. I
do agree, if I were attempting an entire Managed C++ solution, this
may get really annoying, really quick! ;-)
See above. Yes, I want to define it in the correct format, if I only knew
what that is for MC++. I have gathered, unless I am greatly wrong, that
using __gc pointers in MC++ is the same as using object references in C#. So
if one uses references instead in MC++, I gather that this is not CLS
compliant since it has no analogy to anything in C# and CLS.

I'm really curious as to why one needs to use the op_XXX syntax as
oppose to the normal operator+ syntax. I would expect in a __gc class
that operator+ (or __gc operator+) would create the proper routine
with the proper parameters, and then the rest of your code would work
as one would expect!
Definitely not according to the docs. Using any C++ operator syntax is
forbidden in __gc classes. Some of the other things that are forbidden are
really strange. For instance one can't use const data members in __gc or
__value classes. I guess if one would normally have a const data member in a
__gc/__value class, one needs to create a read-only property instead. I am
still trying to figure out whether passing a const T __gc * is CLS compliant
but I expect not. In that case how does one pass an __gc object which is not
to be modified ? These limitations are gnarly problems for standard C++
programmers who are use to much greater flexibility in their programming
paradigms.

I have not looked at the Whidbey version of C++ to know if MS has
improved this yet or not...
There is a new binding for MC++ called CLI, with Herb Sutter being the chief
architect of that. How that will eventually change MC++ -> CLI remains to be
seen.

It would have been better if op_Equality ( and binary operators in
general ) for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second); Reading the Managed C++ spec page I gave in my other post, I get the
impression this should be:

static bool op_Equality(T first,T second);

For a __value class, yes. For a __gc class I am still not sure whether
references can be used instead of pointers. See above.

I do hope the Grimes' book clears up many things. My previous reading of his
ATL books indicates that he is a very good amd thorough technical writer, in
that stratosphere ot technical writing ability about MS technologies that
Richter and very few others inhabit. So I hope I am not disappointed.

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:uu******** *****@TK2MSFTNG P11.phx.gbl...

Jay B. Harlow [MVP - Outlook] wrote:

Edward,
Where in these .doc files is the information ?

Partition I Architecture
9.3 Operator Overloading.

Did you check the table of contents?

Hope this helps

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work:

_gc class AC
{
public:
static bool op_Equality(AC * first,AC* second)
{ bool ret; /* some code which sets ret based on values in each AC
*/ return(ret); }
};

AC * fac = new AC();
AC * sac = new AC();
// Code which changes some values in each AC etc.
if (fac == sac) { } // Compares the pointers, not the values
if (*fac == *sac ) { } // Does this match my op_Equality above ? I
think not.

It would have been better if op_Equality ( and binary operators in
general ) for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second);

then "if (*fac == *sac ) { }" would work. Because of this,
implementing the operators using the op_XXX seems to be a waste of
time. The only advantage in doing so for __gc classes/structs is
that the user can call op_XXX directly instead of using infix
notation.

[Jay B. Harlow [MVP - Outlook]]

Edward,

Definitely not according to the docs. Using any C++ operator syntax is
forbidden in __gc classes. Some of the other things that are forbidden are I know its forbidden, I was questioning why! The point I was trying to make
is that __gc should say, do operator overloading the CLR way! which would
eliminate most if not all your problems! ;-)

Let me know if the Grimes book covers it.

Good Luck

Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:eh******** ******@TK2MSFTN GP12.phx.gbl... Jay B. Harlow [MVP - Outlook] wrote:

Edward,

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work: My mistake, I read your question as wanting the names, not the
signatures.

No, the signatures. The MSDN doc on Managed C++ doesn't have that
information.

I haven't tried it, An easy way to get this signatures may be to
simply define all the operators in a C# project, reference this
project in your Managed C++ project, then use object browser, to see
the syntax, or use ILDASM to see the syntax.

I found the signatures in one of the online articles you mentioned. I am
going to pick up Richard Grimes' book on Managed C++ today. Although the
MSDN docs on it are decent, there are too many incomplete areas and, aside
from this thread, most of my other queries on this NG have gone

unanswered.

then "if (*fac == *sac ) { }" would work. Because of this,
implementing the operators using the op_XXX seems to be a waste of
time. The only advantage in doing so for __gc classes/structs is
that the user can call op_XXX directly instead of using infix
notation. Reading the various links I gave, specifically the Managed C++ spec
page, I would agree with that statement.

However in another part of the MSDN doc, it is suggested that if the
signature were changed to use references, then the infix notation in __gc
classes would work. Trying to figure out what is true or not regarding

this is a PITA. Furthermore my code is a component and needs to be CLS compliant. The doc for Managed C++ is almost completely vague on what __gc class member function usages are CLS compliant or not. This is easily the weakest part of the doc. Evidently attempting to write .NET components in MC++, rather than MS's darling C#, was something that MS doesn't encourage greatly.

However if you do define the op_XXX in the correct format, then those
routines are usable for other language such as C# & VB.NET (VB.NET the
Whidbey edition). Seeing as most of my managed C++ would be for
libraries to be consumed by C# or VB.NET, this makes sense to me. I
do agree, if I were attempting an entire Managed C++ solution, this
may get really annoying, really quick! ;-)
See above. Yes, I want to define it in the correct format, if I only knew
what that is for MC++. I have gathered, unless I am greatly wrong, that
using __gc pointers in MC++ is the same as using object references in C#.

So if one uses references instead in MC++, I gather that this is not CLS
compliant since it has no analogy to anything in C# and CLS.

I'm really curious as to why one needs to use the op_XXX syntax as
oppose to the normal operator+ syntax. I would expect in a __gc class
that operator+ (or __gc operator+) would create the proper routine
with the proper parameters, and then the rest of your code would work
as one would expect!
Definitely not according to the docs. Using any C++ operator syntax is
forbidden in __gc classes. Some of the other things that are forbidden are
really strange. For instance one can't use const data members in __gc or
__value classes. I guess if one would normally have a const data member in

a __gc/__value class, one needs to create a read-only property instead. I am
still trying to figure out whether passing a const T __gc * is CLS compliant but I expect not. In that case how does one pass an __gc object which is not to be modified ? These limitations are gnarly problems for standard C++
programmers who are use to much greater flexibility in their programming
paradigms.

I have not looked at the Whidbey version of C++ to know if MS has
improved this yet or not...
There is a new binding for MC++ called CLI, with Herb Sutter being the

chief architect of that. How that will eventually change MC++ -> CLI remains to be seen.

It would have been better if op_Equality ( and binary operators in
general ) for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second); Reading the Managed C++ spec page I gave in my other post, I get the
impression this should be:

static bool op_Equality(T first,T second);

For a __value class, yes. For a __gc class I am still not sure whether
references can be used instead of pointers. See above.

I do hope the Grimes' book clears up many things. My previous reading of

his ATL books indicates that he is a very good amd thorough technical writer, in that stratosphere ot technical writing ability about MS technologies that
Richter and very few others inhabit. So I hope I am not disappointed.

Hope this helps
Jay

"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:uu******** *****@TK2MSFTNG P11.phx.gbl...

Jay B. Harlow [MVP - Outlook] wrote:
Edward,
> Where in these .doc files is the information ?

Partition I Architecture
9.3 Operator Overloading.

Did you check the table of contents?

Hope this helps

It does. However it appears that defining operators for MC++ __gc
classes/structs does not really work:

_gc class AC
{
public:
static bool op_Equality(AC * first,AC* second)
{ bool ret; /* some code which sets ret based on values in each AC
*/ return(ret); }
};

AC * fac = new AC();
AC * sac = new AC();
// Code which changes some values in each AC etc.
if (fac == sac) { } // Compares the pointers, not the values
if (*fac == *sac ) { } // Does this match my op_Equality above ? I
think not.

It would have been better if op_Equality ( and binary operators in
general ) for __gc classes/structs had the signature instead of:

static bool op_Equality(T & first,T & second);

then "if (*fac == *sac ) { }" would work. Because of this,
implementing the operators using the op_XXX seems to be a waste of
time. The only advantage in doing so for __gc classes/structs is
that the user can call op_XXX directly instead of using infix
notation.

[Ronald Laeremans [MSFT]]

If you look at the signature for op_Assign, you will see that the way it is
defined is bogus since it takes its LHS by value so it simply cannot assign.
Apart from that even if you were to define it, there is no language
targeting the CLR that would ever call it. This was a partially designed and
later abandoned part of the bcl spec that was left in there by accident.

And for operators on reference types in MC++ you have correctly discovered
that there is no usable way to call them using infix notation. Due to using
pointer syntax for __gc types in MC++ we more or less painted ourselves into
a corner. C++ support for the CLR in the Whidbey version completely
addresses that issue.

The following links to the specification for that.

http://www.ecma-international.org/ne...-PR.pdf&e=7418

Ronald Laeremans
Visual C++
"Edward Diener" <ed******@tropi csoft.com> wrote in message
news:eh******** ******@TK2MSFTN GP12.phx.gbl...

The documentation states the names of the various managed operators but does not give the signature for them. Is there some documentation which I have
missed that gives the correct signature ? In particular I want to implement the op_Assign (=) operator for a __value struct.