Optimierungsproblem mit Zeigerarithmetik

Gantenbein

Hallo,
ich versuche gerade ein Programm zu schreiben, dass eine Art gleitenden Mittelwert über aufgenommene Werte bildet. Das jedoch derart, dass dieser jeweils sperat von der ersten, weiten usw. Matrix nach einem Marker gemacht wird. Das funktioniert soweit auch wunderbar, jedenfalls mit der auskommentierten Berechnung. Nun würde ich das aber gerne optimieren und dachte daran, dass man vielleicht nicht explizit über die Inhalte der Arrays gehen müßte sondern es vielleicht auch möglich wäre das über Zeigerarithmetik zu bewerkstelligen. Nun bin ich jedoch recht neu auf dem Gebiet und habe keine Ahnung inwiefern das überhaupt möglich ist, geschweige denn wie ich das mit meinen Strukturen umsetze. Ich dachte dfann daran, dass es vielleicht folgendermaßen ginge:
Wo es im einfachen Fall ohne struktur elt++ wäre dann eben (*OutFlow)->elt++ zu schreiben. Naja mit den Programmzeilen, wie sie gerade sind erzählt mir der Compiler, dass man keine Zeiger addieren kann. Da hat er sicher recht aber dennoch habe ich im Hinterkopf, dass mir mal jemand erzählte, dass man mit so etwas einen code optimieren könne. (Über andere Optimierungsvorschläge und kontruktive Kritik bin ich natürlich auch dankbar).

/* Call Library source file */

#include "extcode.h"

/* Typedefs */

typedef struct {
	int32_t dimSizes[2];
	float elt[1];
	} TD1;
typedef TD1 **TD1Hdl;

typedef struct {
	int32_t dimSizes[3];
	float elt[1];
	} TD2;
typedef TD2 **TD2Hdl;

__declspec(dllexport)int32_t MovingAverage(int32_t *FrameLength, uint8_t *Marker, TD1Hdl InFlow, TD2Hdl OutFlow, int32_t *AverageNrCount, int32_t *FrameNr);

int32_t MovingAverage(int32_t *FrameLength, uint8_t *Marker, TD1Hdl InFlow, 
	 TD2Hdl OutFlow, int32_t *AverageNrCount, int32_t *FrameNr)

{

int k, i, j, Fnum1, Fnum2, Fnum3;

Fnum1 = (*OutFlow)->dimSizes[0];
Fnum2 = (*OutFlow)->dimSizes[1];
Fnum3 = (*OutFlow)->dimSizes[2];

if(*Marker==1 && ((*FrameNr==Fnum1)||(*FrameNr==0)))
{
*FrameNr=0;
*AverageNrCount=*AverageNrCount+1;
}

if(*FrameNr<Fnum1)
{
k=*FrameNr;
	for(i=0;i<Fnum2;i++)
	{
		for(j=0;j<Fnum3;j++)
		{

/*(*OutFlow)->elt[((k*Fnum2*Fnum3)+(i*Fnum3)+j)] =
( ((*OutFlow)->elt[((k*Fnum2*Fnum3)+(i*Fnum3)+j)]*(*AverageNrCount-1)) + (*InFlow)->elt[((i*Fnum3)+j)] ) / *AverageNrCount; */

(*OutFlow)->elt+((k*Fnum2*Fnum3)+(i*Fnum3)+j) =
( ((*OutFlow)->elt+((k*Fnum2*Fnum3)+(i*Fnum3)+j) *(*AverageNrCount-1)) + (*InFlow)->elt+((i*Fnum3)+j) ) / *AverageNrCount;

		}
	}
*FrameNr=*FrameNr+1;
}//if

return 0;
}

DaRpH

Ohne jetzt genau die Logik dahinter durchzublicken aber nutze doch anstatt zugriff per index nur inkrement.

aller:

int num[20];

// ... füllen

int* iter = &num[0];
int* iterend = &num[sizeof(num)/sizeof(int)];
int sum;
double avg;

while(iterend != iter)
{
   sum += *iter;
    ++iter;
}
avg = (double)sum/(sizeof(num)/sizeof(int));

Das ganze Funktioniert auch mit mehrdimensionalen Arrays musst dir nur vorstellen das es eigentlich nicht mehrere Dimensionen gibt sondern die Daten trotzdem hintereinander stehen...