0

This is an interview question: how can we store the objects of let's say 3 different classes which are totally independent of each other.

My answer was: create an array which stores all void pointers. like :

void *array[];

and store the pointers of all the objects.the array elements can be many. but for retrieving the elements,i said we can use the dynamic cast or the static cast! this i think is the wrong answer.i think dynamic cast and static cast are supposed to be used among the classes which are dependent. please correct me if i am wrong.

if dynamic cast and static cast doesn't work.May be we can use reinterpret cast.

but is this the correct way to do this task?

Improve this question
5
  • @Rahul Dravid You need a Tuple. Commented May 31, 2011 at 11:02
  • 1
    If you'd have to do this, you should use a safe solution like boost::any. Commented May 31, 2011 at 11:03
  • 1
    @Red Hue: (1) why (??) and (2) how Commented May 31, 2011 at 11:15
  • he was not interested in boost. Commented May 31, 2011 at 11:25
  • 1
    @Angel: No, C does not have UDTs defined with the keyword class. C does have user-defined types in general, though (see: struct) and thus this question would be applicable to both languages... if it weren't for the {dynamic,static,reinterpret}_cast references. Commented May 31, 2011 at 11:34

4 Answers 4

Reset to default
5

Why are you trying to make this so complicated?

struct T {
   T1 obj1;
   T2 obj2;
   T3 obj3;
};

If you instead mean that you have an array of objects, and each element can be of any of three distinct, unrelated types, then it's a silly interview question because it's a silly thing to do.

(Yes, you would consider reinterpret_cast if forced to employ this approach by limited job opportunities and a pressing need to consume food.)

Improve this answer
Sign up to request clarification or add additional context in comments.

26 Comments

if it was silly - why were boost::any or boost::variant created?
If you'd go the non-boost way, at least make it a discriminated union? I know there are (severe) restrictions to what types can be used as union members, but many of these restrictions are lifted with the advent of c++0x
@Nim: So people can hack around stupid designs. Are you going to claim that the mere existence of a thing means that the requirements that leads to its use therefore must be non-silly?
@sehe, context is important, but to dismiss something as being "silly" without the context is plain silly IMHO. @Tomalak, of course not, the point I'm making is that the mere existence implies that there were/is some situation where it was/is pertinent, and to make a general statement dismissing an approach is "silly".
@Konstantin: Have a read through en.wikipedia.org/wiki/Argument_from_silence and en.wikipedia.org/wiki/Argument_from_ignorance
|
3

You could use a boost::variant<myfoo, anotherfoo, somefoo> v to put into a vector<v> and then you can store one class per item in the vector, however it can store variables of all three types.

You can find more info on boost::variant here

Improve this answer

2 Comments

he was expecting an answer not using any library like boost.
@Rahul, oh ok... didn't know. But this could work however, IRL
1

dynamic_cast from void* is not allowed, you need a polymorphic pointer for that (that is, a pointer to a class with a virtual method in it).

You cannot use other casts because the target type of the cast is not known. Once you cast a typed pointer to void*, the type information is lost forever. Given just the pointer, you have no chance to get that type information back. You need to remember something about the type somewhere in some form. How about enum { one, two, three } alongside the void* ?

Improve this answer

2 Comments

reinterpret_cast would be fine.
@Tomalak reinterpret_cast<???> What do you write inside the brackets? There are three types to choose from.
1

The only "correct" way to do this is to use something like boost::variant. If you cannot use boost, then you have to more less do the same thing: implement a discriminate union which accepts all of the desired types. This isn't as hard as it might seem: for POD types, you can just use a normal union for the data; for non-POD types, you add a unsigned char x[sizeof(T)] to the union, and use placement new and explicit delete on it, as needed. And you add whatever is necessary to the union to ensure alignment. Thus, for a user type MyClass and a double, one might have something like:

class MyVariant
{
public:
    enum Type { t_double, t_MyClass };
private:
    Type m_type;
    union
    {
        double m_double;
        unsigned char m_MyClass[sizeof(MyClass)];
        MaxAlignFor<MyClass> m_dummyForAlignment_MyClass;
    };
public:
    MyVariant( double d )
        : m_type( t_double )
    {
        m_double = d;
    }
    MyVariant( MyClass const& c )
        : m_type( t_MyClass )
    {
        new (m_MyClass) MyClass( c );
    }
    ~MyVariant()
    {
        switch ( m_type )
        {
        case t_double:
            break;

        case t_MyClass:
            reinterpret_cast<MyClass*>( m_MyClass )->~MyClass();
            break;
        }
    }
};

And so on. (There's obviously a lot more involved, but this should give the basic framework.)

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.