C++ pass derived struct to method expecting the super struct - c++

Question

I am trying to create a menu library for arduino with C++ and OOP.
I have a struct called:
struct MenuItem {
int position;
String name;
MenuItem(int position, String name) : position(position), name(name) { };
};
And I have a derived struct called:
struct SpecificMenuItem : MenuItem {
int count;
SpecificMenuItem(int position, String name, int count) : MenuItem(position, name) , count(count) { };
};
How can I pass an array of the SpecificMenuItem structs to a method that expects an array of MenuItem? The idea here is that all the derived structs from MenuItem should have position and name, so that a simple list can be rendered out with the following method from the Menu class:
Menu::Menu() {
}
void Menu::setMenuItems(MenuItem *menuItems) {
this->mMenuItems = menuItems;
}
void Menu::render(void) {
for (int j = 0; j < this->mMenuItemSize; j++) {
Serial.println(this->mMenuItems[j].name);
}
}
The header file for specific_menu.h:
class SpecificMenu : public Menu {
struct SpecificMenuItem mSpecificMenuItem[2] = {
{1, "Name", 3},
{2, "Name 2", 4}
};
public:
SpecificMenu();
};
The cpp file for specific_menu.cpp:
SpecificMenu::SpecificMenu() : Menu() {
this->setMenuItems(this->mSpecificMenuItem);
this->setMenuItemsSize(2);
}
The issue right now is that having the extra count member in the SpecificMenuItem struct is causing the program to crash, however the program runs fine if I remove the count member, but I think this is just a fluke that it works. Would love to get some pointers on how to get the above to work.
Cheers!

Answer 1

You cannot pass an array of SpecificMenuItem to a method waiting for an array of MenuItem, even if SpecificMenuItem inherits from MenuItem.
One possible way would be to remove the setMenuItems methods and makes use of polymorphism to access the size and the items of the menu:
class Menu {
protected:
virtual size_t size () const = 0;
virtual MenuItem& operator[] (size_t) = 0;
};
class SpecificMenu : public Menu {
SpecificMenuItem mSpecificMenuItem[2] = {
{1, "Name", 3},
{2, "Name 2", 4}
};
protected:
virtual size_t size () const { return 2; }
virtual const MenuItem& at (size_t i) const {
return mSpecificMenuItem[i];
}
public:
SpecificMenu();
};
And then use these method in Menu::render:
void Menu::render(void) {
for (int j = 0; j < this->size(); j++) {
Serial.println(this->at(j).name);
}
}
This is making your Menu acts as a (abstract) container of "MenuItem&".

Answer 2

You'd better declare something like:
typedef std::list<MenuItem *> MenuItemArray;
Then you can access you base classes by pointer.
void
Menu::setMenuItems(const MenuItemArray& menuItems)
{
this->mMenuItems = menuItems;
}
void
Menu::render(void)
{
for (int j = 0; j < this->mMenuItems.size(); j++) {
Serial.println(this->mMenuItems[j]->name);
}
}
Afterward, if you need to access a SpecificMenuItem element:
...
SpecificMenuItem *specificItem = dynamic_cast<SpecificMenuItem *>(mMenuItems[i]);
if (specificItem) {
...
}
The solution you initialy wrote rather looks like a C solution, not C++ IMHO.
Have fun.

Answer 3

Your problem is, you can't put different structs/classes in same array, as they have different sizes. Consider making array of pointers, that point to objects of base class, as they can point to derived as well. Like
typedef MenuItem * MenuItemPtr;
typedef MenuItemPtr * MenuItemPtrArray;
MenuItemPtrArray myArr= new MenuItemPtr[2];
myArr[1] = new MenuItem(/*...*/);
myArr[2] = new SpecificMenuItem(/*....*/);
Of course, you can use std::list or other collectionas #Holt suggested in his answer, and it would be better solution. But I suppose you don't have it as you write for arduino, which has no stl