Encrypt.exe

You're kidding me right?
Making a basic windows app with Managed C++, C#, VB.NET is so easy it's hardly worth being called programming.... Drag & drop a few controls, set some properties & event handlers and call it good..

I've been through C, C++, Managed C++ and C# in my job and using the .Net stuff is THE EASIEST of anything to make a windows app..

Also - you don't HAVE to use Managed C++, you can still use MFC, or plain old Win32 code if you're really into self-punishment

Masochism?
Mortification?

>_> You are saying strange things about me >_>.
xD Eitherway the problem with managed C++ was that you had to use their custom string class. Ok fine that's not too bad. But then there was no suitable way to convert from a standard string.

And i couldn't just use the managed string because it is immutable and one other reason that i can't remember.

....Wait a minute.

Oh nvm. Ok.

char* still works in Managed c++
and you can convert it just fine: System::Runtime::InteropServices::Marshal::PtrToSt ringAnsi((IntPtr)(void*)pChar);
or
LPCTSTR str = static_cast<LPCTSTR>(Marshal::StringToHGlobalAnsi( gcString).ToPointer());
...
Marshal::FreeHGlobal(const_cast<LPTSTR>(str)); //since you're dealing with 'non-managed' resources here you need to free the memory yourself.


though natively the .net strings are unicode which could create some other issues.

I mix native C++ strings & .NET strings all day long

Ok Line by Line:

LPCTSTR str = static_cast<LPCTSTR>(Marshal::StringToHGlobalAnsi( gcString).ToPointer());

LPCTSTR str = a 'long pointer const string' (there is a madness to the naming convention ) but it's basically the same as 'const char*'

so we're defining a old fashioned char pointer called 'str' which is getting assigned with 'something'.

Then jumping to the back:
Marshal::StringToHGlobalAnsi(gcString).ToPointer() ;

The Marshal Class (which is in the System.Runtime.InteropServices namespace so you can either type all that crap out everytime or have a using statement on the top of your code which tells the compiler you're using that namespace so you don't have to label each and every little thing) is a static class ,so no need to create an instance of it, which exists basically purely to help dealing with 'non-managed' (.net) objects/memory etc.

The signature of StringToHGlobalAnsi in .NET is:
IntPtr StringToHGlobalAnsi(string s);
Which takes a .NET string ('gcstring' in above sample) and returns an IntPtr (Let's assume 32 bit Pointer on 32 bit system) to the memory address of where the converted string will be located in memory.

We're trying to cast this IntPtr we have to a LPCTSTR which we can't do until we actually take the IntPtr and cast it to what in C++ would be a void* pointer (anything in C++ can basically be cast to a void pointer). This is done by calling .ToPointer() on the IntPtr. Then we call a static_cast since we know this will work (so no runtime checking of the type like a dynamic_cast).
If you don't know about static vs dynamic cast, do some reading - you can do some great stuff with that.

Ok so Now str has your string.. and you can do whatever the heck you want with it..
When you're done with it it though you need to clean it up: Since we created a new string object in a .NET Environment (Managed C++ /C# etc) that's not garbage collected we need to get rid of it ourselves when we're done which is simply a call to FreeHGlobal

Marshal::FreeHGlobal(const_cast<LPTSTR>(str)); //since you're dealing with 'non-managed' resources here you need to free the memory yourself.



The other way around - reading a 'c++' style string into a .NET unicode string uses the first sample and the reverse logic; we cast a Char* to a void* and then to an IntPtr so that the Marshal class knows how to use it:

string s = Marshal.PtrToStringAnsi((IntPtr)(void*)pChar);


What may get confusing is that for instance in C# everything is '.'
Namespace.NameSpace.StaticClass.Method
and calling properties/methods it's all SomeObject.DoSomething(this.X); etc

While in Managed C++ you'll run into Double Colon's for Namespace & static classes
Namespace::NameSpace::Class::StaticMethod
but in your code you can still have object.DoSomething() (if you allocated on the stack) and object->DoSomething(); (if you allocated on the heap with 'new')

Good times