This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.


  Memory Allocation / DLLs / Reference Counting
  Submitted by

(This applies to Win32 primarily) For starters, it is generally a bad idea to free/delete memory returned from a dll function inside another dll/exe. The opposite, new in an exe, and delete in a dll is also true. This depends on which heap is used, but both will almost certainly fail.

For example:

// dllTest.h
sSomething* createSomething();

// dllTest.cpp sSomething* createSomething() { return new sSomething; }

The client might write in an exe something like:

// exeTest.cpp
sSomething* mySomething = createSomething();
// ...
delete mySomething; // <- problem 

This point is made, more clearly perhaps, in "Programming Applications for MS Windows 4th Ed" by Jeffrey Richter (pg 678). The way to solve this problem, is to include a method to delete any objects that are allocated inside the dll:

  // dllTest.h
  void deleteSomething(sSomething*);

// dllTest.cpp void deleteSomething(sSomething* obj) { delete obj; }

Now consider the case where you wish to use a simple base object to implement reference counting.

For example:

// CObject.h -- part of myDll.dll
class CObject.h
  void addRef() { m_refCount++; }
  void release();

CObject() : m_refCount(1) { ... } };

// CObject.cpp void CObject::release() { if ( (--m_refCount) <= 0) delete this; }

A client might be tempted to create an instance of some derived object, say CTexture, like so:

  // EXEtest.cpp
  CTexture* txr = new CTexture; // <- uhmm?

  // ...
  txr-release(); // <- crash!?! 

Here we have the same basic problem (only reversed). Because the object is created by the exe, but will be released by the dll, it will crash.

Luckily the fix is somewhat simple. Actually, I've seen two solutions. One is to override the 'new' operator for any reference-counted class. The operator is then able to malloc memory from the same heap that the relase() call will free from. This can be done with a simple macro inside each class's .h / .cpp file. However, MFC likes to "#define new DEBUG_NEW" for debug builds, so it is possible that you might have problems there.

The other is to do the same basic thing, but use a static 'createInstance()' method. (Making the constructor/destructors protected to prevent accidental new'ing.)

// Texture.h
class CTexture : public CObject
  static void createInstance(CTexture** txr);

// Texture.cpp void CTexture::createInstance(CTexture** txr) { *txr = new CTexture; }

Using a static createInstance method per class has the 'benefit' of providing a simple class factory method for dynamic object creation:

For example:

// EXETest.cpp
CTexture* txr = NULL;
CObject::createInstance(CLSID_Texture, (CObject**)&CTexture);
// ^ maps CLSID_Texture to the static function pointer
// "CTexture::createInstance(...)", calls it, and returns the
// correct object instance.

This is a bit more than I intended to write for a tip, but maybe someone will find it useful.


The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.


Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.