Dynamic class variable

I have a base class, A, with an inquiry method bool isB(), and two derived classes, B and C, that inherit from A. I also have a container class, D, with a variable, x, and its respective accessor, x(). My problem, is that x needs to be a pointer to type B --or-- C, so that when I do something like D *test = new D();, then test->x() will either be a pointer to B or a pointer to C, which I won't know until run time and could then check using the inherited method, test->x()->isB(), which will be set within B and C's constructors to true or false, respectively.

So, my question is, what should the data type for x and return type for x() be? I was thinking like void *, but wasn't sure if that's correct or not.

Quote:

---

I have a base class, A, with an inquiry method bool isB(), and two derived classes, B and C, that inherit from A.

---

Is isB() really necessary? It pretty much means that the base class must know about one of its child classes. If you can get away without it, that would be better.

Quote:

---

So, my question is, what should the data type for x and return type for x() be? I was thinking like void *, but wasn't sure if that's correct or not.

---

It should be an A*.

Quote:

---

Originally Posted by laserlight

Is isB() really necessary? It pretty much means that the base class must know about one of its child classes. If you can get away without it, that would be better.

---

The only reason isB() exists is so D objects will know whether x() points to a B or C. What would be a better way to test this?

Quote:

---

Originally Posted by laserlight

It should be an A*.

---

A pointer to a base class can also point to any derived classes as well without breaking things? If I'm understanding you correctly, and use A* as the data type for D::x and return type for D::x(), then the following should be possible, right?

Code:

---

B *b = new B();
C *c = new C();
D *d = new D();

//  point x to b
d->x ( b );

cout << d->x->some_class_B_method () << endl;

//  point x to c
d->x ( c );

cout << d->x->some_class_C_method () << endl;

---

Quote:

---

The only reason isB() exists is so D objects will know whether x() points to a B or C. What would be a better way to test this?

---

It would be even better if you can design it such that D objects do not need to know if x really is a B or a C, but only needs to know it is an A. One way to do this is by the appropriate use of virtual functions.

Quote:

---

A pointer to a base class can also point to any derived classes as well without breaking things?

---

Of course. This is one way to use polymorphism in C++.

Quote:

---

If I'm understanding you correctly, and use A* as the data type for D::x and return type for D::x(), then the following should be possible, right?

---

I am assuming that D::x() takes and returns an A*. If so, so, what you wrote will not work. With an A*, you can only call member functions from A, not member functions specific to its derived classes, unless you type cast (in which case you need to be sure that the object really is of the type that you cast it to).

Quote:

---

Originally Posted by drrcknlsn

The only reason isB() exists is so D objects will know whether x() points to a B or C. What would be a better way to test this?

---

You can use dynamic_cast, but there is a slight performance cost using that.
Instead of isB() you can have something like ClassType() which returns an enum value specifying the class type.

Quote:

---

Originally Posted by drrcknlsn

A pointer to a base class can also point to any derived classes as well without breaking things? If I'm understanding you correctly, and use A* as the data type for D::x and return type for D::x(), then the following should be possible, right?

Code:

---

B *b = new B();
C *c = new C();
D *d = new D();

//  point x to b
d->x ( b );

cout << d->x->some_class_B_method () << endl;

//  point x to c
d->x ( c );

cout << d->x->some_class_C_method () << endl;

---

---

No, if x is an A* pointer then it can only access A functions.

Right. I didn't think it would work like that, which is why I was asking about void *.

The only other option I can think of that satisfies my requirements is splitting D::x into two different variables, with accessors B *D::x_B() and C *D::x_C(). I didn't really want to do this, because it seems like bad design to have to test for a null pointer every time I want to use x.

Quote:

---

The only other option I can think of that satisfies my requirements is splitting D::x into two different variables, with accessors B *D::x_B() and C *D::x_C(). I didn't really want to do this, because it seems like bad design to have to test for a null pointer every time I want to use x.

---

Why not share with us an overview of the real problem you are trying to solve? Perhaps someone here can suggest an appropriate solution, e.g., using a design pattern or something.

Well, basically...

A = student
B = undergraduate (inherits student)
C = graduate (inherits student)
D = class
D::x = class role (list of all students in the class)

So, to send a message to all students in a class, I would have liked to have D::x be a pointer to a linked list of "mixed" types (both undergrads and/or grads) that I could iterate through.

Instead, it appears that I'll have to have D::x be a list of undergrads only, and create a new D::y for grads, and then test both for null pointers and iterate them separately.



If anyone has a better design, I'm very much open to suggestions!

Quote:

---

So, to send a message to all students in a class, I would have liked to have D::x be a pointer to a linked list of "mixed" types (both undergrads and/or grads) that I could iterate through.

---

That sounds like you want a std::list<Student*>, or perhaps more appropriately a std::vector<Student*> or Boost's ptr_vector<Student>.

Quote:

---

Instead, it appears that I'll have to have D::x be a list of undergrads only, and create a new D::y for grads, and then test both for null pointers and iterate them separately.

---

So far the only reason why you "have to have" it differently is that you want to call member functions specific to Undergraduate and Graduate. What are these member functions? Perhaps they can be eliminated by providing one or more virtual functions in Student.

Quote:

---

Originally Posted by laserlight

So far the only reason why you "have to have" it differently is that you want to call member functions specific to Undergraduate and Graduate. What are these member functions? Perhaps they can be eliminated by providing one or more virtual functions in Student.

---

Correct - things like uint16 Graduate::GRE(), which returns a graduate student's GRE score. While this probably isn't the best example, since all students can take the GRE regardless of undergrad/grad status, in my implementation, I only care about the score if the student is a grad, and it didn't make sense to add such methods to the base class if they would only ever be called on objects of the Graduate class.

There are (more than) two ways you can solve this type of problem. In this case, if you want a particular type of student "have or not have" a particular capability, why not make it a function that returns a bool to say if it's there or not?

Something like this:

Code:

---

class student
{
  public:
      virtual string studenType() { return string("Any student"); };
      virtual bool GRE(int &grade)  { grade = 0; return false; };
  ...
};

class graduate : public student
{
  public:
      virtual string studenType() { return string("Graduate student"); };
      virtual bool GRE(int &grade)  { grade = gre; return true; };
  private:
      int gre;
};

---

You can then do something like:

Code:

---

  D *d;
  student *s;
  int gre;
...
  s = d->x();
  if (s->GRE(gre)) { cout << "GRE: " << gre << endl;
}

---

--
Mats

It should be noted that semicolons after inline class member functions are not required:

Code:

---

class student
{
  public:
      virtual string studenType() { return string("Any student"); };
      virtual bool GRE(int &grade)  { grade = 0; return false; };
  ...
};

class graduate : public student
{
  public:
      virtual string studenType() { return string("Graduate student"); };
      virtual bool GRE(int &grade)  { grade = gre; return true; };
  private:
      int gre;
};

---

You do, of course, need them for "prototypes":

Code:

---

class test {
    void required();
    void non_required() {}
};

void test::required() {}

---

Quote:

---

Originally Posted by dwks

It should be noted that semicolons after inline class member functions are not required:

Code:

---

class student
{
  public:
      virtual string studenType() { return string("Any student"); };
      virtual bool GRE(int &grade)  { grade = 0; return false; };
  ...
};

class graduate : public student
{
  public:
      virtual string studenType() { return string("Graduate student"); };
      virtual bool GRE(int &grade)  { grade = gre; return true; };
  private:
      int gre;
};

---

You do, of course, need them for "prototypes":

Code:

---

class test {
    void required();
    void non_required() {}
};

void test::required() {}

---

---

Thanks for that clarification. Most of my class member functions are defined "outside" the class when I work on classes at work, so I'm not so used to writing inline functions...

--
Mats

Quote:

---

Originally Posted by matsp

Something like this:

Code:

---

class student
{
  public:
      virtual string studenType() { return string("Any student"); };
      virtual bool GRE(int &grade)  { grade = 0; return false; };
  ...
};

class graduate : public student
{
  public:
      virtual string studenType() { return string("Graduate student"); };
      virtual bool GRE(int &grade)  { grade = gre; return true; };
  private:
      int gre;
};

---

---

Student is supposed to be an abstract class that will never be instanced, but I get what you're saying.

Would it not be more efficient to have a dedicated inquiry method (like virtual bool Student::isGraduate() = 0; - what I was alluding to in the OP) rather than returning the answer through every single method? Then, you could block the code after a test, rather than testing each individual method call.

The point is that generally speaking, you should be using public inheritance to model an is-a or works-like-a relationship, and if you have a collection of pointers to the base class then you should probably only be performing operations that makes sense for that base class.

One possible solution that will allow you to keep your current design but avoid specialized code for different derived classes is to look at the code that you think needs to call the isGraduate() function. Is that code performing a more general duty that should be handled by the Student class?

For example, let's say you need the GRE score only for graduates in code that outputs the transcript because on graduate transcripts there is an extra line for the GRE score. Then perhaps outputTranscript should be a method of Student than is at least partially implemented by virtual methods that are overridden in the derived classes. Then the graduate class can output the GRE score as necessary while the undergraduate class will not.

So go up a level and look at the purpose of the code where you think you need the isGraduate() functionality and see if maybe it makes more sense to implement it as part of the Student class instead.

If that code relies on some other object or inheritance hierarchy, then you can get them to work together with a specific design pattern (the name of which escapes me at the moment).