Zeiger in typedef Variable die Zweite

[CJens]

Hallo.

Ich hänge noch immer an meiner Funktion. Die läuft jetzt zwar, aber ich kann nach der Funktion auf einmal nicht mehr auf meine Werte zugreifen.

Man stelle sich das wie folgt vor:

int main()
TNode * pNode; //Benutzerdefinierter Variablentyp (siehe weiter unten)
TQuad * pQuad; //Benutzerdefinierter Variablentyp
unsigned long nNode, nQuad, nInternalNodes;
unsigned long * pInternalNodes;

//...
//pNode wird mit Werten befüllt.
//pQuad wird mit Werten befüllt.
//nNode und nQuad erhalten die Anzahl der Einträge von pNode und pQuad.
//pInternalNodes bekommt einige Knotennummern zugewiesen.
//nInternalNodes bekommt die Anzahl der Knotennummern zugewiesen.
//...

//Nun wird die Funktion (siehe weiter unten) ausgeführt:
//In dieser Funktion werden die Werte pNode[i].Gamma[j] berechnet, welche
//bei späterer Ausgabe mein Programm zum Absturz bringen.
CalcINPF(pInternalNodes, pNode, pQuad, nNode, nQuad, nInternalNodes, MaxNodeConnectedElements, 0);

//Jetzt möchte ich mir die Werte von pNode.Gamma[i] ausgeben lassen:
for (i=0;i<nNode;i++){
	for (j=0;j<pNode[i].nP;j++){
                //Die nächste Zeile führt zum Abbruch des Programms, solange ich
                //auf pNode[i].Gamma[j] zugreife. Wenn ich das rausnehme und mir
                //nur i und j ausgeben lasse, läuft es wunderbar.
		printf("Index 1: %lu, Index 2: %lu, Gamma: %f\n", i, j, pNode[i].Gamma[j]);
	}
}

return 0;
}

So nun die (evtl. schon bekannte) Funktion CalcINPF.
Hierbei ist zu erwähnen, dass diese Problemlos läuft.
Ich möchte Eure Aufmerksamkeit auf die Zeilen 23, 25 und 40 dieser Funktion lenken. Hier werden die Werte berechnet, gespeichert und anschließend (Z.40) ausgegeben, was problemlos klappt.

int CalcINPF(unsigned long * fpInternalNodes, TNode * fpNode, TQuad * fpQuad, unsigned long fnNode, unsigned long fnQuad, unsigned long fnInternalNodes, unsigned long fMEPN, unsigned int AreaInfluence){
unsigned long fi=0, fj=0, fk=0;
double * Areas = (double *)calloc(fMEPN+1, sizeof(double));
double * Dist = (double *)calloc(fMEPN+1, sizeof(double));
double SArea=0., SDist=0.;
unsigned int OutputINPFs = 1;

for (fi=0;fi<=fnInternalNodes;fi++){

	do{
		Areas[fj] = fpQuad[fpNode[fpInternalNodes[fi]-1].EP[fj]-1].Area;
		Dist[fj] = sqrt(pow(fpQuad[fpNode[fpInternalNodes[fi]-1].EP[fj]-1].P.x - fpNode[fpInternalNodes[fi]-1].x,2) + pow(fpQuad[fpNode[fpInternalNodes[fi]-1].EP[fj]-1].P.y - fpNode[fpInternalNodes[fi]-1].y,2));
		SArea+=Areas[fj];
		SDist+=(1./Dist[fj]);
	}while(++fj<fpNode[fpInternalNodes[fi]-1].nP);

	SArea/=fj;

	fpNode[fpInternalNodes[fi]-1].Gamma = (double *)calloc(fj, sizeof(double));

	for (fk=0;fk<fj;fk++){
		if (AreaInfluence == 1){
			fpNode[fpInternalNodes[fi]-1].Gamma[fk] = (((1./Dist[fk]))/(SDist))*(Areas[fk]/SArea);
		} else {
			fpNode[fpInternalNodes[fi]-1].Gamma[fk] = (1./Dist[fk])/SDist;
		}
		Areas[fk] = 0.; Dist[fk] = 0.;
	}
	SArea = 0.,	SDist = 0., fj=0;
}

my_free(Areas);
my_free(Dist);

if (OutputINPFs==1){
	for (fi=0;fi<=fnInternalNodes;fi++){
		printf("Node number: %lu\n", fpInternalNodes[fi]);
		for (fj=0;fj<fpNode[fpInternalNodes[fi]-1].nP;fj++){
			printf("Index fj: %lu\n", fj);
			printf("Interpolations factor to Element number %lu: %f\n", fpNode[fpInternalNodes[fi]-1].EP[fj], fpNode[fpInternalNodes[fi]-1].Gamma[fj]); //Hier funktioniert die Ausgabe problemlos.
		}
		printf("\n");
	}
}

return 0;
}

Interessant ist auch, dass weder der TCC noch der LCC Compiler Fehlermeldungen ausgeben.

Anbei noch die Definition meiner Benutzerdefinierten Variablen:

typedef struct{
	double Value;
	double Index;
}TMCoeff;

typedef struct{
	double x;
	double y;
}TPoint;

typedef struct{
	double vx;
	double vy;
}TVector;

typedef struct{
	TPoint P;

	unsigned long P1;
	unsigned long P2;
	unsigned long P3;
	unsigned long P4;

	unsigned long E1;
	unsigned long E2;
	unsigned long E3;
	unsigned long E4;

	double Value[NV];

	double Area;

	double D[NV];

	double D1;
	double D2;
	double D3;
	double D4;

	double N1;
	double N2;
	double N3;
	double N4;

	TPoint xs1;
	TPoint xs2;
	TPoint xs3;
	TPoint xs4;

	TPoint xs1t;
	TPoint xs2t;
	TPoint xs3t;
	TPoint xs4t;

	TVector n1;
	TVector n2;
	TVector n3;
	TVector n4;
}TQuad;

typedef struct{
	double x;
	double y;

	double Value[NV];

	unsigned int nP;
	unsigned long * EP;
	double * Gamma;
}TNode;

typedef struct{
	unsigned long P1;
	unsigned long P2;

	TPoint P;

	double Value[NV];
	double Length;

	unsigned int BType[NV];
	//0 = Value
	//1 = Flux
	//2 = Symmetrie

	unsigned int family;
}TBar;

Ist ein wenig viel Input, sorry. Aber ich denke, man kann das Problem auf einen einfachen Kern reduzieren. Interessant ist auch, dass diese Funktion wiederum läuft (hier greife ich in Zeile 10 auf die Werte des Arrays "Gamma" zu:

int INPValues(unsigned long * fpInternalNodes, unsigned long fnInternalNodes, TQuad * fpQuad, TBar * fpBar, TNode * fpNode, unsigned long ValueNumber){
unsigned long fi=0, fj=0;
unsigned int OutputInterpolatedValues = 0;
double fValue = 0.;
TNode * P;

for (fi=0;fi<=fnInternalNodes; fi++){
	P = &fpNode[fpInternalNodes[fi]-1];
	do{
		P->Value[ValueNumber] += P->Gamma[fj] * fpQuad[P->EP[fj]].Value[ValueNumber];
	}while(++fj<P->nP); fj = 0;
}

if (OutputInterpolatedValues == 1){
	for (fi=0;fi<=fnInternalNodes;fi++){
		printf("Value for node number %lu: %f\n", fpInternalNodes[fi], fpNode[fpInternalNodes[fi]-1].Value[ValueNumber]);
	}
}
return 0;
}

[DirkB]

Jetzt wird es aber mal Zeit den Debugger zu nehmen und zu schauen welchen Wert die Zeiger vor und nach der Funktion haben. (Ich hoffe du initialsierts Gamma mit NULL)

[CJens]

Hallo Dirk,

ich habe das geprüft. Die Zeiger sind während und nach der Funktion gleich.
Der Fehler lag wo anders. Nicht jeder Wert von pNode hat ein Array in Gamma. Also nur bestimmte Knoten haben das. Das kann ich aber über eine einfache Abfrage klären entweder, da .Gamma == NULL oder da .nP == 0

Die Frage hat sich also erledigt.

Trotzdem an alle Vielen Dank.