Question

It’s hard to explain exactly what I want to do here, but I have a base class and two classes which inherit this base class. Both classes which inherit it have their own unique members. I want to be able to pass both to a method, and have that method detect which it is, then access their unique members. I can’t assume there will only be two classes which inherit it, so i’m looking for something of a more general solution.

Here is an example of what I’d like to do:

#include <iostream>

class Base {

  public:
    int _type;
    Base() { }
};

class First : public Base {
  public:
    int _first_only;

    First() { }
};

class Second : public Base {
  public:
    int _second_only;

    Second() { }
};

void test (Base b) {

  std::cout << "Type: " << b._type << std::endl;

  if(b._type==1) {
    std::cout << "First\n";
    // Want to be able to do this
    std::cout << "Val: " << (First)b._first_only << std::endl; 
  } else if(b._type==2) {
    std::cout << "Second\n";
    // And this
    std::cout << "Val: " << (Second)b._second_only << std::endl;
  }
}

int main() {

  First f;
  f._first_only=1;
  f._type=1;
  Second s;
  s._type=2;
  s._second_only=2;

  test(f);
  test(s);
}

Answer 1

This is similar to others answers:

1. You can write polymorphic classes to get this behavior using virtual functions.
2. Pass the Dervied class objects either by pointer or by reference to get polymorphic behaviour. Otherwise it will lead to object slicing. Your test() function leads to object slicing.

This code may also help you. You can see that there are different ways to print the type. I used GetBaseType(), GetDerivedType() and GetType(). Among these GetType() method is convenient for you case. There are two constructors for convenience. Constructors allow to initialize data members.

class Base {
private:
    int _type;
public:
    Base(int type) : _type(type) { }
    int GetBaseType() { return _type; }
    virtual int GetDerivedType() = 0;
    virtual int GetType() { return _type; }
};

class First : public Base {
private:
    int _first_only;
public:
    First() : Base(1), _first_only(1) { }
    First(int first_only) : Base(first_only), _first_only(first_only) { }
    int GetDerivedType() { return _first_only; }
    virtual int GetType() { return _first_only; }
};

class Second : public Base {
private:
    int _second_only;
public:
    Second() : Base(2), _second_only(2) { }
    Second(int second_only) : Base(second_only), _second_only(second_only) { }
    int GetDerivedType() { return _second_only; }
    virtual int GetType() { return _second_only; }
};

void test (Base &b) {
    std::cout << "Type: " << b.GetBaseType() << std::endl;
    std::cout << "Type: " << b.Base::GetType() << std::endl;

    std::cout << "Dervied type: \n";
    std::cout << "Val: " << b.GetDerivedType() << std::endl; 
    std::cout << "Val: " << b.GetType() << std::endl; 
}

int main() {

  First f(1);
  Second s(2);

  test(f);
  test(s);

  First f1;
  Second s1;

  test(f1);
  test(s1);
}