Mac Forum / Programming / CodeWarrior / May 2004

Thank you very much for the responses. I've been trying to narrow down
the element of the problem and to make an example, because my code is
too large to show as an example. It took me a long time, but finally I
grabbed the core part. It seems a little complicated. The problem is
not simply the arrangement of the members, but is the problem of the
boundary of a class structure and the problem only happens in a
certain hierarchical structure. In a hierarchy, if you have a virtual
function in the base class and derived classes are connected virtual
to it, destruction of the class boundary occurs at one of the
constructor processes in derived classes. It is hard to explain by the
word, so I will copy and past my example program. In this case, member
variables of the base class (A) are arranged from private member m to
public members x, y, and n in memory. In constructor of class C, the
private member m of class A is destroyed. If you select 68k memory
structure alignment, the next pointer x is also affected. It is easy
to take a look what's happening by the debugger. If you put dummy
(long value) before member m, the program runs without problem at
least.

Masa

/*
*  Copyright © 1997-2003 Metrowerks Corporation.  All Rights
Reserved.
*
*  Questions and comments to:
*       <mailto:support@metrowerks.com>
*       <http://www.metrowerks.com/>
*/

#include <iostream.h>
#include <stdlib.h>

class A {
    /*long    dummy;*/    /* solution */
    short    m;

public:
    short    *x;
    short    *y;
    short    n;
   
    A();
   
    void printPrivate(void);
   
    virtual void f(void) {}    /* problem */
};

A::A()
{
    x = (short *) malloc(10 * sizeof(short));
    y = (short *) malloc(10 * sizeof(short));
    m = 123;
    n = 456;
   
    short    i;
    for (i = 0; i < 10; i++)
        x[i] = i;
}

void A::printPrivate(void)
{
    cout << m << '\n';
}

class B : public virtual A {
public:
    B();
};

B::B()
{
}

class C : public virtual B {
public:
    C();
};

C::C()
{
}

class D : public virtual B {
public:
    D();
};

D::D()
{
}

class E : public C, public D {
public:
    E();
};

E::E()
{
}

int main()
{
    using namespace std;
   
    E *e = new E;
   
    e->printPrivate();
    cout << e->n << '\n';
   
    short    i;
    for (i = 0; i < 10; i++)
        cout << e->x[i] << '\n';
   
    return 0;
}