Re: /MD vs /MT

"mathieu" <mathieu.malaterre@gmail.com> ha scritto nel messaggio
news:b6e9a3bf-7c8a-4c9c-852d-530232359685@f63g2000hsf.googlegroups.com...


I think this is one of the cases.


Doug's post was very clear and correct, as usual.
I just try to elaborate a bit on Doug's Case 2, to try to make it more clear
for you.

Suppose you have a DLL called MyClassCPP.dll, which defines and exports a
C++ class like this:

 class MyClass
 {
   public:
     MyClass();
     ~MyClass();

     void DoSomething( const std::string & s );
 };

So, this MyClassCPP.dll has a C++ interface.

In that case, you are in "Doug's Case 1".

But suppose that you want to make that DLL a "Doug's Case 2" DLL.

The first thing you should do, is to wrap this C++ class interface into a
C-like interface, and only use C-like interface as DLL interface.
(You can use C++ *inside* the DLL, but the interface must be pure C.)

Moreover, every instance of the class must be built inside the DLL, and must
be freed inside the DLL, too.

i.e. the DLL should be like a "monad", which only communicates with the
external world using a C-like interface, and every heap allocation ('new')
must be done inside the DLL, and that heap memory must be freed ('delete')
in the same DLL.

Call this "Doug's Case 2" DLL MyClassC.dll.

This DLL may export the following functions (C-like interface):

 MyClass_New /* kind of corresponds to 'new MyClass' */
 MyClass_Delete /* kind of corresponds to 'delete MyClass' */
 MyClass_DoSomething /* corresponds to MyClass::DoSomething */

The problem is that you must refer to a particular MyClass class instance
when you call this C functions
i.e. you need the C++ "this" pointer.
You can wrap that C++ "this" pointer in a void * pointer, or an unsigned
int, etc.

 So, in your DLL header file you may have:

<code>

 typedef void * MYCLASS;

 MYCLASS MyClass_New( void );
 void MyClass_Delete( MYCLASS c );
 void MyClass_DoSomething( MYCLASS c, const char * s );

 // void MyClass_DoSomethingElse( MYCLASS c, ... other parameters ... );

</code>

The above is the interface that the DLL client uses: as you can see, it is
just a C-like interface (you should wrap that using the classic #ifdef
__cplusplus extern "C" { ... stuff).

Let's see how you could implement that in your DLL.
You can still use *C++* in your DLL for class main implementation, you just
need to wrap that into a C interface.
So, you can have code like this:

<code>

 MYCLASS MyClass_New( void )
 {
     // Create a new instance of MyClass class in the DLL's heap
     MyClass * c = new MyClass();

     // [See note after code]

     // Return the "opaque" pointer
     return (MYCLASS)c;
 }

 void MyClass_Delete( MYCLASS c )
 {
    // Check that the pointer is valid
    ASSERT( c != NULL );

    // Get our MyClass back
    MyClass * p = (MyClass *)c;

    // Delete from DLL's heap
    delete p;
 }

 void MyClass_DoSomething( MYCLASS c, const char * s )
 {
    // Check that the pointer is valid
    ASSERT( c != NULL );

    // Get our MyClass back
    MyClass * p = (MyClass *)c;

    // Call method
    p->DoSomething( s );
    // Note that there is an implicit conversion
    // from const char * and std::string;
    // std::string const reference was in MyClass::DoSomething
    // prototype
 }

</code>

So, you can still use C++ in your DLL. You just need to wrap C++ stuff into
a thin C-interface.

An important note:

In C++, "everyone" (e.g. standard library class methods, custom class
methods...) can throw exceptions. You must make sure that those exceptions
do not cross your DLL boundaries.
So, you may consider putting a try/catch guard inside every C-interface
function body, to capture exceptions and convert them to something that C
language likes, like return error codes.

For example, in case of 'new', if there is a problem in allocating object, a
std::bad_alloc exception is thrown by 'new'.
You don't want this exception to cross your C-interface DLL.
So, you should catch that exception, and return NULL to the caller.

In general, you can use code like this in your C wrappers:

   try
   {
         // Do C++ stuff...
   }
   catch ( std::exception & )
   {
        // Catch standard exceptions and return error codes
        // using the C-like interface
   }

HTH,
Giovanni