Mac Forum / Programming / CodeWarrior / July 2004

Hi All -

I have a rather nasty problem regarding operator delete[] and CW 9.2.
Calling delete[] on an object that was allocated with new[] but is then
POINTED to by the object's superclass results in only 1 virtual dtor
being called. This is a little tricky to explain, so maybe a simple
test program will clarify:

#include <iostream>
using namespace std;

class foo
{
public:
  virtual ~foo() { cout << "foo dtor\n"; }
};

class bar : public foo
{
public:
  virtual ~bar() { cout << "bar dtor\n"; }
};

int main()
{
  using namespace std;
 
  // This first example results in expected behavior.
  // The delete operator calls bar's dtor, which then in turn
  // calls foo's dtor.
  foo *f = new bar;
  delete( f );

  cout << "--------\n";

  // Again, expected behavior.
  // The delete[] operator calls bar's dtor, which then in turn
  // calls foo's dtor.
  bar *b = new bar[1];
  delete [] b;

  cout << "--------\n";

  // Badness!
  // The delete[] operator does not call bar's dtor. Instead,
  // the CW compiler always uses foo's dtor when calling
  // __destroy_new_array.  Can this be fixed?
  foo *foobar = new bar[1];
  delete [] foobar;
 
  return 0;
}

Sample output:

bar dtor
foo dtor
-------
bar dtor
foo dtor
-------
foo dtor

In the above example, regular new/delete work as expected -- both dtors
are called as expected. But new[]/delete[] only works if the CW
compiler KNOWS it's delete[]'ing an object of type "bar". Otherwise,
foo's dtor is mistakenly called. A quick disassembly of the code
revealed that the CW compiler is passing __destroy_new_array a pointer
to foo's dtor. I cannot figure out a way to make the compiler know to
use bar's dtor (like with using regular new/delete).

I kind of blundered into this problem while tracking down some other
memory leaks. Needless to say, I was shocked to find my app leaking a
LOT of memory. Unfortunately, this is a Mac port of a 500,000 line
MSVC++ program, and I can't easily re-engineer the codebase without
making massive changes. BTW, trying this test code on MSVC++ results in
expected behavior -- delete[] always calls bar's dtor on my PC. I guess
that's why the original PC program didn't leak memory so much;-)

Anyway, any help y'all can give would be appreciated.  TIA.

- phil