Managed Extensions for C++

Managed Extensions for C++ or Managed C++ is a deprecated set of language extensions for C++, including grammatical and syntactic extensions, keywords and attributes, to bring the C++ syntax and language to the .NET Framework. These extensions were created by Microsoft to allow C++ code to be targeted to the Common Language Runtime (CLR) in the form of managed code, as well as continue to interoperate with native code.

In 2004, the Managed C++ extensions were significantly revised to clarify and simplify syntax and expand functionality to include managed generics. These new extensions were designated C++/CLI and included in Microsoft Visual Studio 2005. The term Managed C++ and the extensions it refers to are thus deprecated and superseded by the new extensions.

History

Microsoft introduced Managed Extensions for C++ in Microsoft Visual C++ 2002 (MSVC++). Microsoft attempted to minimize the deviations between standard C++ and Managed Extensions for C++, resulting in core differences between the two being syntactically obscured. MSVC++ 2003 and 2005 also provided support for writing programs in Managed C++. In 2004, Managed Extensions for C++ was deprecated in favor of C++/CLI, a second attempt by Microsoft at supporting programming for the Common Language Infrastructure using C++.

Design

Managed refers to managed code that it is run in, or managed by, the .NET virtual machine that functions as a sandbox for enhanced security in the form of more runtime checks, such as buffer overrun checks. Additionally, applications written in Managed C++ compile to CIL—Common Intermediate Language—and not directly to native CPU instructions like standard C++ applications do.

Managed C++ code could inter-operate with any other language also targeted for the CLR such as C# and Visual Basic .NET as well as make use of features provided by the CLR such as garbage collection. This means Managed C++ occupies a unique position in the gallery of .NET languages. It is the only language that can communicate directly with .NET languages (such as C#, VB.NET) as well as native C++. The other .NET languages can only communicate with C++ code via PInvoke or COM. But since Managed C++ can communicate directly in both managed and standard C++ contexts, it is often used as a "bridge".

Functionality

Programs coded in Managed C++ provide additional functionality of the .NET Framework and the CLR. Most notable of these is garbage collection, which relieves the programmer of manual memory management. The garbage collector (GC) is handled by the CLR. Memory management is executed quite quickly, but for more performance critical applications, native, unmanaged code is most likely the preferred option.

Managed C++ is geared towards object-oriented programming. A major difference between standard C++ and Managed C++ is that multiple inheritance is not supported, and a class managed under the CLR's garbage collector cannot inherit more than one class. This is because of a limitation of the CLR.

Key features:

Advantages over native code

  • Managed and unmanaged code can be mixed together in the same CLI assembly seamlessly. This allows the programmer to keep unmanaged code that cannot be ported over to the .NET Framework without re-writing it completely. Some ramifications of using this hybrid convention are present though.
  • Managed C++ is the only language that can contain unmanaged code and natively communicate with all other .NET languages. Managed C++ is thus very convenient for interoperability between programmers who use different languages, including those in the .NET theater and those who use standard C++.

Disadvantages compared to unmanaged code

  • Managed C++ introduces a lot of new keywords and syntactic conventions that can impair the readability of code, especially if C++ code is included directly and interacts directly with Managed C++ code in the same assembly.
  • Managed C++ is superseded by C++/CLI and thus obsolete as C++/CLI has been standardized.

Disadvantages compared to fully managed code

  • Managed C++ requires a slightly longer development time than other .NET languages that could be applied to projects that still produce the same results. The use of pointers may or may not be a requirement, because managed C++ has both value types (__value struct and __value class) and reference types (__gc struct and __gc class).
  • Managed C++ fully support ASP.NET web applications, even though the development is more difficult than with other .NET languages, including some other third party languages.
  • Managed C++ includes only support for templates (for interoperability with native C++) but no support for generics (for interoperability with all the other .NET languages). C++/CLI supports both templates (at compile time) and generics (at run time).

Examples

The following examples depict the use of Managed C++ as compared to standard C++:

// Gello.cpp

// new using directive
#using <mscorlib.dll>

// another using namespace directive.
using namespace System;

int main() {
    Console::WriteLine("Hello, world!");
    return 0;
}

A new preprocessor directive #using <mscorlib.dll> is required. In addition to that, more #using directives are required to import more libraries to use more namespaces in the Base Class Library, such as #using <System.Windows.Forms.dll> and using namespace System::Windows::Forms; to use Windows Forms.

$ cl.exe hello.cpp /clr

/clr enables any code referencing the .NET Framework to be compiled as CIL.

// GarbageCollected.cpp

#using <mscorlib.dll>

__gc class GarbageCollected {
    int* i;
    char* g;
    float* j;
};

int main() {
    while (true) {
        GarbageCollected^ gc = gcnew GarbageCollected();
    }
    return 0;
}

The preceding code can be compiled and executed without any fear of memory leaks. Because class GarbageCollected is managed under the garbage collector, there is no need to call the delete operator. To achieve the same with unmanaged code, the delete keyword is required:

// NotGarbageCollected.cpp

class NotGarbageCollected {
    int* i;
    char* g;
    float* j;
};

int main() {
    while (true) {
        NotGarbageCollected* g = new NotGarbageCollected();
        // ...
        delete g;
    }
    return 0;
}

Notes:

public __gc class MyClass {
    // ...
};

A __gc designated class can be destroyed manually using the delete keyword, but only if the __gc designated class has a user-defined destructor.

// MyInterface.cpp
#using <mscorlib.dll>

__gc __interface MyInterface {
    void init();
    int common();
}

The preceding code must be compiled with /clr and /LD to produce a simple .DLL file.

Notes:

Comparison with other languages

The following contains main points and programmatic standards that differ between Managed C++ and other well known programming languages that are similar in concept.

Standard C++

Advantages

  • Managed C++ supports a greater degree of reflection than regular C++, which is generally much more convenient depending on the function of the code, or what the code is intended for.
  • Managed C++ can inter-operate with all other .NET capable languages, including other third party languages.
  • Managed C++ is garbage collected. In standard C++, memory management and allocation is the responsibility of the programmer.

Disadvantages

  • native C++ code may be faster at runtime.
  • C++ does not require an installation of an associated compiler and managed runtime environment on the target system
  • C++ supports generic programming. Until the final release of C++/CLI however, Managed C++ programmers must revert for workarounds for using generics.
  • C++ supports the keyword const and const correctness. Managed C++, like Java and C#, does not contain this feature. An alternative is to make a managed class immutable, or restricting set accessors on public interfaces.
  • C++ code is not constricted by the CLR's restrictions. For example, the CLR does not allow classes to inherit other classes privately nor protected, thus the following will produce a compiler error:
public __gc class First {
    int i;
};

public __gc class Second: private First { 
    int h; 
    i = h; 
}; // error

public __gc class Third: protected First {
    int h;
    i = h;
}; // error
  • Managed C++ __gc classes cannot inherit from more than one class, as such the following will produce a compiler error:
__gc class First {};
__gc class Second {};
__gc class Third: public First, public Second {}; // will produce an error

C#

Differences

  • While C# supports pointers just as in C++, this feature is turned off by default.

Advantages

  • C# must use the .NET Framework and provided class libraries to access the computer system on a low level.
  • Porting over applications to the .NET Framework from C or C++ is much easier to do using Managed C++.
  • The Microsoft Visual C++ .NET compiler, which compiles Managed C++ to target the .NET Framework, produces a much more matured set of instructions in its resultant assembly, thus improving performance.

Disadvantages

  • Like Java, C# is syntactically simpler when dealing with managed code.
  • C# can achieve basically the same result as Managed C++, as all syntactic and structural conventions remain strikingly similar.
  • Managed C++, though it is a strongly typed language due to its introduction into the CLR, can be prone to errors if unmanaged compiled code is introduced in the same codebase, while C# is pure MSIL.

Java

Differences

  • Running Java code requires an appropriate virtual machine, while running Managed C++ code requires an appropriate implementation of the .NET Framework.

Advantages

  • Managed C++ can access the computer system on a low level interface much more easily than Java. Java programmers must use the JNI (Java Native Interface) to use low level services of the host operating system.

Disadvantages

  • Java provides a documentation on the source code, while Managed C++ does not.
  • Java has many other development tools available for Java programmers to use, while Managed C++ is only available under Visual Studio .NET.

See also