Click here to Skip to main content
14,542,590 members

Introduction to Managed C++

Rate this:
4.78 (20 votes)
Please Sign up or sign in to vote.
4.78 (20 votes)
7 Jul 2002CPOL
An attempt to get a beginner started on Managed C++


This is intended as a jump-start tutorial for Managed C++ programming. It does not cover every aspect of the managed extensions, but it does cover certain areas that are often puzzling to someone coming from a C# or a native C++ background. The article assumes that the reader is familiar with the basic elements of .NET technology and that the user can understand C++ code when he or she sees it.

Simple program

#using <mscorlib.dll>

using namespace System;

int _tmain(void)
    return 0;

#using is a preprocessor directive that imports meta data from a .NET module or library. In our small program we have used #using on mscorlib.dll which is an essential library for all .NET programs. Just using #using gives us access to all the namespaces and classes in that module or library. But we'd have to type the fully qualified name for each class we use, including the namespace or namespaces if any. We can use the using namespace directive which will allow us to use class names without having to use the namespace-name explicitly.

For example I can write this :-

System::Console::WriteLine("Hello Earth");

But if I have used a using namespace directive, then I can use :-

using namespace System;
Console::WriteLine("Hello Earth");

It's mostly a matter of readability. Some people might prefer to use fully qualified names to improve the clarity of their code. And sometimes you are forced to, as when two namespaces have classes with the same names in which case the compiler gets confused.

Managed classes

A managed class is a class that is garbage collected, means you don't have to delete it after using it. All that's managed for you by the common language runtime. In MC++ we create managed classes using the __gc keyword as shown below.

__gc class First
        m_name = "Anonymous";
    First(String* s)
        m_name = s;
    String* GetName()
        return m_name;
    void SetName(String* s)
        m_name = s;
    String* m_name;

Well, it looks more or less like a normal C++ class except that we have used the __gc keyword when declaring it. That marks it as managed. You'll also notice how I have used String* instead of String. This is because the String class is a managed class that can only be declared on the heap.

First* f1 = new First();
First* f2 = new First("Andrew");

Using the managed class is not dissimilar from using a normal old-style C++ class. Except that I cannot declare objects of type First, I have to declare them on the heap using First* and new. As you might observe, I have not called delete. Hey, don't look at me with that sort of gleam in your eyes as if to tell me that I should not be so careless. I didn't call delete because it's not required that I do so. This is Managed C++ we are talking about, remember. And because First is a managed class, the common language runtime will automatically delete the objects that are no longer under use, using it's garbage collector. Very handy, I say very handy!

Using properties

Take a look at the two listings below :-

//Listing A
//Listing B
f2->Name = "Colin";

Obviously the second listing is more readable. Of course using a public member variable would be a very impetuous idea and one that would result in a lot of scornful looks from most programmers. But in .NET we have properties, in fact I have some rather vague ideas that the native C++ compiler supports properties too, but since the vagueness is rather strong, I better keep quiet about that one.

__gc class First


    __property String* get_Name()
        return m_name;
    __property void set_Name(String* s)
        m_name = s;



If you have only a get_ function then your property is read-only. If you have only the set_ function you have a write-only property. And in our case, since we have both get_ and set_ functions, we have a read-and-write property. The get_ function's return type must be same as the set_ function's argument. MSDN adds that you cannot define a property that has the same name as the containing class.


Consider the function below :-

void Show(Object* o)

Rather neat, eh? It takes an object of type Object and displays it on the console. Now see this snippet of code.

String* s1 = "Hello World";

Compiles and works fine. Now see the following snippet of code.

int i = 100;
Show(i); //This won't compile

Blast! That won't even compile. You'll get compiler error C2664: 'Show' : cannot convert parameter 1 from 'int' to 'System::Object __gc *'. This is where we need to use the __box keyword.

int i = 100;

What __box does is simple. It creates a new managed object on the heap and copies the value type object into the managed object. And it returns the managed object which is actually a copy of the original value type object. This means that if you modify the managed object returned by an __box, the original object won't change at all.


Obviously if you can box, you should be able to unbox too, eh? Let's say we want to box a value object to an Object and then unbox it back to a value object. The following code snippet shows you how to accomplish this chore.

Object* o1 = __box(i);
int j = *static_cast<__box int*>(o1);
j *= 3;

Good heavens! That turned out to be rather more sinister looking than you had expected I bet. What we do is to cast the managed object to the __gc pointer on the CLR heap and then we simply dereference it. You can use dynamic_cast instead of static_cast for increased type-safety.

Native code blocks

Consider the following function.

void NativeCall()
    puts("This is printed from a native function");

As you can see, it uses purely normal non-.NET stuff. Obviously we can improve execution speed if we can compile this function as native. MC++ provides us with the #pragma managed and #pragma unmanaged preprocessor directives. We simply add a #pragma unmanaged just before the function and then add a #pragma managed just after the function.

#pragma unmanaged

void NativeCall()

#pragma managed

Now when this function is encountered during program execution, the common language runtime will pass on control to the native platform. Obviously we must use this whenever we have functions that use fully unmanaged functions. What's real neat is that we call call unmanaged functions that are marked as #pragma unmanaged from within managed blocks of code.

__value classes

Earlier I had said that managed classes cannot be allocated on the stack. Sometimes, we might have the requirement for a very simple class, often merely for storing some values. In such cases it might be desirable to have a value type class that can be allocated on the stack. That's where the __value keyword comes in. The following code snippet shows you how to declare a value type class.

__value class Second
    void Abc()

Now we can declare objects of type Second on the stack.

Second sec;

In fact we can even declare them on the heap. But remember this won't be the CLR managed heap and thus we need to delete our objects on our own.

Second* psec = __nogc new Second();
delete psec;

More reading


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Nish Nishant
United States United States
Nish Nishant is a Principal Software Architect based out of Columbus, Ohio. He has over 17 years of software industry experience in various roles including Lead Software Architect, Principal Software Engineer, and Product Manager. Nish was a Microsoft Visual C++ MVP between 2002 and 2015.

Nish is an industry acknowledged expert in the Microsoft technology stack. He authored C++/CLI in Action for Manning Publications in 2005, and had previously co-authored Extending MFC Applications with the .NET Framework for Addison Wesley in 2003. In addition, he has over 140 published technology articles on and another 250+ blog articles on his WordPress blog. Nish is vastly experienced in team management, mentoring teams, and directing all stages of software development.

Contact Nish : If you are interested in hiring Nish as a consultant, you can reach him via his google email id voidnish.

Company Website :

Comments and Discussions

QuestionWhy slowdown operation!? Pin
murti3866-Feb-07 7:19
Membermurti3866-Feb-07 7:19 
GeneralManaging MFC Pin
Jain Mohit8-Mar-04 22:00
MemberJain Mohit8-Mar-04 22:00 
GeneralPlatform SDK with Unmanaged interface Pin
PawanKishore20-Feb-04 20:09
MemberPawanKishore20-Feb-04 20:09 
GeneralManaged C++ classes Pin
ricky_casson9-Jan-04 12:37
Memberricky_casson9-Jan-04 12:37 
GeneralCreating objects of unmanaged C++ in managed C++ Pin
moist10-Aug-03 20:16
Membermoist10-Aug-03 20:16 
GeneralRe: Creating objects of unmanaged C++ in managed C++ Pin
Nish Nishant11-Aug-03 6:59
sitebuilderNish Nishant11-Aug-03 6:59 
GeneralRe: Creating objects of unmanaged C++ in managed C++ Pin
moist11-Aug-03 14:48
Membermoist11-Aug-03 14:48 
GeneralRe: Creating objects of unmanaged C++ in managed C++ Pin
Nish Nishant11-Aug-03 15:32
sitebuilderNish Nishant11-Aug-03 15:32 
QuestionWhat about C using Unmanaged C Static Libraries ? Pin
Anonymous26-May-03 1:37
MemberAnonymous26-May-03 1:37 
Generalusing Hashtable in MC++ Pin
haranath25-Apr-03 5:58
Memberharanath25-Apr-03 5:58 
GeneralRe: using Hashtable in MC++ Pin
Nemanja Trifunovic25-Apr-03 6:13
MemberNemanja Trifunovic25-Apr-03 6:13 
GeneralRe: using Hashtable in MC++ Pin
haranath27-Apr-03 21:57
Memberharanath27-Apr-03 21:57 
GeneralRe: using Hashtable in MC++ Pin
MarkTheShark17-Feb-05 12:42
MemberMarkTheShark17-Feb-05 12:42 
GeneralHello, Nishant Pin
Anthony_Yio10-Dec-02 16:52
MemberAnthony_Yio10-Dec-02 16:52 
GeneralRe: Hello, Nishant Pin
Nish Nishant26-Dec-02 10:26
sitebuilderNish Nishant26-Dec-02 10:26 
GeneralBrilliant Style Pin
Yusuf Jiruwala9-Dec-02 8:23
MemberYusuf Jiruwala9-Dec-02 8:23 
GeneralRe: Brilliant Style Pin
Nish Nishant26-Dec-02 10:25
sitebuilderNish Nishant26-Dec-02 10:25 
GeneralThanks Nish Pin
Paul Watson23-Jul-02 5:29
sitebuilderPaul Watson23-Jul-02 5:29 
GeneralRe: Thanks Nish Pin
Nish Nishant23-Jul-02 6:33
sitebuilderNish Nishant23-Jul-02 6:33 
QuestionHow slow is it? Pin
Miguel Lopes9-Jul-02 8:21
MemberMiguel Lopes9-Jul-02 8:21 
AnswerRe: How slow is it? Pin
Nish Nishant9-Jul-02 9:06
sitebuilderNish Nishant9-Jul-02 9:06 
GeneralRe: How slow is it? Pin
pankajdaga12-Jul-02 0:25
Memberpankajdaga12-Jul-02 0:25 
GeneralRe: How slow is it? Pin
Nish Nishant13-Jul-02 0:41
sitebuilderNish Nishant13-Jul-02 0:41 
AnswerRe: How slow is it? Pin
Nemanja Trifunovic23-Jul-02 6:09
MemberNemanja Trifunovic23-Jul-02 6:09 
GeneralRe: How slow is it? Pin
Nish Nishant23-Jul-02 6:37
sitebuilderNish Nishant23-Jul-02 6:37 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Posted 18 Oct 2001


50 bookmarked