Unofficial Managed C++ FAQ

List of entries

  1. Compiler switches incompatible with /clr

  2. Why can't I use the overloaded operators on type 'X'

  3. Can I overload managed operators on my MC++ classes?

  4. How can I define a method that takes an 'ref' argument?

  5. How can I define a method that takes an array of ints by
    reference?

  6. Why do I always get an error when trying to add an
    attribute to an enum value?

Last Modified: June 1, 2002

Compiler switches incompatible with /clr

The following options are incompatible with the /clr compiler
switch:

Why can't I use the overloaded operators on type 'X'

If type 'X' is a reference object, you won't be able to consume any of the
overloaded managed operators it might have defined. This is because there's a
real impedance mismatch between operator overloading and the fact that in MC++
reference objects have to be accessed through pointers. Since standard C++,
from which MC++ sort of came out, explicitly defines semantics for standard
operators on pointers, such as the meaning of order relations (<, >, =, etc.),
the use of actual operators would conflict with them.

Note that you should be able to use some overloaded operators on value types,
though.

Can I overload managed operators on my MC++ classes?

Yes, using the appropriate operator name (such as op_Addition.
However, not all managed operators defined by the CLR can be overloaded on the
first release of MC++, because of compiler bugs. Look
here for detailed information on those.

How can I define a method that takes an 'ref' argument?

If you want to define a method that takes a reference argument (that is, and
in/out argument) that C# programs can see defined as "ref", you can use the C++
reference (&) syntax.

However, if the type of the argument is one of the basic types, and you try to
use the C++ name for the type, this won't compile at first. For example, this
won't work:



      void MethodWithRef(int& v);

The simplest workaround is to use the CLR's typename, instead:



      void MethodWithRef(System::Int32& v);

How can I define a method that takes an array of ints by reference?

Try something like this:



      void MethodWithRef(System::Int32 (&intArray) __gc[]) {

         const size_t arraySize = 2;

         intArray = new int __gc[arraySize];

         // fill array

      }

Why do I always get an error when trying to add an attribute to an enum value?

You're probably doing something like this:



      public __gc class MyCustomAttribute : public Attribute

      {

         public:

            MyCustomAttribute(String* desc) {

            }

         // rest of implementation

      };


      __value enum MyEnum {

         [ MyCustomAttribute(S"Value 1") ]

         value_1 = 1,

         [ MyCustomAttribute(S"Value 2") ]

         value_2 = 2,

      };

And you're getting a C2143 and a few other errors, right? The cause is a bug in
the current MC++ compiler that doesn't allow it to parse attributes in an enum
declaration, so there's no workaround for it.