This topic demonstrates how ANSI strings can be passed using C++ Interop, but the .NET Framework String represents strings in Unicode format, so conversion to ANSI is an extra step. For interoperating with other string types, see the following topics:

The following code examples use the managed, unmanaged #pragma directives to implement managed and unmanaged functions in the same file, but these functions interoperate in the same manner if defined in separate files. Because files containing only unmanaged functions do not need to be compiled with /clr (Common Language Runtime Compilation), they can retain their performance characteristics.

Example

The example demonstrates passing an ANSI string from a managed to an unmanaged function using StringToHGlobalAnsi. This method allocates memory on the unmanaged heap and returns the address after performing the conversion. This means that no pinning is necessary (because memory on the GC heap is not being passed to the unmanaged function) and that the IntPtr returned from StringToHGlobalAnsi must be explicitly released or a memory leak results.

В	Copy Code
// MarshalANSI1.cpp // compile with: /clr #include <iostream> #include <stdio.h> using namespace std; using namespace System; using namespace System::Runtime::InteropServices; #pragma unmanaged void NativeTakesAString(const char* p) { printf_s("(native) received '%s'\n", p); } #pragma managed int main() { String^ s = gcnew String("sample string"); IntPtr ip = Marshal::StringToHGlobalAnsi(s); const char* str = static_cast<const char*>(ip.ToPointer()); Console::WriteLine("(managed) passing string..."); NativeTakesAString( str ); Marshal::FreeHGlobal( ip ); }

Copy Code

// MarshalANSI1.cpp
// compile with: /clr
#include <iostream>
#include <stdio.h>

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

#pragma unmanaged

void NativeTakesAString(const char* p) {
   printf_s("(native) received '%s'\n", p);
}

#pragma managed

int main() {
   String^ s = gcnew String("sample string");
   IntPtr ip = Marshal::StringToHGlobalAnsi(s);
   const char* str = static_cast<const char*>(ip.ToPointer());

   Console::WriteLine("(managed) passing string...");
   NativeTakesAString( str );

   Marshal::FreeHGlobal( ip );
}

The following example demonstrates the data marshaling required to access an ANSI string in a managed function that is called by an unmanaged function. The managed function, on receiving the native string, can either use it directly or convert it to a managed string using the PtrToStringAnsi method, as shown.

В	Copy Code
// MarshalANSI2.cpp // compile with: /clr #include <iostream> #include <vcclr.h> using namespace std; using namespace System; using namespace System::Runtime::InteropServices; #pragma managed void ManagedStringFunc(char* s) { String^ ms = Marshal::PtrToStringAnsi(static_cast<IntPtr>(s)); Console::WriteLine("(managed): received '{0}'", ms); } #pragma unmanaged void NativeProvidesAString() { cout << "(native) calling managed func...\n"; ManagedStringFunc("test string"); } #pragma managed int main() { NativeProvidesAString(); }

Copy Code

// MarshalANSI2.cpp
// compile with: /clr
#include <iostream>
#include <vcclr.h>

using namespace std;

using namespace System;
using namespace System::Runtime::InteropServices;

#pragma managed

void ManagedStringFunc(char* s) {
   String^ ms = Marshal::PtrToStringAnsi(static_cast<IntPtr>(s));
   Console::WriteLine("(managed): received '{0}'", ms);
}

#pragma unmanaged

void NativeProvidesAString() {
   cout << "(native) calling managed func...\n";
   ManagedStringFunc("test string");
}

#pragma managed

int main() {
   NativeProvidesAString();
}

Example

See Also

Reference