Acces variable of subclass, using a pointer array of base class - c++

Question

I hope I formulated the title a bit correct.
I have this base class
class FunctionBlock
{
public:
uint8_t IN1 : 1 ;
uint8_t IN2 : 1 ;
uint8_t IN3 : 1 ;
uint8_t Q : 1 ;
uint8_t Q_NOT : 1 ;
virtual void run() ;
} ;
And many subclasses like
class Or : public FunctionBlock // there is also And, JK, SR, NOT etc..
{
public:
Or()
{
IN1 = IN2 = IN3 = 0 ;
}
void run()
{
Q = IN1 | IN2 | IN3 ;
}
} ;
And the one with the problem:
class AnalogOutput : public FunctionBlock
{
public:
AnalogOutput( uint8_t _pin )
{
pin = _pin ;
}
void run()
{
if( analogIN2 != prevIn )
{ prevIn = analogIN2 ; // if incoming change, update PWM level
analogWrite( pin, analogIN2 ) ;
// Serial.println( analogIN2 ) ; // DEBUG just testing if it... actually works
}
}
uint8_t analogIN2 ; // I need to be 8 bits instead of 1 bit
private:
uint8_t pin ;
uint8_t prevIn ;
} ;
The main program process the logic of all function blocks and it updates the links. The links used to exist of a connection from a Q to an IN1, IN2 or IN3. Using bit fields I can stuff these in one single byte.
Now I have added analog components, so a single bit for Q and IN does not suffice. To solve this problem, I added the public variable analogIN2 as seen in the analogOutput class. Similarly I use a public variable int analogQfor an analog input.
For the links I make a destinction between digital and analog links.
Obivously I could change
uint8_t IN1 : 1 ;
uint8_t IN2 : 1 ;
uint8_t IN3 : 1 ;
uint8_t Q : 1 ;
Into
uint16_t IN1 ; // instead of 1 byte, I would need 8 bytes
uint16_t IN2 ;
uint16_t IN3 ;
uint16_t Q ;
But this would increase memory consumption, so I keep this as a last resort
#include "functionBlocks.h"
static AnalogInput b1 = AnalogInput(1) ;
static AnalogOutput b2 = AnalogOutput(5) ;
static And b3 = And() ;
static Or b4 = Or() ;
FunctionBlock *block[] = {
&b1 ,
&b2 ,
&b3 ,
&b4 ,
} ;
const int nBlocks = 4 ;
void setup()
{
}
void loop()
{
/***************** UPDATE FUNCTION BLOCKS *****************/
for( int i = 0 ; i < nBlocks ; i ++ ) block[i] -> run() ;
/***************** UPDATE LINKS *****************/
block[1] -> analogIN2 = block[0] -> analogQ ; // <-- analog link does not compile
block[3] -> IN2 = block[2] -> Q ; // digital links work fine
block[2] -> IN3 = block[3] -> Q ;
} ;
I marked the line which does not compile.
C:\Users\me\Documents\hobbyProjects\functionBloX\arduinoProgram\arduinoProgram.ino:26:17: error: 'class FunctionBlock' has no member named 'analogIN2'
block[1] -> analogIN2 = block[0] -> analogQ ;
The reason is obvious, the base class does not know about analogIn and analogQ. Therefor the array 'block[]' does not have acces to the members.
My questions:
Can I let the FunctionBlock *block[] objects give acces to analogQ without increasing memory usage drastically. And if so, how can I do that?
The one thing I could think of was to add a 2nd baseclass but I do not know every last in and out of c++, hence this question.

Answer 1

You could even go entirely without inheritance and polymorphism:
#include <tuple>
static auto blocks = std::make_tuple(AnalogInput(1), AnalogOutput(5), And(), Or());
void loop()
{
// Using the tuple elements as arguments to a suitable function
auto run_all = [](auto&... args) { (args.run(), ...); };
std::apply(run_all, blocks);
// Assuming that the digital and analog blocks now have members
// of the same name
auto& [b1, b2, b3, b4] = blocks;
b2.IN2 = b1.Q;
b4.IN2 = b3.Q;
b3.IN3 = b4.Q;
}
Admittedly, the interface of tuples is not as nice as that of arrays or other containers, but they are an option.
If all blocks have the same basic data, you could parametrise that using a template:
#include <concepts>
template<std::integral T = uint8_t, unsigned N = 1>
struct BlockData
{
T IN1 : N = 0;
T IN2 : N = 0;
T IN3 : N = 0;
T Q : N = 0;
T Q_NOT : N = 0;
};
You can also use your current approach, but then the data would need to be encapsulated behind virtual get/set functions:
struct FunctionBlock {
virtual ~FunctionBlock() = default;
virtual void run() = 0;
// Set channel 1 to the given value
virtual void in1(uint8_t) = 0;
// etc.
};