10 years, 2 months ago.

Yes, that will work fine. Anywhere that you have a type of the base pointer you can substitute a derived class.

Just keep in mind that since you'll have pointers to the base class you'll only be able to call functions defined in the base class, in order to call any functions that are specific to a derived class you will need to cast the pointer to the correct class.

e.g.

class sensor {
...
};

class thermistor : sensor {
...
};

sensor *sensorArray[5];
sensorArray[0] = new thermistor();

sensor *nextSensor = sensorArray[0];



// This would give an error
thermistor *thermSensor = sensorArray[0];

// If you want to access sensor class specific functions you would instead need to
// define a getType() method and have a list of return values and then use code like this:
if (sensorArray[0]->GetType() == thermistorID)
  thermistor *thermSensor = (thermistor *)sensorArray[0];

Generally it's best to have just about any method you will want for any sensor defined in the base class as a virtual function with the base class version not actually doing anything. That way you don't need to worry about casting to the correct pointer.

One thing that is a good tactic in this situation is to make sure you have at least one pure virtual function in the base class, something that everything will need to implement like getting the value e.g.

class sensor() {
public:

virtual float getReading() = 0;
...
...
} 

By making the function a pure virtual (the = 0 bit at the end) you will cause the compiler to throw an error if someone tried to create an item of the base class directly or if one of the derived classes forgets to define it. Making it so that it complains if you try to compile something silly is far easier to than trying to track down what's going on if it does compile and then has issues.