Указатель на массив Вести счетчик элементов

Трудно ответить, не зная более подробной информации о вашем приложении — но вот несколько идей, которые могут помочь.

Дано:

class someInterface { public: virtual char someMethod() = 0; };

class A : public someInterface { public: char someMethod() { return 'A'; } };
class B : public someInterface { public: char someMethod() { return 'B'; } };
class C : public someInterface { public: char someMethod() { return 'C'; } };

Вы можете свернуть вручную что-то вроде этого:

class Array {
public:
void forEach( void(*function)(someInterface&) ) {
for (size_t i = 0  ;  i < countA  ;  ++i) function(As[i]);
for (size_t i = 0  ;  i < countB  ;  ++i) function(Bs[i]);
for (size_t i = 0  ;  i < countC  ;  ++i) function(Cs[i]);
}
private:
enum {countA = 10, countB = 5, countC = 3};
A As[countA];
B Bs[countB];
C Cs[countC];
};

void doSomeMethod(someInterface& element) {
std::cout << element.someMethod();
}

int main(int, char**) {
Array array;
array.forEach(doSomeMethod);
return 0;
}

Обратите внимание, что с помощью функции «обратного вызова» doSomeMethodОбходим типичную проблему диспетчеризации в полиморфных коллекциях.
Конечно, вы не хотите продолжать такие вещи. К счастью, у проверенного мной компилятора Arduino C ++ есть поддержка шаблонов, так что вы можете сделать что-то вроде:

template <class T, size_t _size, class NextArray = void>
struct Array {
public:
typedef T value_type;
enum {size = _size};

void forEach( void(*function)(someInterface&) ) {
for (size_t i = 0  ;  i < _size  ;  ++i)
function(elements[i]);
nextArray.forEach(function);
}
private:
T elements[_size];
NextArray nextArray;
};

template <class T, size_t _size>
struct Array<T, _size, void> {
public:
typedef T value_type;
enum {size = _size};

void forEach( void(*function)(someInterface&) ) {
for (size_t i = 0  ;  i < _size  ;  ++i)
function(elements[i]);
}
private:
T elements[_size];
};

void doSomeMethod(someInterface& element) {
std::cout << element.someMethod();
}

int main(int, char**) {
Array<A, 10, Array<B, 5, Array<C, 3> > > array;
array.forEach(doSomeMethod);
return 0;
}

Который заставляет компилятор написать это для вас для различных комбинаций типов и размеров. Несколько вещей, на которые стоит обратить внимание:

1. Вся магия делается во время компиляции. Посмотрите сборку, сгенерированную оптимизирующим компилятором, чтобы увидеть, насколько маленькой и быстрой это может быть.
2. Читайте о «функторах» c ++, если вашей функции обратного вызова требуется некоторое состояние.
3. Если ваш компилятор поддерживает переменные шаблоны и / или лямбды, это становится проще (я предполагаю, что компилятор Arduido еще не)

Если вы не можете использовать метод обратного вызова (и ваш компилятор еще не поддерживает лямбда-выражения), вы можете попробовать следующую опцию, которая требует небольших затрат времени выполнения по сравнению с опцией, указанной выше:

template <class Interface>
class ArrayInterface {
public:
virtual size_t getSize() = 0;
virtual Interface& getElement(size_t index) = 0;
};

template <class T, class Interface, size_t size>
class Array : public ArrayInterface<Interface> {
public:
size_t getSize() { return size; }
Interface& getElement(size_t index) { return element[index]; }
private:
T element[size];
};

int main(int, char**) {
Array<A, SomeInterface, 10> As;
Array<B, SomeInterface, 5> Bs;
Array<C, SomeInterface, 3> Cs;

const int SOMEINTERRFACE_SIZE = 3;
ArrayInterface<SomeInterface>* array[SOMEINTERRFACE_SIZE] = {&As, &Bs, &Cs};

for (size_t i = 0  ;  i < SOMEINTERRFACE_SIZE  ;  ++i) {
ArrayInterface<SomeInterface>& innerArray = *array[i];
for (size_t j = 0  ;  j < innerArray.getSize()  ;  ++j)
std::cout << innerArray.getElement(j).someMethod();
}

return 0;
}

(Этот последний использует внешний массив указатели, согласно вашему вопросу)

Этот пост уже слишком длинный, поэтому я не вдавался в подробности и не углублялся в такие опции, как единый плоский массив указателей на функции-члены. Если у вас есть какие-либо вопросы, просто кричите.

Это то, что вы пытаетесь достичь?
Перебирать список объектов и вызывать переопределенный метод общего интерфейса?

Поместите этот кусок кода в любую область глобальной C ++ для тестирования.

#include <vector>
#include <iostream>
int TestSomewhereInCppGlobalScopeCode()
{
class someInterface
{
public:
virtual void someMethod() = 0;
};

class A : public someInterface
{
public:
void someMethod()
{
std::cout << "A::someMethod()";
}
};

class B : public someInterface
{
public:
void someMethod()
{
std::cout << "B::someMethod()";
}
};

class C : public someInterface
{
public:
void someMethod()
{
std::cout << "C::someMethod()";
}
};

std::vector<someInterface*> ListOfObjectsHavingCommonInterface;

ListOfObjectsHavingCommonInterface.push_back( new A );
ListOfObjectsHavingCommonInterface.push_back( new B );
ListOfObjectsHavingCommonInterface.push_back( new C );

for ( std::vector<someInterface*>::iterator it = ListOfObjectsHavingCommonInterface.begin();
it != ListOfObjectsHavingCommonInterface.end();
++it )
{
(*it)->someMethod();
}

return 0;
}

static int TestSomewhereInCppGlobalScopeCode_Caller = TestSomewhereInCppGlobalScopeCode();