C/C++ Seltsamer Fehler bei zuweisen von Arrays

[DanDanger]

Hallo,

ich habe hier ein ziemlich Seltsames Problem :

Eine Funktion in meinem Programm wird ein float-Array Übergeben.
Die Funktion soll dieses Array nun in 2 Arrays aufteilen.

Hintergrund : Das "Ursprungsarray" beinhaltet Punktkoordinaten, also (x, y)-Wertepaare.
Die Funktion soll nun Alle x-Werte in das Array PX, und alle y-Werte in das Array PY schreiben.

Das ganze habe ich so implementiert :



float PunkteC[13] = {0, 0, 0, 5, 0, 5, 10, 10, 10, 10, 20, 20} ;

/*
Ertwartet die Anzahl der Punkte des Arrays (Also : Arraygrösse/2) und einen
Zeiger auf das Array
*/
void Test(int p_NumPoints, float *p_ptPoints)
{
float PX[6] ; // 12 Werte im Array : = 6 Punkte
float PY[6] ; // => 6 X und 6 Y Werte

double t = 0 ;
float x = 0 ;
float y = 0 ;

int i = 0 ; ;
int ZaehlX = 0 ;
int ZaehlY = 0 ;


/* Das Punkte-Array auf 2 Versch. Arrays (PX, PY) Aufteilen */

for(int xA=0; xA < (p_NumPoints * 2); xA+=2)
{
PX[ZaehlX] = p_ptPoints[xA] ;
cout << "PX[" << ZaehlX << "] = " << PX[ZaehlX] << endl ;
ZaehlX++ ;
}


for(int yA=1; yA <= (p_NumPoints * 2); yA+=2)
{
PY[ZaehlY] = p_ptPoints[yA] ;
cout << "PY[" << ZaehlY << "] = " << PY[ZaehlY] << endl ;
ZaehlY++ ;
}




for(int j=0; j < 6; j++)
{
cout << "X : " << PX[j] << ", " ;
}
cout << endl ;

for(int jA=0; jA < 6; jA++)
{
cout << "Y : " << PY[jA] << ", " ;
}
cout << endl ;

}




int main()
{
cout << "RUNNING....." << endl ;

Test(6, PunkteC) ;


return 0 ;
}


Das Problem ist nun :
In der "Zuweisungsschleife" wird alles Korrekt zugewiesen, aber die beiden Kontrollabfragen nach der zuweisung geben nur Schei*** aus:(

Irgendwas Passiert mir den Arrays PX und PY, denn sobald die "Zuweisungsschleifen" verlassen wurden, sind alle Werte in PX und PY "durcheinander".

Meine Frage : Wieso ?????

PS: Der Code scheint mir sauber zu sein, aber ich benutze noch die gcc-Version 2.95.3.
Kann das ein Bug vom gcc sein ?

[f0rtex]

Ich würde folgendes in den for-loops machen:



...
PX[ZaehlX] = *(p_ptPoints+xA);
...
PY[ZaehlY] = *(p_ptPoints+yA);


greets
f0rtex

[Malte]

Ich hab's mal mit der GCC 3.2.2 ausprobiert, dann kommt die folgende Ausgabe:

RUNNING.....
PX[0] = 0
PX[1] = 0
PX[2] = 0
PX[3] = 10
PX[4] = 10
PX[5] = 20
PY[0] = 0
PY[1] = 5
PY[2] = 5
PY[3] = 10
PY[4] = 10
PY[5] = 20
X : 0, X : 0, X : 0, X : 10, X : 10, X : 20,
Y : 0, Y : 5, Y : 5, Y : 10, Y : 10, Y : 20,

[anda_skoa]

Selber Output mit 2.95.4

Ciao,
_

[DanDanger]

Oh mann,

Danke Leute, aber ich hab (meinen WIRKLICH Dummen) Fehler entdeckt :

Anstatt :


float PX[6] ;
float PY[6] ;


stand in meinen Original-Code :


float PX[3] ;
float PY[3] ;




:rolleyes: :rolleyes: :rolleyes: :rolleyes:
Da das Array mit nur 3 Einträgen viel zu klein war, wurden die Werte natürlich andauernd Überschrieben......
Daher halt die "Seltsame Ausgabe":rolleyes:

Nochmals : Danke

[SumpfMonsterJun]

Hi DanDanger,

evtl. kannst Du das ganze Problem vereinfachen, wenn Du schon das Design änderst! Anstatt die X/Y-Werte interleaved in einem Array zu speichern könntest Du eine Structur oder ein Typedef benutzen ( #typedef float koord[2]; koord[Anzahl Koordinaten].
Noch eleganter wäre die Benutzung sog. paralleler Arrays, d.h. von Anfang an getrennte Arrays für X/Y. Ist viel leichter zu erweitern und zu warten.
Falls Du C++ nutzt empfehle ich Dir dringend, soviel wie irgendmöglich die STL zu benutzen.

MfG

SumpfMonsterJun

[DanDanger]

Hi,

Danke für den Tipp.

Das "Design" mit den "interleaved Array's" ist wirklich blöd, aber Leider ist die Schnittstelle vorgeschrieben. Das Programm ist so eine Art "Plug In", und ich muss da halt die Schnitstelle nutzen, die das Host Programm bietet.

Gruss
DanDanger