Zugriff außerhalb der Klasse

[etsmart]

Ich habe eine Frage betreffend Klassenzugriff.
Wie man unten sehen kann erstelle ich CSV aus der Klasse CSVInterface global für alle Funktionen. Dann fülle ich die Struktur IGBTDaten mit Werten mit Hilfe der Funktion CSV.DateiLesen("Dateiname"). Diese Funktion funktioniert, hab ich schon ausprobiert in einem Konsolenprogram.
Das alles findet in der Funktion PrepareExcelImport statt. Wenn ich jetzt versuche auf diese Daten in der Funktion Simulate_ExcelImport_TR zuzugreifen, erhalte ich als Rückgabe ausschließlich 0.
Warum? Ich habe CSV global erstellt. Dann sollte ich doch in jeder Funktion mit z.B. CSV.IGBTDaten.ESum[0] auf diese Daten zugreifen können.

struct IGBTStruktur {		// Beschreibung struct für das Auslesen der Datensatzdatei
		// Beschreibung IGBT Modul
		int Reihe[VTSize];
		string ch_Hersteller;
		string ch_Typ;
                   ...
		double VT_Eoff[VTSize];
		double VT_I[VTSize];
		double VT_ESum[VTSize];
	} IGBTDaten;

struct IGBTStruktur {		// Beschreibung struct für das Auslesen der Datensatzdatei
		// Beschreibung IGBT Modul
		int Reihe[VTSize];
		string ch_Hersteller;
		string ch_Typ;
		double i_Nennspannung;
		double i_Nennstrom;
                  ...
		double VT_I[VTSize];
		double VT_ESum[VTSize];
		// Rückgabewerte
		double Energy[9];	// Energy[0] = Eon1; Energy[1] = Eoff1; Energy[2] = Esum1
							// Energy[3] = Eon2; Energy[4] = Eoff2; Energy[5] = Esum2
							// Energy[6] = EonI; Energy[7] = EoffI; Energy[8] = EsumI
		string temp;
	} IGBTDaten;

...
#include "CSVSchnittstelle.h"

CSVInterface CSV;

FCTDECL Prepare_ExcelImport( CModUser *pMod )
{

	//inner states--AddNode_State
	//conservativ nodes-- AddNode__c
	//non-conservativ nodes--AddNode_nc
	//**********************************************************************************
	// Datensatz einlesen

	CSV.DateiLesen("D:/Diplomarbeit/Simplorer/ExcelImport2/Release/IGBTDatensatz.csv");	
...
}

FCTDECL Simulate_ExcelImport_TR( CModUser *pMod )
{
	CSV.FindEnergy(
		pMod->GetValNode_nc("Td"),
		pMod->GetValNode_nc("Ud"),
		pMod->GetValNode_nc("Id")	);
	//pMod->SetValNode_nc("Eon",CSV.IGBTDaten.Energy[3]);
	pMod->SetValNode_nc("Eon",125.0);
	pMod->SetValNode_nc("Eoff",CSV.IGBTDaten.Energy[2]);
	pMod->SetValNode_nc("ESum",CSV.IGBTDaten.Energy[3]);
	MessageBox(NULL,CSV.IGBTDaten.ch_Hersteller.c_str(),"Betriebspunkt-Information",MB_OK);

	return TRUE;
}

[Simon2]

Hi,

mal ganz kurz für das Verständnis:

• Eine Klasse erstellt man mit der Programmierumgebung (Editor; OK, jetzt nix über Instantiierung von Klassentemplates.... ); was Du da "erstellst", ist ein Objekt.
• Der Scope ("Gültigkeitsbereich") eines Objekts hat nichts mit Zugriffsbeschränkungen zu tun; Wenn ein Member private ist, bleibt er es .. auch wenn ein Objekt dieser Klasse als gobale Variable angelegt wird.
• Wenn CSVInterface (leider präsentierst Du uns nicht die Klassendeklaration) eine abstrakte Klasse sein sollte (wie man es meinen könnte aufgrund des Namens), kannst Du sie nicht "instantiieren" (erzeugen). Du kannst lediglich einen Zeiger/Referenz auf eine nichtabstrakte (konkrete) Kindklasse halten.
• Es wäre sehr hilfreich, wenn Du kurz beschreibst, was bei Dir nicht klappt: Compilermeldung ? Werte im Programm nicht die erwarteten ? Programmabsturz ? ...

Gruß,

Simon2.

[etsmart]

Nun denn, werde ich nochmal Vokabeln lernen.
Leider ist der ganze Code schon zu umfangreich um hier alles zu posten.
Ich erstelle das Objekt CSV aus der Klasse CSVInterface. In diesem Objekt speichere ich Daten in eine Struktur mit dem Namen IGBTDaten.
Es kommt keine Fehlermeldungen. Wenn ich versuche die Werte wieder auszulesen, kommt nur 0 als Rückgabewert für alle Variablen.

[Simon2]

etsmart schrieb:

...
Leider ist der ganze Code schon zu umfangreich um hier alles zu posten.
..

Dann poste doch mal wenigstens ein minimal-Auszug Deiner auslese-Funktion.

Gruß,

Simon2.

[etsmart]

class CSVInterface	{
public:
	int memclear(void);										//Datensatz initiatlisieren
	int IGBTLesen(char* pszFilename);						//Datensatz auslesen
	int IGBTSchreiben(char* pszFilename);					//Datensatz Änderung einsetzen
	int KKLesen(char* pszFilename);							//Datensatz auslesen
	int KKSchreiben(char* pszFilename);						//Datensatz Änderung einsetzen
	int VerzeichnisLesen(char* pszFilename);				//Verzeichnis einlesen und als Textarray speichern
	double FindCellDouble(string& s,int n);					//Double Wert in String finden
	string FindCellString(string& s,int n);					//String Wert in String finden
	double CellValueDouble(char* pszFilename,int x,int y);	//Double Wert mit Hilfe von Koordinaten finden
	string CellValueString(char* pszFilename,int x,int y);	//String Wert mit Hilfe von Koordinaten finden
	int Sortieren(void);									//Sortiert Schaltverlusttabelle
	int Testausgabe(void);
	void quicksort(double *a, int left, int right);
	void bubblesort(double v[], int n);
	int FindEnergy(double Td,double Ud,double Id);

public:
	struct IGBTStruktur {		// Beschreibung struct für das Auslesen der Datensatzdatei
		// Beschreibung IGBT Modul
		int Reihe[VTSize];
		string ch_Hersteller;
		string ch_Typ;
		double i_Nennspannung;
		double i_Nennstrom;
		string ch_Pack;
		string ch_Kommentar;
		// Statische Wärmewiderstände
		double d_StatIGBTRth;
		double d_StatDiodeRth;
		double d_StatModulRth;
		// Transiente Wärmewiderstände
		double d_TransIGBTRth[uiSize];
		double d_TransIGBTTau[uiSize];
		double d_TransDiodeRth[uiSize];
		double d_TransDiodeTau[uiSize];
		// Tabellen der Leitwerte
		double d_IGBT_U;
		double d_IGBT_r;
		double d_Diode_U;
		double d_Diode_r;
		// Wertepaare 
		double IGBTui_T[uiSize];
		double IGBTui_U[uiSize];
		double IGBTui_I[uiSize];
		double Diodeui_T[uiSize];
		double Diodeui_U[uiSize];
		double Diodeui_I[uiSize];
		//Schaltverlusttabelle
		double VT_T[VTSize];
		double VT_U[VTSize];
		double VT_Ion[VTSize];
		double VT_Eon[VTSize];
		double VT_Ioff[VTSize];
		double VT_Eoff[VTSize];
		double VT_I[VTSize];
		double VT_ESum[VTSize];
		// Rückgabewerte
		double Energy[9];	// Energy[0] = Eon1; Energy[1] = Eoff1; Energy[2] = Esum1
							// Energy[3] = Eon2; Energy[4] = Eoff2; Energy[5] = Esum2
							// Energy[6] = EonI; Energy[7] = EoffI; Energy[8] = EsumI
		string temp;
	} IGBTDaten;

	struct KKStruktur {
		string ch_Typ;
		string ch_Kommentar;
		double d_TransKKRth[uiSize];
		double d_TransKKTau[uiSize];

	} KKDaten;

};

CSVInterface::IGBTLesen(char* pszFilename) {

	string line;		// Speichert eingelesene Zeile zur weiterverarbeitung

	//cout << "Methode -> IGBTLesen <-" << endl;	

// ***********************************************************************
	 memclear();
// ***********************************************************************

	IGBTDaten.ch_Hersteller = CellValueString(pszFilename,2,1);
	IGBTDaten.ch_Typ = CellValueString(pszFilename,2,2);
	IGBTDaten.i_Nennspannung = CellValueDouble(pszFilename,2,3);
	IGBTDaten.i_Nennstrom = CellValueDouble(pszFilename,2,4);
	IGBTDaten.ch_Pack = CellValueString(pszFilename,2,5);
	IGBTDaten.ch_Kommentar = CellValueString(pszFilename,2,6);
	IGBTDaten.d_StatIGBTRth = CellValueDouble(pszFilename,3,13);
	IGBTDaten.d_StatDiodeRth = CellValueDouble(pszFilename,3,14);
	IGBTDaten.d_StatModulRth = CellValueDouble(pszFilename,3,15);
	IGBTDaten.d_IGBT_U = CellValueDouble(pszFilename,3,28);
	IGBTDaten.d_IGBT_r = CellValueDouble(pszFilename,6,28);
	IGBTDaten.d_Diode_U = CellValueDouble(pszFilename,3,29);
	IGBTDaten.d_Diode_r = CellValueDouble(pszFilename,6,29);

	int i = 0;	
	for(int m=2;m<=2+VTSize-1;m++) for(int n=19;n<=19;n++) {
		IGBTDaten.d_TransIGBTRth[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;	
	for(m=2;m<=2+VTSize-1;m++) for(int n=20;n<=20;n++) {
		IGBTDaten.d_TransIGBTTau[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;	
	for(m=2;m<=2+VTSize-1;m++) for(int n=23;n<=23;n++) {
		IGBTDaten.d_TransDiodeRth[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;	
	for(m=2;m<=2+VTSize-1;m++) for(int n=24;n<=24;n++) {
		IGBTDaten.d_TransDiodeTau[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;	
	for(m=1;m<=1;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_T[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=2;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_U[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=3;m<=3;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_Ion[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=4;m<=4;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_Eon[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=5;m<=5;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_Ioff[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=6;m<=6;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_Eoff[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=7;m<=7;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_I[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=8;m<=8;m++) for(int n=45;n<=(45+VTSize-1);n++) {
		IGBTDaten.VT_ESum[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=(2+uiSize-1);m++) for(int n=32;n<=32;n++) {
		IGBTDaten.IGBTui_T[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=(2+uiSize-1);m++) for(int n=33;n<=33;n++) {
		IGBTDaten.IGBTui_U[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=(2+uiSize-1);m++) for(int n=34;n<=34;n++) {
		IGBTDaten.IGBTui_I[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=(2+uiSize-1);m++) for(int n=36;n<=36;n++) {
		IGBTDaten.Diodeui_T[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=(2+uiSize-1);m++) for(int n=37;n<=37;n++) {
		IGBTDaten.Diodeui_U[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

	i = 0;
	for(m=2;m<=(2+uiSize-1);m++) for(int n=38;n<=38;n++) {
		IGBTDaten.Diodeui_I[i] = CellValueDouble(pszFilename,m,n);
		i++;
	} // for

// ***********************************************************************

	//cout << endl;

// ***************************************************************************************
	return 0;
} // IGBTLesen

[Simon2]

Hi,

sorry, aber das sieht mir nicht wirklich nach einem "Minimal-Auszug" aus. Ist mir ingsgesamt zu lang, zum Lesen. Wichtig sind folgende Punkte:

• Wie wird die Struktur initialisiert ? (Bei der Konstruktion und vor der ersten Nutzung)
• Wer manipuliert die Daten wann ? (also wo wird die Init-Funktion (Einlesen aus einem File ?) aufgerufen ? Wer schreibt sonst darein ? ...)
• Wann liest Du die Daten aus ? Welche Funktionsaufrufe liegen dazwischen ?

Gruß,

Simon2.

[Gamer4]

etsmart schrieb:

....

Sorry für OT:
Bekommen da nicht noch andere Leute ausser mir puren Augenkrebs?

[camper]

Eine solche Funktion hat einen grunsätzlichen Defekt: Überüberüberlänge.
Eine Funktion: eine Aufgabe. Stichwort: Refaktoring
Und dabei habe ich jetzt nicht näher hingeschaut
bei Sachen wie

for(int n=23;n<=23;n++)

habe ich da einfach keine Lust.
und Tonnen an magischen Konstanten...

[etsmart]

Es ging mir hier um grundlegende Fehler. Das es kein besonders guter Programmierstil ist, ist mir klar. Das liegt zum einen da dran, dass das ganze später wieder auseinandergenommen wird und in eine andere Programmierumgebung eingebunden werden muss, die nicht 100% C/C++ ist. Und da siehts dann schon wieder anders aus.
Also bitte konstruktive Kritik! Ich habe übrigens auch den nichtvorhandenen Fehler gefunden. Es liegt an der besagten anderen Programmierumgebung.
@Simon2 Danke