Override array size in subclass - c++

Question

I have an array as a member of a class. In a subclass, I would like to re-define the array with a different size. I want to do this because I anticipate making many subclasses, each with only the array size it needs, and nothing more.
class Foo
{
Foo() {ivar = 1};
int thisArray[2];
int ivar;
}
class Bar : public Foo
{
Bar() {ivar = 3};
int thisArray[4];
}
int main()
{
Foo myFoo;
Bar myBar;
Foo fooCollection[] = {myFoo,myBar};
cout << "myFoo array size = " << sizeof(myFoo.thisArray)/sizeof(int) << endl;
cout << "myBar array size = " << sizeof(myBar.thisArray)/sizeof(int) << endl;
for (int n=0;n<2;n++)
{
cout << "fooCollection[" << n << "] array size = ";
cout << sizeof(fooCollection[n].thisArray)/sizeof(int) << endl;
}
for (int n=0;n<2;n++)
{
cout << "fooCollection[" << n << "] ivar = ";
cout << fooCollection[n].ivar << endl;
}
}
My results are:
myFoo array size = 2
myBar array size = 4
fooCollection[0] array size = 2
fooCollection[1] array size = 2
fooCollection[0] ivar = 1
fooCollection[1] ivar = 3
I get that, since I declare the array objects as objects of class Foo, that referring to myBar within that scope would reference myBar as though it was a Foo and consequently interpret the size of thisArray as equivalent to 2. I also understand why ivar comes out the way it does.
Is there a way to affect the size of thisArray within the Bar class so its "correct" size can be recognized within an array of Foo objects? I would use a vector, but they are not friendly on the arduino platform. I could also simply make the array within the Foo class with a size of 100, but I am trying to be conscious of memory allocation.

Answer 1

You could template your base class:
template <size_t Size>
class FooBase
{
// etc....
int thisArray[Size];
};
class Foo : public FooBase<2> { ... };
class Bar : public FooBase<4> { ... };
Of course, this is only practical where everything derives from FooBase -- that is, you don't have a class that derives from Bar which needs a different array size.
Also, as has been said in comments, if you need to keep these in an array you need to store pointers.
Foo myFoo;
Bar myBar;
Foo * fooCollection[] = { &myFoo, &myBar };
Oops, there I have assumed that Bar derives from Foo, which it no longer does. If you want a common base that isn't templated, you need to derive the templated class FooBase<Size> from another base FooType and now use an array of FooType. I think that will work.
class FooType {
public:
// etc...
virtual size_t GetSize() const = 0;
};
template <size_t Size>
class FooBase : public FooType
{
public:
// etc...
virtual size_t GetSize() const { return Size; }
protected:
// etc....
int thisArray[Size];
};
And then:
FooType *fooCollection[] = { &myFoo, &myBar };

Answer 2

You can define your array as a pointer and then new it with your constructor and delete it in your destructor. Remember the Rule of Three and you will be fine.
This is unless I've totally misunderstood your intent of this program.

Answer 3

When you do this: cout << sizeof(fooCollection[n].thisArray)/sizeof(int) << endl;, it is impossible to know the size of thisArray because you are not using actual polymorphism. So the compiler assumes all elements in fooCollection are simpy Foo (static binding).
Start by using pointers:
Foo * fooCollection[] = { &myFoo, &myBar };
And declaring a virtual member that will know at runtime the size of the array. (dynamic binding)
virtual int size() {return sizeof(thisArray);}
And then rewriting to:
cout << fooCollection[n]->size()/sizeof(int) << endl;

Answer 4

My opinion would be to not allow the base class to be a concrete class:
Let the base class be a abstract class providing interfaces to the
array (size of array, read and write to the array).
Let the construction and destruction of the array be controlled by the
derived classes.
This way, each derived class can choose the length of its array as appropriate.
Code sketch:
class foo {
public:
virtual size_t array_size() const = 0;
virtual int * array_base() const = 0;
int array_get( size_t index ) const {
array_verify_index( index );
return *( array_base() + index );
}
void array_set( size_t index, int value ) {
array_verify_index( index );
*( array_base() + index ) = value;
}
private:
void array_verify_index( size_t index ) const {
assert( index < array_size() );
}
};
class bar : public foo {
public:
bar() {
array_base = new int[ BarArraySize ];
}
~bar() {
delete [] array_base;
}
virtual size_t array_size() const {
return BarArraySize;
}
virtual int * array_base() const {
return array_base;
}
private:
int * array_base;
};

Answer 5

Well aware that I'm two years late, I would like to add another option - for those who seek an answer to this question without virtual methods or the new operator:
class Foo
{
protected:
// Can only be constructed by Bar, or other derived type.
Foo(int* _array, size_t _size) :
array(_array),
arraySize(_size)
{};
private:
int* array;
size_t arraySize;
};
template<size_t Size>
class Bar : public Foo
{
public:
Bar() : Foo(arrayData, Size) {};
private:
int arrayData[Size];
};
This allows Foo to be a common 'array' interface for several classes, with no virtual methods and with stack allocated arrays. Only real drawback is that we, by necessity, inserted Foo::arraySize, but that's still for a relatively small cost (4/8 bytes on 32/64-bit).