Dynamic pointer type

Hi friends,

I need to optimize a code but a few questions.
I have a method that makes the checking of configurations that depending on the state set, and a pointer to the class X and if you're in another state, for class Y.

These two classes are classes that have different but similar methods, I thought to use templates, but there is a template for pointer.
What I want is a pointer to a type (class), sometimes to another (depending configuration), so I can access the appropriate attributes. How do I do that? It enables someone to write a minimum practical example? It's possible?

If one class is a subclass of the other: access them both via the base pointer, use virtual methods for methods that are different in the base class.

If the classes are only 'related' but not by inheritance, you may use templates. That only helps if the two classes may be used syntactically identically.

Code:

---

class X
{
    int x;
    int y;
};
class Y : public X
{
    int z;
};
 
bool check_config(const X * const config)
{
   if (config->x > 5) return false;
}
 
X x;
Y y;
check_config(&x);
check_config(&y); // also ok

---

HTH
If not, please give us more details (esp. on those configuration classes of your's).

OK, follow little example for my question.
In my particular case, the class does not inherit Z of X and Y.

Code:

---

class X
{
  public:
    int lastNumber( );    
};
 
class Y {
  public:
    int lastNumber( );
};
 
class Z {
  private:
    bool check_config( );
};
 
...
 
bool Z::check_config( ) {
  if (result_of_database == 0)
    X *pointer = new X;
  else
    Y *pointer = new Y;
  ...
  return true;
}
...
 
void Z::other_method( ) {
  pointer->lastNumber( );   // The correct pointer used depend result of check_config
}

---

Please note that my code is wrong, but it is just for you understand, because the pointer was declared and initialized within the scope of the method.

Thanks,

Marcelo E. Geyer
Brazil

Basically, you have 3 options. You have to decide yourself, which is the appropriate in your situation:

1) if classes X and Y are under your control: why not make them related by inheritance (perhaps a common base class)?

2) provide two separate implementations for the two cases

Code:

---

X * m_x; // init to NULL somewhere
Y * m_y;
bool Z::check_config( ) {
  if (result_of_database == 0)
    m_x = new X;
  else
    m_y = new Y;
 return true;
}
void Z::other_method( ) {
  if (m_x) m_x->lassNumber();
  if (m_y) m_y->lastNumber();
  pointer->lastNumber( ); 
}

---

3) templates

Note that that this is very similar to 2), just that the template saves you the work of having to write to separate other_methods, the compiler generates those for you.
However, as soon as you want to do something for X that is not possible in Y, you have to code that in other_method. The template method is just a way to write code once for syntactically identically useable objects.

Code:

---

void other_method()
{
    if (m_x) do_other_method(m_x);
    if (m_y) do_other_method(m_y);
}
 
template<typename Config>
void Z::do_other_method(Config *cfg) {
  cfg->lassNumber();
}

---

All code untried, but I hope the idea is understandable.
HTH