Inheritance and casting

[meLlamanJefe]

I am writing a queue object that will take different types of values. My approach is to have the std::queue take objects of a base class type while the user interacts with the queue using objects derived from the base type. Here is the relevant code:

inside Queue.h

   class RequestObject
   {
     public:
      // Constructor
      RequestObject(){ mType = -1; }
      virtual ~RequestObject(){}
 
      int GetType() const { return mType; }
      void SetType(int i) { mType = i; }
 
     private:
      int mType;
   };
 
   class IntDoublePair : public RequestObject
   {
      public:
         IntDoublePair(){ mInt = 0; mDouble = 0.0; }
         IntDoublePair(int i, double d){ mInt = i; mDouble = d; }
         IntDoublePair(RequestObject O){}
         virtual ~IntDoublePair(){}
 
         void SetInt(int value){ mInt = value; }
         void SetDouble(double value){ mDouble = value; }
         int GetInt(){ return(mInt); }
         double GetDouble(){ return(mDouble); }
      private:
         int    mInt;
         double mDouble;
   };
 
   class QueueObject
   {
   public:
       QueueObject(){}
       ~QueueObject(){}
 
       // Public Methods
       void Add(const RequestObject &Request);
       bool Empty();
       RequestObject Pop();
       void Clear();
 
   private:
       std::queue<RequestObject> Q;
   };
 

Inside Queue.cpp

#include "Queue.h"
 
using namespace std;
 
void QueueObject::Add(const RequestObject &Request)
{
   RequestObject O = Request;
    Q.push(O);
}
 
RequestObject QueueObject::Pop()
{
    RequestObject O = Q.front();
    Q.pop();
    return(O);
}
 
bool QueueObject::Empty()
{
   return(Q.empty());
}
 
void QueueObject::Clear()
{
   while(!Q.empty())
   {
      Q.pop();
   }
}
 

Inside QueueTest.cpp

#include <iostream>
#include "Queue.h"
 
using namespace std;
 
int main(int argc, char *argv[])
{
   QueueObject mQ;
 
   for(int i = 0; i < 10; ++i)
   {
      IntDoublePair tID(i, (i*1000.0/10.0));
      tID.SetType(i);
      mQ.Add(tID);
   }
 
   while(!mQ.Empty())
   {
      IntDoublePair ip = mQ.Pop();
      cout << "Int = " << ip.GetInt() <<
              " Doub = " << ip.GetDouble() << 
              " Type = " << ip.GetType() << endl;
   }
 
   return(0);
}
 

Unfortunately the output of this test code is:

Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1
Int = 9 Doub = 900 Type = -1

where it should be:
Int = 0 Doub = 0 Type = 0
Int = 1 Doub = 100 Type = 1
Int = 2 Doub = 200 Type = 2
Int = 3 Doub = 300 Type = 3
Int = 4 Doub = 400 Type = 4
Int = 5 Doub = 500 Type = 5
Int = 6 Doub = 600 Type = 6
Int = 7 Doub = 700 Type = 7
Int = 8 Doub = 800 Type = 8
Int = 9 Doub = 900 Type = 9

So I have two questions:

Has anyone already implemented anything like this?

If not, does anyone have an idea of why this code is not behaving as expected?

Thanks.

[boxfish]

Hi,
Since your QueueObject's Q is a <RequestObject> queue, it can't hold the IntDoublePairs, even though they're descended from RequestObject. Only dynamic variables can hold the descendants of their type. In order to do this, you will need to make Q a <RequestObject*> queue, and dynamically allocate memory for the RequestObjects you put into it.
Hope this helps.

[Savage]

That is,you can only call object methods declared in base class. Everything else will result in pure garbage. Making your queue class a template class,or adding methods from IntDoublePair to base class should give you expected results.

[meLlamanJefe]

Thanks for both replies.

I've toyed around with the idea of making the Queue class a template but I'm not very proficient with templates and the trouble I have come across is that while the std::queue is a template class, it only takes in one type of object for each instance.

I'm not sure if it is possible to make a single std::queue object hold objects of different types. Any ideas on this thought? In my case this is what I try to emulate but again, I'm not familiar enough with templates and that might be the problem here.

[Savage]

Thanks for both replies.

I've toyed around with the idea of making the Queue class a template but I'm not very proficient with templates and the trouble I have come across is that while the std::queue is a template class, it only takes in one type of object for each instance.

I'm not sure if it is possible to make a single std::queue object hold objects of different types. Any ideas on this thought? In my case this is what I try to emulate but again, I'm not familiar enough with templates and that might be the problem here.

There are three good ways to go about it then:

1.Use boxfish's way and make your self responsible for managing memory.
2.Make your base class use a universal accessor:

class Base
{
  protected:
  /*........*/
 
  public:
 
  /*Universal accessors,each class implements this pair of accessors..*/
  virtual void SetValue(void* value);
  virtual void *GetValue(void);
 
};
 

Not very type safe,the one of reasons templates exist.

3.Use template base class:

template<class T>
class Base
{
  protected:
  /*...............*/
 
 
  public:
 
   virtual void Set(T &value);
   virtual T Get(void);
 
};

Type safer,but includes messy templates syntax

[weaknessforcats]

I thnk you are being steered the wrong way.

True: Your queue must contain pointers or references to the base class.
True: Using the base class reference in the queue you can only call methods on RequestObject
FALSE: You have to put derived class methods into RequestObject.
FALSE: There is no way to call IntDoublePair methods using a RequestObject.

That is, the base class contains the interface to the hierarchy and does not mean that all the methods in the derived class have to be in the base class as virtual functions.

Almost cetainly, the the virtual methods in the base and derived classes need to be private. Virtual describes the implementation. You are to separate the intrerface from thje implementation (you might Google this phrase).

Read this article about that: http://bytes.com/forum/thread793836.html.

Then to access those derived class methods that aren't in the base class, you need a Visitor. This is a design pattern that will solve your problem. Read this: http://bytes.com/forum/thread674645.html.

[meLlamanJefe]

I thnk you are being steered the wrong way.

True: Your queue must contain pointers or references to the base class.
True: Using the base class reference in the queue you can only call methods on RequestObject
FALSE: You have to put derived class methods into RequestObject.
FALSE: There is no way to call IntDoublePair methods using a RequestObject.

That is, the base class contains the interface to the hierarchy and does not mean that all the methods in the derived class have to be in the base class as virtual functions.

Almost cetainly, the the virtual methods in the base and derived classes need to be private. Virtual describes the implementation. You are to separate the intrerface from thje implementation (you might Google this phrase).

Read this article about that: http://bytes.com/forum/thread793836.html.

Then to access those derived class methods that aren't in the base class, you need a Visitor. This is a design pattern that will solve your problem. Read this: http://bytes.com/forum/thread674645.html.

Thanks for the tip on the articles. I had never heard of the Visitor concept (I'm a programmer by need :). It is taking me a bit of time to wrap my head around the concept but I think I agree with you that it would solve the problem I am having.

Thanks!