Re: Different Objects in Array

From:

James Kanze <james.kanze@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sat, 9 Jan 2010 05:09:39 -0800 (PST)

Message-ID:

<8201f19a-088b-4186-ba15-5894e9e58896@21g2000yqj.googlegroups.com>

On Jan 8, 1:21 pm, Michael Doubez <michael.dou...@free.fr> wrote:

On 8 jan, 04:51, Immortal Nephi <Immortal_Ne...@hotmail.com> wrote:

On Jan 7, 8:21 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

Immortal Nephi wrote:

   I thought that you might find an interesting code. Perhaps, you have
seen this before. I created two classes of A and B. Two classes have
different objects. The class Obj has a relationship to class A and
class B which is called composition.
   The class Obj has one variable which is a pointer to member function
in array. You can't bind member function of both class A and class B
because they do not belong to class Obj. I use reinterpret_cast to
convert from class A to class Obj before pointer to member function is
invoked.
   I believe that my code is the alternative replacement so I don't use
inheritance and polymorphism. It is easier to extract class. What do
you think?

Your code has undefined behaviour, not to mention that the
compiler that is supposed to compile your
'reinterpret_cast' will exhibit undefined behaviour (most
likely). Aside from that, you're good...

How did you say undefined behavior? I played with
debugging. I found out that reinterpret_cast array did
assign memory address correctly, but *this* pointer in class
A and class B assigns to the wrong memory address.

For example:

class ....
{
int a;
int b;
int c;
}

*this* pointer should always assigns to data member as a,
but it did assigns to either data member as b or c. The
data was misplaced from a to b like memory misalignment.

I guess there is no alternative replacement to undefined
reinterpret_cast array, but switch block is the answer to each class'
member function.

Do you know if there is another way? What about template array?

You can use union:

class Obj
{
public:
        void Run()
        {
                this->*(pO[0].runA)();
                this->*(pO[1].runB)();

That shouldn't compile, given the union you defined below; this
isn't the right type. (It's also lacking some parentheses.)

        }

private:
        A a;
        B b;
        union To
        {
          void A::*runA();
          void B::*runB();
        };
        static To const pO[2];
};

// not sure about initialisation - perhaps only possible in C99
Obj::To const Obj::pO[2] =
{
        {&A::Run},
        {&B::Run}
};

You could use assignment somewhere, e.g. in an if in the
constructor. But once you've gotten the correct types in the
array, you have to call the function with the correct type; the
whole point of his exercise was to lie to the compiler, in order
to ensure that it generated incorrect code (and probably to use
some exotic and generally slow technique, like pointers to
members, rather than the usual faster technique of virtual
functions).

--
James Kanze