Pro Visual C++/CLI and the .NET 2.0 Platform - read book log I.

1. Implicit Virtual Overriding
For implicit overriding, the method signature of the base ref class must be the same as the derived
ref class including the prefix virtual. This means that the name of the method and the number of
parameters and their types must be identical. The return type of the method need not be identical,
but it must at least be derived from the same type as that of the base method’s return type. Also, you
need to append the new keyword override after the parameters:
virtual void Speak () override
{
}

2. Explicit or Named Virtual Overriding
Explicit or named overriding allows you to assign a method with a different name to a virtual function.
To do this, you need to declare the overriding method as virtual and then assign the name of the
virtual method being overridden:
ref class Puppy : public Dog
{
public:
virtual void Yip () = Dog::Speak
{
}
};

3. Operators
Not all operators can be overloaded. The most notable missing operators are the open and
closed square brackets [], open and closed round brackets (), gcnew, new, and delete. The Table 3-1
is a list of the operators available to be overloaded.
There are two types of operator overloads: unary and binary. You would have a good case, if you
claimed that the increment and decrement operators are a third type of operator. As you will see,
Table 3-1. Supported Managed Operators
Operators
+ - * / %
^ & | ~ !
= < > += -=
*= /= %= ^= &=
|= << >> <<= >>=
== != <= >= &&
|| ++ -- ,

4. Static Properties
As I mentioned previously, ref classes also contain static member variables. Likewise, C++/CLI
provides property syntax to support static properties, or properties that have ref class-wide storage.
Static properties are nearly identical to scalar properties except that they contain the keyword
static in their definition and they can only use static variables for storage. To create a readable and
writable static property, simply use this syntax:
property static type PropertyName
{
type get() {};
void set (type value) {};
}

5. Indexed Properties
At first glance, indexed properties may appear to provide the same functionality as array properties.
They allow you to look up a property based on an index. The syntax to allow you to do this is more
complex than that of the array property:
property type PropertyName [ indexType1, ..., indexTypeN ]
{
type get(indexType1 index1, ..., indexTypeN indexN) {};
void set(indexType1 index1, ..., indexTypeN indexN, type value) {};
}
6. Default Indexed Property
property String^ default [int]
{
String^ get(int index)
{
if (index < 0)
index = 0;
else if (index > defaultArray->Length)
index = defaultArray->Length - 1;
return defaultArray[index];
}
}

7. C++/CLI provides three different operators for type casting between classes or structs:
static_cast, dynamic_cast, and safe_cast. Each performs the process of trying to convert from
one class type to another.
l The static_cast operator cannot be verified and thus is classified as unsafe code.
l The dynamic_cast operator is slower than the static_cast operator because it verifies that the
type casting is valid. If the conversion is allowed, then the dynamic_cast operator completes the
conversion. On the other hand, if it’s not a valid conversion, then the dynamic_cast operator returns
nullptr.
if ( dynamic_cast<ClassA^>(ClassB) != 0)
{
// ClassB is of type ClassA
}

l
8. Abstract class
ref class AbstractExClass abstract
{
virtual void Method2() = 0; // unimplemented method

};

9. interface class Interface2
{
void Method3();
property String^ X;
};