Werte im Array bewegen

Uruk-h4j

Hallo Zusammen !

Ich habe folgendes Problem. Ich habe einen Array, den ich "von rechts" befülle.
Ich schiebe also die Werte von rechts nach links durch das Array, wobei der letzte dann Rausfällt. Nun stehe ich vor dem Problem, dass ich das bisher so löse:

int temp[3];
	int store[3];

	temp[0] = Acc.x[1280];

	for(int i=1280; i>=0; i--)
	{
	     store[0] = Acc.x[i-1];
	     Acc.x[i-1] = temp[0];
	     temp[0] = store[0];
	}

Bei 1280 Werten läuft das ganze noch relativ Flott. Aber ich muss das später auif 10000 oder mehr aufblähen und für 2 Weitere Arrays durchführen und da wirds dann etwas lahm. Die Funktion wird alle 7-8 ms über einen Multimedia-Timer aufgerufen.

Meine Frage ist, geht es auch einfacher oder eleganter zu befüllen, dass ich das ganze von der benötigten Ausführzeit reduzeiren kann? Oder gibts da evtl. eine andere Vorgehensweise?

Danke

CTecS

Was hällst du von CUIntArray oder eine eigene Verkettete Liste also eine eigene Klasse, wo du nur den ersten Eintrag ausketten und löschen musst und an das ende einen neuen Eintrag erstellst, so wie du das machst über ein Statisches Array und alles umkopieren kann das nicht schnell werden.

Hi,

void CDraw::MovMem(DWORD scr,DWORD anz)
{
	__asm
	{
         mov ebx, this
         mov edi, [ebx]CDraw.m_pTmp;
	mov esi,scr
	mov ecx,anz
          CLD
	rep  movsd 
    }
[code]

mit CLD bzw CLW gibst du die Kopierrichtung vor, so kannst du rückwärts
versetzt umschiffen, der Vorgang passiert im [µs] Bereich bei diesen
kleinen Päckchen da.

Uruk-h4j

SRy, aber mit der MovMem komm ich net klar. Was muss ich da machen. Er sagt mir, dass CDraw undefiniert ist und m_pTemp keine gültige Struktur/Union.

Ein wenig mehr Info wie man das verwendet wäre schön.

Zu CUIntArray und den anderen habe ich das Problem, dass ich da keine negativen Werte eintragen kann (bei UInt ists klar). Aber evtl. hab ich vorher was falsch deklariert. Ich schau nochmal drüber

Uruk-h4j

So hatte vorher eine falsche Variable vergeben, somit war es out of Range. Jetzt läufts damit schonmal. Aber das MovMem einteressiert micht trotzdem noch.

Martin Richter

Und warum verwendest Du nicht std::dequeue, sprich eine Struktur, die für so etwas gebaut ist?

Du könntest auch ganz auf das verschieben des Arrays verzichten und einen rotierenden Puffer verwenden.

Uruk-h4j

Weil ich mich irgendwie auf Arrays versteift hatte und auch std::dequeue nicht kenne. Meine eigene Routine (wenn man das so nennen kann) läuft jaauch bei kleineren Arrays einwandfrei.

Was meinst du mit rotierendem Puffer?

Wutz

Meine eigene Routine (wenn man das so nennen kann) läuft jaauch bei kleineren Arrays einwandfrei.

Ja wirklich?
Und beim Schleifenende mit i==0?
Auf welchen Speicherbereich greifst du dabei mit [0-1] sogar schreibend zu?

Martin Richter

Rotierender Puffer = Der Anfang wird durch einen Index bestimmt. Wenn ein Element entfällt wird einfach der Index um eine Position verschoben und auf Index-1 das neue Element eingetragen.

Das aktuelle nte Element ist einfach durch (startindex+n) % groesse zuzugreifen.
Dann hat man 0 Aufwand zum verschieben.

BTW: Dann solltest Du dir mal die STL ansehen, wenn Du schon (wie Wutz anmerkt) mit eigenen Algorithmen etwas Probleme hast.

Uruk-h4j

Ups, jetzt seh ich auch das da was nicht ganz passt. Hab aber komischerweise nie Fehler oder Abstürze gehabt. Naja ich werd eure tipps mal beherzigen und mir das ganze mal anschauen. Vorerst nutze ich CWordArray für die ersten Versuche.

Danke

Wutz

Falls ich deinen Beispielcode richtig verstanden habe, wie wärs mit strikt konformen ANSI C?

memmove(Acc.x,&Acc.x[1],1279*sizeof(Acc.x[0]))

?
Hat zwar mit diesem Forum nicht mehr viel zu tun, aber der Compiler sollte hierbei schon ziemlich schnellen Code erzeugen.

Es wurde schon gesagt,

ich sage es dennoch nochmal:

Ein Array mit rotierem Startindex ist hier die optimale Lösung.

Gruß Frank

CTecS

nimm halt eine einfach verkettete Liste und für den neuen Eintag an das ende an und lösch den ersten eintrag wenn du das erste element liesst, also erstes element löschen und startzeiger auf den nächsten Eintag umschreiben und fertig.
Beispiele dazu gibt es im netz genügend.
Das ganze is dann in der größe dynamisch und sicher schnell genug, das ganze noch in eine Klasse gekapselt und fertig is dein FIFO.

Martin Richter

@CTecS: Eine verkette Liste ist auch in diesem Falle langsamer, denn der Array ist fest von der Größe. Warum sollte man durch dynamische Allokationen das Ganze wieder ausbremesen.

Nochmal: Rotierender Puffer ist effektiv, einfach, geschmacklos, simpel und leicht zu pflegen...