Funktionspointer array als parameter übergeben

[µCFrage (Gast)]

Hi all,
ich bin gerade zu doof ein funktionsarray als Parameter zu übergeben.
Google hat mir leider nur mit einem einzigen funktionspointer helfen 
können:

Hier der code:

typedef void (*stateArray)(void);

uint8 getArrSize(void);
void start0(void);
void start1(void);
void start2(void);
void start3(void);
void start4(void);

stateArray myStateArray[]=
{
  start0,
  start1,
  start2,
  start3,
  start4,
};

int main (void){
  uint8 fpSize= getArrSize(/* hier soll die übergabe rein*/);
}

uint8 getArrSize( void){
  return sizeof(myStateArray) / sizeof(myStateArray[0]);
}

wie ihr seht hab ich es bisher durch eine globale variable gelöst.
Das geht doch aber auch mit einer übergabe?
In etwa so:

uint8 fpSize= getArrSize(stateArray nFct){
  return sizeof(nFct) / sizeof(nFct[0]);
}

Leider leider mag das aber der compiler nicht :\

Danke und Gruß
µCFrage

[Karl H. (kbuchegg)]

µCFrage schrieb:

> wie ihr seht hab ich es bisher durch eine globale variable gelöst.
> Das geht doch aber auch mit einer übergabe?

Ein Array aus Funktionspointern ist auch nur ein Array wie jedes andere.
Aber: Innerhalb der Funktion ist das Array nicht mehr als C-Array 
'vorhanden' sondern du hast nur einen Pointer auf das erste Element des 
Arrays.
-> Eine Funktion kann prinzipiell mittels sizeof nicht ermitteln, wie 
groß ein Array ist, von dem sie einen Pointer auf den Anfang bekommen 
hat. Die Funktion kann noch nicht mal feststellen, ob der Pointer 
überhaupt auf ein Array zeigt, oder auf ein einzelnes Element

void foo( int * pI )
{
  // hier ist nicht feststellbar, ob pI auf ein int Array
  // zeigt, oder auf einen einzelnen int
  // Beides ist möglich

}

int main()
{
  int valA[5];   // ein Array von int
  int j;         // ein einzelner int

  foo( valA );   // ist korrekt
  foo( &j );     // ist ebenfalls korrekt
}

und mit einem Array aus Funktionspointern ist das auch nicht anders.


>

> uint8 fpSize= getArrSize(stateArray nFct){
>   return sizeof(nFct) / sizeof(nFct[0]);
> }
>

>
> Leider leider mag das aber der compiler nicht :\

Logisch, denn

    ....       (stateArray nFct)

das ist nun mal kein Pointer, sondern ein einzelnes stateArray Objekt 
(welches trotz seines Namens ja kein Array ist). Wie willst du daher 
davon das Element [0] nehmen?

Nur weil du deinem mittels typedef erzeugten Datentyp einen Namen 
gegeben hast, in dem 'Array' vorkommt, ist es das ja noch lange nicht. 
Das Array hast du ja erst hier

stateArray myStateArray[]=
{
  ...

erzeugt. Du kannst 'stateArray' ja auch durch 'SchnurdirBur' austauschen

typedef void (*SchnurdirBur)(void);

...

SchnurdirBur myStateArray[]=
{
  start0,
  start1,
  start2,
  start3,
  start4,
};

uint8 fpSize= getArrSize(SchnurdirBur nFct){
  return sizeof(nFct) / sizeof(nFct[0]);
}

dann wirds vielleicht etwas klarer, dass du innerhalb der Funktion erst 
mal kein Array hast, sondern eben ein SchnurdirBur-Objekt.

Aber wie gesagt: selbst wenn, würde dir das nichts helfen. Denn der 
Übergabemechanismus eines Arrays sieht nun mal so aus, dass die 
Startadresse des Arrays übergeben wird. Und das hilft dir nichts um die 
Größe des Arrays festzustellen.

#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(*x))

....


int main()
{
  uint8 fpSize = ARRAY_SIZE( myStateArray )
}

und das ganze funktioniert nur dann, wenn myStateArray dann auch 
tatsächlich als Array sichtbar ist. Hier ist es das.
So ....

void foo( stateArray* fnctns )
{
   ...
}

.... ist es das nicht. Da ist es bereits zu einem Pointer degeneriert.

[Karl H. (kbuchegg)]

Und PS:
Du solltest das hier

typedef void (*stateArray)(void);

besser

typedef void (*stateFnct)(void);

(ausgesprochen: State-Function) oder

typedef void (*stateFnctPtr)(void);

(ausgesprochen: Pointer auf eine State Function)
nennen. Denn genau das ist dieser Datentyp: Er beschreibt einen Pointer 
auf eine State Function. Das du daraus dann ein Array baust

stateFnctPtr myStateArray[]=
{
  start0,
  start1,
  start2,
  start3,
  start4,
};

ist zwar nett, ändert aber nichts daran, dass der Datentyp eines 
einzelnen Array Elements ein Pointer auf eine bestimmte Art von 
Funktionen ist.

Ein int wird auch nicht zu irgendetwas anderem, nur weil du

int werte[] = { 1, 2, 3, 4 };

mehrere int in ein Array verpackst. Ein einzelnes Array-Element ist nach 
wie vor ein int. Und bei dir ist ein einzelnes Array-Element nach wie 
vor ein Pointer auf eine Funktion.

[Wusel D. (stefanfrings_de)]

Im compilierten Programm ist ein Array eine Ansammlung von Datensätzen 
mit fester Größe (in Deinem Fall Pointer auf Funktionen). Wie viele 
Datensätze das Array groß ist, steht im Array selbst nicht drin.

Das ist ein elementarer Unterschied zu einigen anderen 
Programmiersprachen, z.B. Java. In Java kannst Du jedes Array fragen, 
wie groß es ist. In C geht das nicht.

sizeof(array) erzeugt KEINEN Programmcode, denn sizeof() ist keine 
Funktionen, sondern ein Makro. Das Makro wird VOR dem Compilieren 
aufgelöst. Der Compiler sieht an dieser Stelle nur noch eine konstante 
Zahl.

Daher muss die Größe von array schon vor dem Compilieren feststehen, 
also am Quelltext ablesbar sein.

In Deinem Fall wird das Array als Parameter übergeben. Es handlet sich 
also nicht mehr um ein einziges fixes Array, sondern man könntes 
theoretisch jedes beliebige Array übergeben. Der Comiler prüft zwar den 
Typ der Datensätze, aber nicht die Größe. Du kannst mal ein Array mit 10 
Datensätzen übergeben, und dann ein anderes Array mit 5 Datensätzen.

Daher kann die Größe erst zur Laufzeit des Programmes ermittelt werden. 
Arrays wissen aber nicht, wie groß sie sind.

Die übliche Lösung in solchen Fällen ist, dass man ein Array als 
Parameter übergibt, und zusätzlich einen Integer, der angibt, wie groß 
das Array ist.

Bei der Objektorienterten Programierung ist das einfacher. Da könntest 
Du das Array durch ein Objekt ersetzen, dass (wie auch immer) mehrere 
Datensätze (in Deinem Fall Funktionspointer) speichert. Das Objekt 
könnte weiterhin wissen, wieviele Datensätze es enthält und wie viele es 
maximal enthalten kann.

Bei Mikrocontrollern würde ich auf C++ verzichten. Das Konzept der 
Objektorientierten Programmierung lässt sich allerdings auch in C 
anwenden - nur etwas umständlicher.

Anstelle des Arrays könntest Du zum Beispiel eine Struktur als Parameter 
übergeben, die das Array UND einen Integer (Größe des Arrays) enthält.