Liste funktioniert nicht



  • Hallo zusammen,

    ich hab da mal wieder ein Problem.
    Und zwar hab ich eine Liste:

    ListOperation::ListOperation(int sizeOfList)
    
    {
    	Input			= new SaveForFasterLoading[sizeOfList];
    	this->sizeOfList= sizeOfList;
    	numberOfItems	= 0;
    }
    
    //Kopierkonstruktor
    
    ListOperation::ListOperation(ListOperation & gps)
    {
    	sizeOfList		= gps.sizeOfList;
    	Input			= new SaveForFasterLoading[sizeOfList];
    	numberOfItems	= gps.numberOfItems;
    
    	for (int i = 0; i < numberOfItems; i++)
    		Input[i] = gps.Input[i];  
    }
    
    ListOperation::~ListOperation()
    {
    }
    
    void ListOperation::AddItemToList(CString CopyItem, int position)
    {
    
    	Input[numberOfItems].Item=CopyItem;
    	Input[numberOfItems].position=position;
    
    	numberOfItems++;
    
    }
    

    Das Problem ist, das numberOfItems einen Wert von -8999999 hat und ich deswegen laufend Adressfehler bekommen wenn ich etwas in die Liste schreiben möchte.

    Wie kann ich das beheben?

    MfG
    Scalls



  • Hallo,

    etwas Kompilierbares wäre nicht schlecht. Die einzigen Fehler, die ich sehe sind fehlende "delete[]" Aufrufe.



  • Danke für deine schnelle Antwort.

    Hier ist die komplette Klasse:

    Header:

    class Data;
    
    class ListOperation : public CObject
    
    {
    
    public:
    
    	ListOperation();
    	void AddItemToList(CString CopyItem, int position);
    	void ReadIteamFromList();
    	ListOperation(int sizeOfList);
    	ListOperation(ListOperation & gps);
    	ListOperation & operator= (ListOperation & gps);
    	void ReadGroupElementsFromArray(CString groupElement);
    	~ListOperation();
    
    private:
    
    	struct SaveForFasterLoading
    	{
    		CString Item;
    		int		position;
    	};
    
    	SaveForFasterLoading * Input;
    		int	sizeOfList;
    		int numberOfItems;
    
    };
    

    Und hier der Cpp Code:

    #include "ListOperation.h"
    
    ListOperation::ListOperation()
    {
    }
    
    //Konstruktor
    
    ListOperation::ListOperation(int sizeOfList)
    
    {
    	Input			= new SaveForFasterLoading[sizeOfList];
    	this->sizeOfList= sizeOfList;
    	numberOfItems	= 0;
    }
    
    //Kopierkonstruktor
    
    ListOperation::ListOperation(ListOperation & gps)
    {
    	sizeOfList		= gps.sizeOfList;
    	Input			= new SaveForFasterLoading[sizeOfList];
    	numberOfItems	= gps.numberOfItems;
    
    	for (int i = 0; i < numberOfItems; i++)
    		Input[i] = gps.Input[i];  
    }
    
    ListOperation::~ListOperation()
    {
    }
    
    void ListOperation::AddItemToList(CString CopyItem, int position)
    {
    
    	//Input[1].Item=CopyItem;
    	//Input[1].position=position;
    
    	//numberOfItems++;
    
    }
    
    ListOperation & ListOperation::operator= (ListOperation & gps)
    {
    
    	numberOfItems	= gps.numberOfItems;
    
    		for (int i = 0; i < numberOfItems; i++)
    		{
    			Input[i] = gps.Input[i];
    		}
    
    	return *this;
    }
    
    void ListOperation::ReadGroupElementsFromArray(CString groupElement)
    {
    
    }
    

    Drn String und den Integer übergeb ich aus einer anderen Klasse.
    Das kommt auch alles an, habs schon getestet indem ich die Daten in ne Textdatei gespeichert hab.
    Aber sobald ich in die Liste schreiben will, kommt der Adressfehler!



  • Dein operator= geht fröhlich davon aus, dass this->Input mindestens genauso groß ist wie gps.Input. Vielleicht kopierst du deshalb auch gps.sizeOfList nicht?

    Es wäre noch wichtig zu sehen, wie du die Klasse benutzt.



  • ähm sorry MFK,

    aber ich weiss nicht was du meinst.
    Kannst du das bitte einem Amateur erklären.

    Danke



  • Scalls schrieb:

    aber ich weiss nicht was du meinst.

    Das ist dein operator=

    Scalls schrieb:

    ListOperation & ListOperation::operator= (ListOperation & gps)
    {
    
    	numberOfItems	= gps.numberOfItems;
    
    		for (int i = 0; i < numberOfItems; i++)
    		{
    			Input[i] = gps.Input[i];
    		}
    
    	return *this;
    }
    

    Wenn gpd.numberOfItems größer ist als sizeOfList der Instanz, der zugewiesen wird, dann schreibst du in der Schleife über die Arraygrenze hinweg.

    Das ist zwar ein Fehler, aber wohl nicht der einzige, denn er erklärt nicht das beschriebene Verhalten. Du musst uns zeigen, wie du die Klasse benutzt. Am besten wäre ein vollständiges, kompilierbares Minimalbeispiel, das den Fehler reproduziert.



  • Okay hier ist der komplette Code.

    ListOperationHeader:

    class Data;
    
    class ListOperation : public CObject
    
    {
    
    public:
    
    	ListOperation();
    	void AddItemToList(CString CopyItem, int position);
    	void ReadIteamFromList();
    	ListOperation(int sizeOfList);
    	ListOperation(ListOperation & gps);
    	ListOperation & operator= (ListOperation & gps);
    	void ReadGroupElementsFromArray(CString groupElement);
    	~ListOperation();
    
    private:
    
    	struct SaveForFasterLoading
    	{
    		CString Item;
    		int		position;
    	};
    
    	SaveForFasterLoading * Input;
    		int	sizeOfList;
    		int numberOfItems;
    
    };
    

    ListOperation:

    ListOperation::ListOperation()
    {
    
    	//AddItemToList();	
    
    }
    
    //Konstruktor
    
    ListOperation::ListOperation(int sizeOfList)
    
    {
    	Input			= new SaveForFasterLoading[sizeOfList];
    	this->sizeOfList= sizeOfList;
    	numberOfItems	= 0;
    }
    
    //Kopierkonstruktor
    
    ListOperation::ListOperation(ListOperation & gps)
    {
    	sizeOfList		= gps.sizeOfList;
    	Input			= new SaveForFasterLoading[sizeOfList];
    	numberOfItems	= gps.numberOfItems;
    
    	for (int i = 0; i < numberOfItems; i++)
    		Input[i] = gps.Input[i];  
    }
    
    ListOperation::~ListOperation()
    {
    	/*for (int i = 0; i < numberOfItems; i++) {
    			delete Input[i].Item;
    			delete Input[i].position;
    	}*/
    
    }
    
    void ListOperation::AddItemToList(CString CopyItem, int position)
    {
    
    	Input[1].Item=CopyItem;
    	Input[1].position=position;
    
    	numberOfItems++;
    
    }
    
    ListOperation & ListOperation::operator= (ListOperation & gps)
    {
    
    	numberOfItems	= gps.numberOfItems;
    
    		for (int i = 0; i < number OfItems; i++)
    		{
    			Input[i] = gps.Input[i];
    		}
    
    	return *this;
    }
    
    void ListOperation::ReadGroupElementsFromArray(CString groupElement)
    {
    
    }
    

    DataHeader:

    #if !defined(AFX_DATA_H__67144F14_10DC_11D7_BF70_00C04F515A9F__INCLUDED_)
    #define AFX_DATA_H__67144F14_10DC_11D7_BF70_00C04F515A9F__INCLUDED_
    
    #if _MSC_VER > 1000
    #pragma once
    #pragma warning(disable:4018)
    #endif // _MSC_VER > 1000
    
    #include "Group.h"
    #include "vector"
    #include "string"
    
    struct HeaderFileEntry;
    class CPermEvFile;
    class CElement;
    class Liste;
    class CData : public CObject  
    {
    	void Init();
    public:
    	void updateDataBezeichner (const char* strVersion, const CTime *pDatum, const char* strStoreTable);
    	int getGroupCount();
    	void drucken(CWnd * pWnd);
    	void kopierInDatei();
    	void updateHeaderEntry(HeaderFileEntry* pEntry,bool bUpdateDate);
    	void setKonstBezeichner(const char * pBezString);
    	CString getKonstBezeichner();
    	void setDataBezeichner(const char * pBezString);
    	CString getDataBezeichner();;
    	CString getDataBezeichnerVersion();
    	CString getDataBezeichnerDate();
    	CString getDataBezeichnerStoreTable();
    	void setChecksum();
    	unsigned short getChecksum();
    	void initData(const char *strConfigFileName, const char *strPath);
    	void save();
    	CGroup* getGroup(short GroupNumber);
    	CGroup* getAktFile(char* Daten);
    	CData(const char *strConfigFileName,const char* strDataPath);
    	CData();
    	virtual ~CData();
    	//void initData(char *configFileName, char *dataFileName1, char *dataFileName2);
    	//void save(char *dataFileName1, char *dataFileName2);
    	//CData(char* configFileName, char *dataFileName1, char *dataFileName2);
    
    	bool m_bChanged; //Flag, ob änderung vorgenommen wurde
    	CString m_strDataPath;
    	char& operator [] (int ID)
    	{
    		return m_pData[ID];
    	}
        CData(int groesse); 
    	CData(CData & rempfad);
        void eintragen(CString name, long nummer);
        bool suchen(CString & name, long nummer);
        CData & operator= (CData & rempfad);
        long & operator[](CString name);
    	void copyItemsToList();
    
    private:
    	char* m_pData;
    	void deleteData();
    	int m_SizeFile2;
    	unsigned short m_DataPos;
    	CObArray m_oaGroups;
    	CPermEvFile* m_pPerEvData;
    
    	struct VersionElements
    	{
    		CElement* pVersion;
    		CElement* pDay;
    		CElement* pMonth;
    		CElement* pYear;
    	}	m_VersionElements;
    
    	struct Eintrag
        {
          CString  name;
          long	nummer;
    
        };
    
    	Eintrag * verzeichnis;
        int       groesse;
        int       anzahlEintraege;
    
    };
    

    DataKlasse aus der ich den String und den Integer übergebe:

    CData::CData()
    {
    	Init();
    }
    
    /**
     * Konstruktor
     * legt den Datensatz aus dem File dataFileName und die Beschreibungen
     * aus dem File configFileName im RAM an
     *
     * Parameter:  char* configFileName, char *dataFileName
     * Returnwert: void
     *
     */
    CData::CData (const char *strConfigFileName,const char* strDataPath)
    //(char *configFileName, char *dataFileName1, char *dataFileName2)
    {
    	Init();
    	//initData(configFileName, dataFileName1, dataFileName2);
    	initData(strConfigFileName, strDataPath);
    }
    
    void CData::Init()
    { 
    	//----------------------------------------------------------------
    	// Initalisiert Membervariablen
    	//----------------------------------------------------------------
     	m_DataPos = 0;
    	m_SizeFile2 = 0;
    	m_pData = NULL;
    	//m_pFile1Bezeichner = NULL;
    	m_pPerEvData = NULL;
    	memset (&m_VersionElements,0,sizeof(m_VersionElements));
    
    }
    
    /**
     * Destruktor
     * 
     * Parameter:  void
     * Returnwert: void
     *
     */
    CData::~CData()
    {
    	this->deleteData();
    }
    
    /**
     * Methode deleteData
     * entfernt den Datensatz aus dem Speicher / gibt den Speicher frei
     * 
     * Parameter:  void
     * Returnwert: void
     *
     */
    void CData::deleteData()
    {
    	TRACE("\n Datensatz wird gelöscht \n");
    
    	//delete [] m_pFile1Bezeichner;
    	delete [] m_pData;
    	delete m_pPerEvData;
    	// Get the number of lines in the object array?
    	int liCount = m_oaGroups.GetSize();
    	// Are there any objects in the array?
    	if (liCount) {
    		// Loop through the array, deleting each object
    		for (int i = 0; i < liCount; i++) {
    			delete m_oaGroups[i];
    		}
    		// Reset the array
    		m_oaGroups.RemoveAll();
    	}
    	Init();
    }
    
    /**
     * Methode getGroup(short GroupNumber)
     * liefert einen Pointer der auf die Gruppe des Datensatzes mit der
     * mitgegebenen Gruppennummer zeigt
     *
     * Parameter:  short groupNumber
     * Returnwert: CGroup*
     *
     */
    CGroup* CData::getGroup(short groupNumber)
    {
    	return (CGroup*) m_oaGroups[groupNumber];
    }
    
    /**
     * Methode save
     * speichert den Datensatz in 2 Files mit den übergebenen FileNamen
     *
     * Parameter:  char *dataFileName1, char *dataFileName2
     * Returnwert: void
     *
     */
    //void CData::save(char *dataFileName1, char *dataFileName2)
    void CData::save()
    {
    
    	char strFile1[_MAX_PATH],strFile2[_MAX_PATH];
    
    	_makepath (strFile1,NULL,m_strDataPath,DEFAULT_DATA_FILE_NAME1,NULL);
    	_makepath (strFile2,NULL,m_strDataPath,DEFAULT_DATA_FILE_NAME2,NULL);
    
    	ofstream dataOutStream1(strFile1,ios::binary);
    	if (dataOutStream1) {
    		dataOutStream1.write(m_pData,(SIZEPEDDATAFILE1));
    		dataOutStream1.write((m_pData+POSBEZEICHNER),SIZEBEZEICHNER);
    		dataOutStream1.close();
    	}
    	else {
    		CString message;
    		message.Format("Datei %s konnte nicht geöffnet werden \n Daten wurden nicht gespeichert", strFile1);
    		AfxMessageBox(message);
    	}
    
    	ofstream dataOutStream2(strFile2,ios::binary);
    	if (dataOutStream2) {
    		dataOutStream2.write((m_pData+SIZEPEDDATAFILE1),m_SizeFile2);
    		dataOutStream2.close();
    	}
    	else {
    		CString message;
    		message.Format("Datei %s konnte nicht geöffnet werden \n Daten wurden nicht gespeichert", strFile2);
    		AfxMessageBox(message);
    	}
    
    	m_pPerEvData->Save();
    }
    
    /**
     * Methode initData
     * Zur Initialisierung/Reinitialisierung des CData Objekts 
     *
     * Parameter:  char* configFileName, char *dataFileName1, char *dataFileName2
     * Returnwert: void
     *
     */
    //void CData::initData(char *configFileName, char *dataFileName1, char *dataFileName2)
    //Liste* CData::initData(const char *strConfigFileName, const char *strPath)
    long w = 0;
    int x=0;
    CData loespfad(600);  //Konstruktoraufruf
    void CData::initData(const char *strConfigFileName, const char *strPath)
    {
    
    	fstream f;
    	f.open("Test.txt",ios::app);
    	char strFile1Bezeichner[SIZEBEZEICHNER+1];
    
    	TRACE("Datensatz wird initialisert \n");
    	m_bChanged = false;
    
    	if (m_pData) 
    	{
    		TRACE("Destruktor von CData wird aufgerufen");
    		this->deleteData();
    	}
    
    	m_strDataPath = strPath;
    
    	char strFile1[_MAX_PATH],strFile2[_MAX_PATH],strFilePerEv[_MAX_PATH];
    
    	_makepath (strFile1,NULL,strPath,DEFAULT_DATA_FILE_NAME1,NULL);
    	_makepath (strFile2,NULL,strPath,DEFAULT_DATA_FILE_NAME2,NULL);
    	_makepath (strFilePerEv,NULL,strPath,DEFAULT_PEREV_FILE_NAME,NULL);
    
    	m_SizeFile2 = 0;
    	m_DataPos = 0;
    	m_pData = NULL;
    
    	m_pPerEvData = new CPermEvFile (strFilePerEv);
    
    	// PED-Daten einlesen
    	ifstream dataFile2(strFile2,ios::binary|ios::nocreate);
    	if (dataFile2.is_open()) {
    		dataFile2.seekg(0, ios::end);
    		m_SizeFile2 = dataFile2.tellg();
    		TRACE("File2 Size: %d \n", m_SizeFile2);		
    
    		//Daten werden von File2 eingelesen
    		dataFile2.seekg(0, ios::beg);
    		m_pData = new char[(m_SizeFile2+SIZEPEDDATAFILE1)];
    		char ch = 0;
    		for (int i=0;i<m_SizeFile2;i++) {
    			dataFile2.get(ch);
    			m_pData[i+SIZEPEDDATAFILE1]=ch;
    		}
    		dataFile2.close();
    	}
    	else {
    		CString message("Datei ");
    		message += strFile2;
    		message += " konnte nicht geöffnet werden!";
    		AfxMessageBox(message);
    		throw "Fehler";
    
    	}
    
    	ifstream dataFile1(strFile1,ios::binary|ios::nocreate);
    	if (dataFile1.is_open()) {
    		dataFile1.seekg(0, ios::end);
    		int sizeFile1 = dataFile1.tellg();
    
    		TRACE("File1 Size: %d \n", sizeFile1);		
    
    		if (sizeFile1 != SIZEFILE1)
    			AfxMessageBox("Data-File1 has wrong size");
    
    		//Daten werden von File1 eingelesen
    		dataFile1.seekg(0, ios::beg);
    		char ch = 0;
    		int i=0;
    		for (i=0;i<SIZEPEDDATAFILE1;i++) {
    			dataFile1.get(ch);
    			m_pData[i]=ch;
    		}
    
    		//Bezeichner von File1 wird eingelesen
    		strFile1Bezeichner[SIZEBEZEICHNER] = 0;
    		for (i=0;i<SIZEBEZEICHNER;i++) {
    			dataFile1.get(ch);
    			strFile1Bezeichner[i]=ch;
    
    		}
    		dataFile1.close();
    
    	}
    	else {
    		CString message("Datei ");
    		message += strFile1;
    		message += " konnte nicht geöffnet werden!";
    		AfxMessageBox(message);
    		deleteData();
    		throw "Fehler";
    	}
    
    	//Vergleich: Sind Bezeichner gleich ?
    	if (!strncmp(strFile1Bezeichner,(m_pData+SIZEPEDDATAFILE1+POSFILE2BEZ),SIZEBEZEICHNER) == 0) {
    		char File2Bezeichner[SIZEBEZEICHNER+1];
    		File2Bezeichner[SIZEBEZEICHNER] = 0;
    		strncpy(File2Bezeichner, (m_pData+SIZEPEDDATAFILE1+POSFILE2BEZ),SIZEBEZEICHNER);
    
    		//Ausgabe Fehlermeldung: Bezeichner sind nicht gleich
    		//Bezeichner drehen
    		char szBezeichner[SIZEBEZEICHNER+1];
    		for(int i=0; i<SIZEBEZEICHNER; i+=2) {
    			szBezeichner[i] = strFile1Bezeichner[i+1];
    			szBezeichner[i+1] = strFile1Bezeichner[i];
    		}
    		szBezeichner[SIZEBEZEICHNER] = 0;
    
    		CString message("Warnung: Dateien haben unterschiedliche Bezeichner \n\n");
    		message += "File 1: "; message += strFile1;
    		message += "\n Bezeichner: "; message += szBezeichner;
    		message += "\n File 2: "; message += strFile2;
    		message += "\n Bezeichner: ";
    		message += getDataBezeichner();
    		AfxMessageBox(message);
    
    		TRACE("Bezeichner sind nicht identisch \n");
    		TRACE("Bezeichner File1: %s \n",strFile1Bezeichner);
    		TRACE("Bezeichner File2: %s \n",File2Bezeichner);
    	}
    
    	// PED-Beschreibungen aus Config File einlesen
    	CCfgParser parser(strConfigFileName);
    
    	char* pToken = NULL;
    	CGroup* pGroup = NULL;
    	char* pName = NULL; 
    	char* pContent = NULL;
    	char* pUnit = NULL;
    	char* pInfoFile = NULL;
    	long size;
    	double scale;
    	unsigned short startindex;
    	unsigned short index;
    	short type;
    	bool isUnsigned;
    	bool bSpezialArray;
    	char* pTrenner = NULL;
    	char* pOutput_Default = NULL;
    	char* pFilterstring1 = NULL;
    	char* pFilterstring2 = NULL;
    	char* pfad = NULL;
    
    	while(parser.hasMoreTokens()) {
    		//TRACE("DataPosition: %d \n",m_DataPos);
    
    		pToken = parser.getNext();
    
    		// is it a group
    		if( !stricmp(pToken, GROUP) ) 
    		{
    			CString strGroupName = parser.getNext();	//Gruppenname der aktuellen Gruppe
    			CString strIsNewGroup = parser.getNext(); //Gruppenname, zu der die aktuelle Gruppe hinzugefügt werden soll
    			//int lenMainGroup = strMainGroupName.GetLength();
    			strIsNewGroup.MakeLower();
    			if (strIsNewGroup == "first")
    			{
    				pGroup = new CGroup( _strdup(strGroupName) );
    				try 
    				{
    					m_oaGroups.Add(pGroup);
    				}
    				// Did we run into a memory exception
    				catch (CMemoryException* perr) 
    				{
    					//Display a message for the user, giving him or her the bad news
    					AfxMessageBox("Out of memory while adding group", MB_ICONSTOP | MB_OK);
    					//Did we create an Element object?
    					if (pGroup) 
    					{
    						// Delete it
    						delete pGroup;
    						pGroup = NULL;
    					}
    					// Delete the exception object
    					perr->Delete();
    				}
    			}
    			else if (strIsNewGroup == "continue")
    			{
    				pGroup = NULL;
    				for (int p = 0; p < m_oaGroups.GetSize(); p++)
    				{
    					if (strcmp ( ((CGroup*)m_oaGroups[p])->getName(),strGroupName) == 0)
    					{
    						pGroup = (CGroup*)m_oaGroups[p];
    						break;	
    					}
    				}
    
    				if (pGroup == NULL)
    				{
    					AfxMessageBox("Gruppenname für Maingroup ist nicht Name einer bisher definierten Gruppe", MB_ICONSTOP | MB_OK);	
    					deleteData();
    					throw "Fehler";
    				}
    			}
    			else
    			{
    				AfxMessageBox("Unbekannter Wert für Parameter 2 bei Schlüsselwort <group>", MB_ICONSTOP | MB_OK);	
    				deleteData();
    				throw "Fehler";
    
    			}
    		}
    
    		bSpezialArray = !stricmp(pToken, ARRAY_SPEZIAL);
    		// is it a array
    		if( !stricmp(pToken, ARRAY) || bSpezialArray  ) 
    		{
    			if (pGroup == NULL)
    			{
    				AfxMessageBox("Schlüsselwort <array> / <arraySp> vor Schlüsselwort <group> gefunden", MB_ICONSTOP | MB_OK);	
    				deleteData();
    				throw "Fehler";
    			}
    			//Array Token: Size
    			size = atol(parser.getNext());
    
    			// Array Token: Typ
    			pToken=parser.getNext();
    			if ( !stricmp( "b", pToken) ) {
    				type = 1;
    				isUnsigned = false;
    			} else if ( !stricmp("w", pToken) ) {
    				type = 2;
    				isUnsigned = false;
    			} else if ( !stricmp("ub", pToken) ) {
    				type = 1;
    				isUnsigned = true;
    			} else if ( !stricmp("uw", pToken) ) {
    				type = 2;
    				isUnsigned = true;
    			} else {
    				AfxMessageBox("Error in config file: array-type not recognized", MB_ICONSTOP | MB_OK);
    			}
    
    			// Array Token: Name
    			pName = _strdup(parser.getNext());
    
    			// Array Token: StartIndex
    			startindex = atoi(parser.getNext());
    
    			// Array Token: Content
    			pContent = _strdup(parser.getNext());
    
    			// Array Token: Scale
    			scale = atof(parser.getNext());
    
    			// Array Token: Unit
    			pUnit = _strdup(parser.getNext());
    
    			// add array to current group
    			CElement* pElement = pGroup->addArray(this, m_DataPos, size, type, isUnsigned, pName, startindex, pContent, scale, pUnit);
    			if (bSpezialArray)
    			{
    				//Spezialgruppe
    				//Setzte VersionElementzeiger
    				pToken=parser.getNext();
    
    				if (size != 1)
    				{
    					AfxMessageBox("Error in config file: special array only allowed for size = 1", MB_ICONSTOP | MB_OK);
    				}
    				else if (!stricmp( "Version", pToken))
    				{
    					m_VersionElements.pVersion = pElement;
    				}
    				else if (!stricmp( "Day", pToken))
    				{
    					m_VersionElements.pDay = pElement;
    				}
    				else if (!stricmp( "Month", pToken))
    				{
    					m_VersionElements.pMonth = pElement;
    				}
    				else if (!stricmp( "Year", pToken))
    				{
    					m_VersionElements.pYear = pElement;
    				}
    				else 
    				{
    					AfxMessageBox("Error in config file: special array-type not recognized", MB_ICONSTOP | MB_OK);
    				}
    			}
    		}
    
    		// is it a filearray 
    
    		if ( !stricmp(pToken, FILEARRAY)) {
    
    			if (pGroup == NULL)
    			{
    				AfxMessageBox("Schlüsselwort <filearray> / <list> vor Schlüsselwort <group> gefunden", MB_ICONSTOP | MB_OK);	
    				deleteData();
    				throw "Fehler";
    			}
    
    		    //Filearray Token: Size
    			size = atol(parser.getNext());
    
    			// Filearray Token: Typ
    			pToken=parser.getNext();
    			if ( !stricmp( "b", pToken) ) {
    				type = 1;
    				isUnsigned = false;
    			} else if ( !stricmp("w", pToken) ) {
    				type = 2;
    				isUnsigned = false;
    			} else if ( !stricmp("ub", pToken) ) {
    				type = 1;
    				isUnsigned = true;
    			} else if ( !stricmp("uw", pToken) ) {
    				type = 2;
    				isUnsigned = true;
    			} else {
    				AfxMessageBox("Error in config file: array-type not recognized", MB_ICONSTOP | MB_OK);
    			} 
    
    			// Filearray Token: Name
    			pName = _strdup(parser.getNext());
    
    			// Filearray Token: StartIndex
    			startindex = atoi(parser.getNext());
    
    			// Filearray Token: Content
    			pContent = _strdup(parser.getNext());
    
    			// Filearray Token: Scale
    			scale = atof(parser.getNext());
    
    			// Filearray Token: Unit
    			pUnit = _strdup(parser.getNext());
    
    			// Filearray Token: Openfile
    		    pInfoFile = _strdup(parser.getNext());
    
    			// Filearray Token: Trennzeichen
    			pTrenner = _strdup(parser.getNext());
    
    			// Filearray Token: Defaultausgabewert
    			pOutput_Default = _strdup(parser.getNext());
    
    			// Filearray Token: Filter -> Suchstring
    			pFilterstring1 = _strdup(parser.getNext());
    
    			// Filearray Token: Filter -> Ersetzstring
    			pFilterstring2 = _strdup(parser.getNext());
    
    			// add filearray to current group
    			CElement* pElement = pGroup->addFilearray(this, m_DataPos, size, type, isUnsigned, pName, startindex, pContent, scale, pUnit, pInfoFile, pTrenner, pOutput_Default, pFilterstring1, pFilterstring2);
    
    		}
    
    		// is it a list
    		if (!strncmp(pToken, LIST,4)){  
    			if (pGroup == NULL)
    			{
    				AfxMessageBox("Schlüsselwort <list> vor Schlüsselwort <group> gefunden", MB_ICONSTOP | MB_OK);	
    				deleteData();
    				throw "Fehler";
    			}
    
    			pfad = _strdup(m_strDataPath + pToken);
    			loespfad.eintragen(pfad, w);
    			m_strDataPath + pToken;
    			w ++;
    			ofstream out;
    			out.open(m_strDataPath + pToken, ios::out);
    			pToken = parser.getNext();
    			while (strcmp(pToken,"end")){  
    			  index = atoi(pToken);
    			  int y = strlen(pToken);
    			  pName = _strdup(parser.getNext());
    			  if(y == 1)
    				  out << "00" ;
    			  if(y == 2)
    				  out << "0" ;
    			  out << index ; 
    			  out << " " ;
    			  out << pName ;
    			  out << ";" << endl;
    			  pToken = parser.getNext();
    			  pToken = parser.getNext();
    			}
    			  out.close(); 		
    		}
    
    		// is it a subarray
    		if ( !stricmp(pToken, SUBARRAY) ) {
    			if (pGroup == NULL)
    			{
    				AfxMessageBox("Schlüsselwort <subarray> vor Schlüsselwort <group> gefunden", MB_ICONSTOP | MB_OK);	
    				deleteData();
    				throw "Fehler";
    			}
    
    			// SubArray Token: Index
    			index = (unsigned short) atol(parser.getNext());
    
    			// SubArray Token: Name
    			pName = _strdup(parser.getNext());
    
    			// SubArray Token: Content
    			pContent = _strdup(parser.getNext());
    
    			// SubArray Token: Scale
    			scale = atof(parser.getNext());
    
    			// SubArray Token: Unit
    			pUnit = _strdup(parser.getNext());
    
    			// add subarray to current group
    			pGroup->addSubArray(index, pName, pContent, scale, pUnit);
    		}		
    	}
    	copyItemsToList();
    }
    
    /**
     * Methode copyItemsToList()
     * gibt die Elment an die Klasse ListOperation
     * 
     * Parameter:  void
     * Returnwert: void
     *
     */
    
    int position=0;
    void CData::copyItemsToList()
    {
    	MessageBox(NULL,NULL,"Hallo",MB_OK);
    	ListOperation L;
    	CString CopyItem;
    	CElement *element;
    
    	int groupcounter, elementcounter;
    	for(groupcounter   = 0; groupcounter < m_oaGroups.GetSize(); ++groupcounter) 
    	{
    		for (elementcounter = 0; elementcounter < ((CGroup*)m_oaGroups[groupcounter])->getSize(); ++elementcounter) 
    		{
    			position++;
    
    			element = (CElement*) ((CGroup*)m_oaGroups[groupcounter])->getElement(elementcounter);
    			CopyItem=element->getName();
    			L.AddItemToList(CopyItem, position);	
    
    		}
    	}
    
    }
    
    /**
     * Methode getChecksum()
     * liefert die aktuelle Checksum des Datensatzes zurück 
     *
     * Parameter:  void
     * Returnwert: unsigned short
     *
     */
    unsigned short CData::getChecksum()
    {
    
    	unsigned short checksum = 0;
    
    	checksum = (unsigned char)m_pData[CHECKSUMPOS + 1];
    	checksum = checksum << 8;
    	checksum |= (unsigned char)m_pData[CHECKSUMPOS];
    
    	TRACE("Lese Checksum an Position %d: %d \n",CHECKSUMPOS,checksum);
    
    	return checksum;
    }
    
    /**
     * Methode setChecksum()
     * berechnet die Checksum und trägt sie in den Datensatz ein
     *
     * Parameter:  void
     * Returnwert: void
     *
     */
    void CData::setChecksum()
    {
    
    	char sz[3];
    	unsigned short hexNum = 0;
    	unsigned short checksum = 0;
    
    	//Berechne Checksum
    	for( int i=0; i<SIZEPEDDATA; i+=2) {
    		sz[0] = m_pData[i + 1];
    		sz[1] = m_pData[i];
    		sz[2] = '\0';
    		sscanf(sz,"%02X",&hexNum);
    		checksum += hexNum;
    	}
    
    	TRACE("Berechnete Checksum: %d \n",checksum);
    	TRACE("Trage Checksum in den Datensatz ein \n");
    
    	//Trage Checksum in den Datensatz ein
    	m_pData[CHECKSUMPOS + 1] = (unsigned char) (checksum >> 8);
    	m_pData[CHECKSUMPOS]   = (unsigned char) checksum;
    	TRACE("Checksum in Dez: %d %d\n",(unsigned char)m_pData[CHECKSUMPOS],(unsigned char)m_pData[CHECKSUMPOS+1]);
    	TRACE("Checksum in Hex: %02X %02X\n",(unsigned char)m_pData[CHECKSUMPOS],(unsigned char)m_pData[CHECKSUMPOS+1]);
    
    	//Trage "gültig" in den Datensatz ein
    	TRACE("Setze Datensatz auf gültig \n");
    	m_pData[CHECKSUMPOS+2] = (char)129; //ascii ü
    	m_pData[CHECKSUMPOS+3] = 'g';
    	m_pData[CHECKSUMPOS+4] = 't';
    	m_pData[CHECKSUMPOS+5] = 'l';
    	m_pData[CHECKSUMPOS+6] = 'g';
    	m_pData[CHECKSUMPOS+7] = 'i';
    	m_pData[CHECKSUMPOS+8] = ' ';
    	m_pData[CHECKSUMPOS+9] = ' ';
    }
    
    /**
     * Methode getDataBezeichner(char *pBezString)
     * schreibt den DatenBezeichner (von File2) in das übergebene Characterfeld
     *
     * Parameter:  void
     * Returnwert: CString
     *
     */
    
    CString CData::getDataBezeichner()
    {
    
    	CString str;
    	char* pStr = str.GetBuffer (SIZEBEZEICHNER+1);
    	for(int i=0; i<SIZEBEZEICHNER; i+=2) {
    		pStr[i] = m_pData[POSBEZEICHNER+i+1];
    		pStr[i+1] = m_pData[POSBEZEICHNER+i];
    	}
    	pStr[SIZEBEZEICHNER] = 0;
    	str.ReleaseBuffer();
    	return str;
    }
    
    CString CData::getDataBezeichnerVersion()
    {
    	//----------------------------------------------------------------
    	// Liefert den Versionsteil des Datensatzbezeichners
    	//----------------------------------------------------------------
    
    	return getDataBezeichner()
    
    		.Mid (DataBezeichner_PosVersion,DataBezeichner_LenVersion);
    }
    
    CString CData::getDataBezeichnerDate()
    {
    	//----------------------------------------------------------------
    	// Liefert den Datumsteil des Datensatzbezeichners
    	//----------------------------------------------------------------
    	return getDataBezeichner()
    		.Mid (DataBezeichner_PosDate,DataBezeichner_LenDate);
    }
    
    CString CData::getDataBezeichnerStoreTable()
    {
    	//----------------------------------------------------------------
    	// Liefert den StoreTable - Teil des Datensatzbezeichners
    	//----------------------------------------------------------------
    	return getDataBezeichner()
    		.Mid (DataBezeichner_PosStoreTab,DataBezeichner_LenStoreTab);
    }
    
    /**
     * Methode setDataBezeichner(char *pBezString)
     * trägt den übergebenen Bezeichner in den Datensatz ein
     *
     * Parameter:  char *pBezString
     * Returnwert: void
     *
     */
    void CData::setDataBezeichner(const char *pBezString)
    {
    	//String mit Leerzeichen auf Bezichnerlänge auffüllen
    	char strTmp[POSBEZEICHNER+1];
    	memset (strTmp,' ',POSBEZEICHNER);
    	strTmp[POSBEZEICHNER] = 0;
    	strncpy (strTmp,pBezString,strlen(pBezString));
    
    	for(int i=0; i<SIZEBEZEICHNER; i+=2) 
    	{
    		m_pData[POSBEZEICHNER+i] = strTmp[i+1];
    		m_pData[POSBEZEICHNER+i+1] = strTmp[i];
    	}
    	m_bChanged = true;
    	setChecksum();
    	if (m_pPerEvData)
    		m_pPerEvData->SetDataBezeichner (m_pData + POSBEZEICHNER);
    }
    
    void CData::updateDataBezeichner(const char *strVersion, const CTime *pDatum, const char *strStoreTable)
    {
    	//----------------------------------------------------------------
    	// Setzen des neuen Datensatzbezeichners mit den angegebenen Daten
    	// Wenn NULL angegeben wird, wird der alte Wert verwendet
    	// Führt auch ein Update der Parameter im LFZ-Kenner durch
    	//----------------------------------------------------------------
    
    	CString strTmpVersion,strTmpDatum,strTmpStoreTable;
    	if (strVersion)
    	{
    		double ver = atof (strVersion);
    		strTmpVersion.Format ("%3.1f",ver);
    		strTmpVersion = strTmpVersion.Right (DataBezeichner_LenVersion);
    		if (m_VersionElements.pVersion)
    		{
    			ver *= m_VersionElements.pVersion->getScale();
    			short v = (short) ver;
    			m_VersionElements.pVersion->setValue (v);
    		}
    	}
    	else
    	{
    		strTmpVersion = getDataBezeichnerVersion().Left (DataBezeichner_LenVersion);
    	}
    
    	if (pDatum)
    	{
    		if (m_VersionElements.pDay && m_VersionElements.pMonth && m_VersionElements.pYear)
    		{
    			short tmp  = (short) (pDatum->GetDay() * m_VersionElements.pDay->getScale());
    			m_VersionElements.pDay->setValue (tmp);
    
    			tmp  = (short) (pDatum->GetMonth() * m_VersionElements.pMonth->getScale());
    			m_VersionElements.pMonth->setValue (tmp);
    
    			tmp  =(short) (((int) (pDatum->GetYear() * m_VersionElements.pYear->getScale())) % 100);
    			m_VersionElements.pYear->setValue (tmp);
    
    		}
    
    		strTmpDatum = pDatum->Format("%d.%m.%Y");
    	}
    	else
    	{
    		strTmpDatum = getDataBezeichnerDate();
    	}
    	strTmpStoreTable = (strStoreTable != NULL) ? strStoreTable : getDataBezeichnerStoreTable();
    
    	strTmpDatum      = strTmpDatum     .Left (DataBezeichner_LenDate);
    	strTmpStoreTable = strTmpStoreTable.Left (DataBezeichner_LenStoreTab);
    
    	CString str;
    	str.Format (DataBezeichner_Format,strTmpVersion,strTmpStoreTable,strTmpDatum);
    	setDataBezeichner (str);
    }
    
    /**
     * Methode getKonstBezeichner(char *pBezString)
     * schreibt den KonstantenBezeichner in das übergebene Characterfeld
     *
     * Parameter:  void
     * Returnwert: CString
     *
     */
    CString CData::getKonstBezeichner()
    {
    	CString str;
    	char* pStr = str.GetBuffer (SIZEBEZEICHNER+1);
    
    	for(int i=0; i<SIZEBEZEICHNER; i+=2) 
    	{
    		pStr[i] = m_pData[POSKONSTBEZ+i+1];
    		pStr[i+1] = m_pData[POSKONSTBEZ+i];
    	}
    
    	pStr[SIZEBEZEICHNER] = 0;
    	str.ReleaseBuffer();
    	return str;
    
    }
    
    /**
     * Methode setKonstBezeichner(char *pBezString)
     * trägt den übergebenen Bezeichner in den Datensatz ein
     *
     * Parameter:  char *pBezString
     * Returnwert: void
     *
     */
    void CData::setKonstBezeichner(const char *pBezString)
    {
    	//String mit Leerzeichen auf Bezichnerlänge auffüllen
    	char strTmp[POSBEZEICHNER+1];
    	memset (strTmp,' ',POSBEZEICHNER);
    	strTmp[POSBEZEICHNER] = 0;
    	strncpy (strTmp,pBezString,strlen(pBezString));
    
    	for(int i=0; i<SIZEBEZEICHNER; i+=2) 
    	{
    		m_pData[POSKONSTBEZ+i] = strTmp[i+1];
    		m_pData[POSKONSTBEZ+i+1] = strTmp[i];
    	}
    	m_bChanged = true;
    	setChecksum();
    }
    
    /**
     * Methode updateHeaderFile(char *headerFileName)
     * aktualisiert das Header-File um den geänderten KonstantenBezeichner
     *
     * Parameter:  CHeaderFileEntry* pEntry
     * Returnwert: void
     *
     */
    void CData::updateHeaderEntry(HeaderFileEntry* pEntry,bool bUpdateDate)
    {
    	int i;
    	int pos = PosInInfostring; //PED steht immer ab Offset 7
    	CString strInfo = pEntry->strInfozeile.GetString();
    	char* str = strInfo.GetBuffer (pos + SIZEBEZEICHNER);
    
    	//Der Bezeichner wird nun aktualisiert
    	for (i=0;i<SIZEBEZEICHNER;i+=2) 
    	{
    		str[pos+i] = m_pData[POSBEZEICHNER+i+1];
    		str[pos+i+1] = m_pData[POSBEZEICHNER+i];
    	}
    	str [pos+i] = 0;
    	strInfo.ReleaseBuffer();
    
    	pEntry->strInfozeile.SetString (strInfo);
    
    	if (bUpdateDate)
    	{
    		CTime time = CTime::GetCurrentTime();
    
    		//Datum Updaten
    		pEntry->strDatum.SetString (time.Format ("%d.%m.%Y"));
    		pEntry->strZeit.SetString(time.Format("%H:%M:%S"));
    	}
    }
    
    /****************************************************************************************************************************/
    /****************************************************************************************************************************/
    
    /****************************************************************************************************************************/
    /****************************************************************************************************************************/
    
    void CData::kopierInDatei()
    {
    	int i=0;
    	CString Ueberschrift;
    	FILE* datei;
    	datei = fopen("Test.txt","w+");
    	CElement *element;
    	CString str;
    	int groupcounter   = 0;
    	int elementcounter = 0;
    	for(groupcounter   = 0; groupcounter < m_oaGroups.GetSize(); ++groupcounter) 
    	{
    		fprintf(datei,"\n\n");
    		Ueberschrift= "Adr.";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,6-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Org";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,6-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Feldname";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,25-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Index";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,6-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Beschreibung";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,40-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Skal";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,7-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Dezimal";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,8-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Physik";
    		fprintf(datei,Ueberschrift);
    		fseek(datei,10-strlen(Ueberschrift),SEEK_CUR);
    
    		Ueberschrift= "Einheit";
    		fprintf(datei,Ueberschrift);
    		fprintf(datei,"\n\n");
    		for (elementcounter = 0; elementcounter < ((CGroup*)m_oaGroups[groupcounter])->getSize(); ++elementcounter) 
    		{
    			element = (CElement*) ((CGroup*)m_oaGroups[groupcounter])->getElement(elementcounter);
    
    			str = element->getDataAdress();
    			fprintf(datei,str);
    			fseek(datei,6-strlen(str),SEEK_CUR);
    
    			str = _T( (element->getType()==2)?'W':'B' );
    			fprintf(datei,str);
    			fseek(datei,6-strlen(str),SEEK_CUR);		
    
    			str = element->getName();		
    			fprintf(datei,str);
    			fseek(datei,25-strlen(str),SEEK_CUR);
    
    			str.Format("%.4d",element->getIndex());
    			fprintf(datei,str);
    			fseek(datei,6-strlen(str),SEEK_CUR);
    
    			str =  element->getContent();
    			fprintf(datei,str);
    			fseek(datei,40-strlen(str),SEEK_CUR);			
    
    			str.Format("%4.1f",element->getScale());
    			fprintf(datei,str);
    			fseek(datei,7-strlen(str),SEEK_CUR);   	
    
    			str.Format("%d",element->getValue());
    			fprintf(datei,str);
    			fseek(datei,8-strlen(str),SEEK_CUR);
    
    			str.Format("%5.2f",element->getValue()/element->getScale());
    			fprintf(datei,str);
    			fseek(datei,10-strlen(str),SEEK_CUR);     		
    
    			str = _T(element->getUnit());
    			fprintf(datei,str);
    			fprintf(datei,"\n\n");
    
    		}
    	}
    	fclose(datei);
    
    	int FILE_NAME_MAX=200;
    	char acCommand[100] = "start notepad ";
    	char acFilename[200] = "Test.txt";
    
    	strcat(acCommand,"Test.txt");
    
    	system(acCommand);
    
    }
    
    /**
     * Methode drucken
     * startet einen Dialog in welchem der Benutzer einen Drucker auswählen kann
     * und druckt danach den Datensatz auf diesem Drucker aus 
     *
     * Parameter:  CWnd *pWnd
     * Returnwert: void
     *
     */
    
    void CData::drucken(CWnd *pWnd)
    {
    	CString Meldung =  "Daten in eine Textdatei kopieren?\n\nWählen Sie Ok um die Daten im Texteditor zu bearbeiten!\nKlicken Sie auf Abbrechen um zum Druckermenu zu gelangen!";
    	CString FeldName;
    	CString Kurz = "....";
    	int Anzahl=0;
    	int ausWahl;
    	ausWahl = MessageBox(NULL,Meldung,"Abfrage",MB_OKCANCEL | MB_ICONQUESTION);
    
    	if(ausWahl==IDOK)
    	{
    		kopierInDatei();	
    	}
    	else
    	{
    
    	CPrintDialog dlgPrint(FALSE,PD_ALLPAGES,pWnd);
    
    	if (dlgPrint.DoModal()==IDOK)
    	{
    		// Den Drucker-DC vom Dialogfeld mit einem
    		// CDC-Objekt verbinden
    		CDC dcPrint;
    		dcPrint.Attach(dlgPrint.GetPrinterDC());
    
    		// Eine DOCINFO-Struktur erzeugen und füllen
    		DOCINFO myPrintJob;
    		myPrintJob.cbSize = sizeof(myPrintJob);
    		myPrintJob.lpszDocName = "Permanent Event Daten";
    		myPrintJob.lpszOutput = NULL;
    		myPrintJob.lpszDatatype = NULL;
    		myPrintJob.fwType = NULL;
    
    		// Ausdruck des Dokuments starten //Evtl Fehler durch zu wenig Speicher, defekter Treiber, ...
    		if (dcPrint.StartDoc(&myPrintJob)>=0)
    		{
    			TRACE("[Druck] Start \n");
    
    			// Schrift erzeugen und auswählen
    			CFont fnArial;
    			CFont fnArialbold;
    			CFont fnArialBig;
    			// Font aufbauen aus der LogFont-Struktur
    			//fnArial.CreateFontIndirect ( &fnLogArial ); 
    			fnArial.CreatePointFont(4,"Arial", &dcPrint);
    			fnArialbold.CreatePointFont(6,"Arial",&dcPrint);
    			fnArialBig.CreatePointFont(12,"Arial",&dcPrint);
    
    			CFont* pOldFont=(CFont*)dcPrint.SelectObject(&fnArial);
    
    			// Seitentext erzeugen
    			CString strDocText;
    			strDocText.Format("Seitennummer %d",1);
    
    			int nHeight = 0;
    			CElement *element;
    			CString str;
    			CRect rect(70,0,130,1); // Behälter für den auszudruckenden Text
    			int yPos = SeitenAnfang;
    			int nHeader;
    			int nSeitenzahl = 1;	 //(NF)
    
    			// Eine Seite beginnen
    			dcPrint.StartPage();
    			// GDI-Treiberdaten für Drucker setzen - Textmodus: 1 Einheit = 1 Pixel (Übersetzung log. Koord. ->Gerätekoord.)
    			dcPrint.SetMapMode(MM_ANISOTROPIC);
    			dcPrint.SetWindowExt(PageWidth, PageLength);
    			dcPrint.SetViewportExt(dcPrint.GetDeviceCaps(HORZRES),dcPrint.GetDeviceCaps(VERTRES));
    
    			//Titelseite drucken (NF)
    			CString strTmp;
    			dcPrint.SelectObject(&fnArialBig);
    			yPos = 90;
    			str = "PED - Datensatz";
    
    			dcPrint.SetTextAlign(TA_LEFT);
    
    			yPos += 2* dcPrint.DrawText(str,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_CENTER | DT_SINGLELINE | DT_TOP  );
    
    			dcPrint.SelectObject(&fnArialbold);
    
    			str = "Datensatz:";
    			dcPrint.DrawText(str,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_LEFT | DT_SINGLELINE | DT_TOP  );
    
    			strTmp = this->getDataBezeichner();
    			strTmp.TrimRight();
    			strTmp.TrimLeft();
    			str = strTmp;// + "\n";
    
    			yPos += dcPrint.DrawText(str,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_CENTER | DT_SINGLELINE | DT_TOP  );
    
    			str = "Konstanten:";
    			dcPrint.DrawText(str,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_LEFT | DT_SINGLELINE | DT_TOP  );
    
    			strTmp = this->getKonstBezeichner();
    			strTmp.TrimRight();
    			strTmp.TrimLeft();
    			str = strTmp;// + "\n";
    			yPos += 2* dcPrint.DrawText(str,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_CENTER | DT_SINGLELINE | DT_TOP  );
    
    			//yPos += dcPrint.DrawText(str,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_CENTER);
    
    			dcPrint.SelectObject(&fnArial);
    
    			yPos += dcPrint.DrawText(m_strDataPath,CRect(Rahmen_Links,yPos, PageWidth,SeitenEnde-Rahmen_Rechts),DT_CENTER | DT_SINGLELINE | DT_TOP  );
    
    			nSeitenzahl++;
    
    			dcPrint.EndPage();
    			yPos = SeitenAnfang;
    			dcPrint.StartPage();
    
    			int groupcounter = 0;
    			int elementcounter = 0;
    			for(groupcounter = 0; groupcounter < m_oaGroups.GetSize(); ++groupcounter) {
    				nHeader =20;
    				for (elementcounter = 0; elementcounter < ((CGroup*)m_oaGroups[groupcounter])->getSize(); ++elementcounter) {
    					element = (CElement*) ((CGroup*)m_oaGroups[groupcounter])->getElement(elementcounter);
    
    					str =  element->getContent();
    					rect.SetRect(Pos_Beschreibung,yPos,Pos_Skalierung-10,yPos+1);
    					//Höhe berechnen
    					nHeight = dcPrint.DrawText(str,rect, DT_CALCRECT|DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS); 
    
    					// wenn das Seitenende erreicht wurde
    					if (yPos+nHeader+nHeight+4>SeitenEnde-nHeight) 
    					{
    						//Seitenzahl Drucken (NF)
    
    						str.Format ("-%02i-",nSeitenzahl);
    						nSeitenzahl++;
    						dcPrint.DrawText (str,CRect(0,SeitenEnde-nHeight, PageWidth,SeitenEnde),DT_CENTER| DT_SINGLELINE | DT_BOTTOM);
    
    						dcPrint.EndPage();
    						yPos = SeitenAnfang;
    						dcPrint.StartPage();
    
    						if (nHeader==20) 
    						{
    							yPos+=2;
    							dcPrint.SelectObject(&fnArialbold);
    							dcPrint.TextOut(Pos_Addresse,yPos,((CGroup*)m_oaGroups[groupcounter])->getName() );
    							yPos +=10;
    							nHeader = 0;
    						}
    						else
    							yPos += 3;
    
    						dcPrint.MoveTo (Rahmen_Links			,yPos-2);
    						//dcPrint.LineTo (Rahmen_Links			,yPos+3+nHeight);
    						dcPrint.MoveTo (PageWidth-Rahmen_Rechts	,yPos-2);
    						//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos+3+nHeight);
    						dcPrint.MoveTo (Rahmen_Links			,yPos-2);
    						//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos-2);
    
    						dcPrint.SelectObject(&fnArial);
    						dcPrint.TextOut (Pos_Addresse		,yPos,"Adr.");
    						dcPrint.TextOut (Pos_Org			,yPos,"Org");
    						dcPrint.TextOut (Pos_FeldName		,yPos,"Feldname");
    						dcPrint.TextOut (Pos_Index			,yPos,"Index");
    						dcPrint.TextOut (Pos_Beschreibung	,yPos,"Beschreibung");
    						dcPrint.TextOut (Pos_Skalierung		,yPos,"Skal.");
    						dcPrint.TextOut (Pos_InhaltDez		,yPos,"Inhalt dez.");
    						dcPrint.TextOut (Pos_InhaltPhysik	,yPos,"Inhalt physik.");
    
    						yPos +=8;
    						rect.SetRect(Pos_Beschreibung,yPos,Pos_Skalierung-10,yPos+1);
    						str =  element->getContent();
    						rect.SetRect(Pos_Beschreibung,yPos,Pos_Skalierung-10,yPos+1);
    						nHeight = dcPrint.DrawText(str,rect, DT_CALCRECT|DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS); 
    					}
    
    					if (nHeader==20) 
    					{
    						yPos+=2;
    						dcPrint.SelectObject(&fnArialbold);
    						dcPrint.TextOut(Pos_Addresse,yPos,((CGroup*)m_oaGroups[groupcounter])->getName() );
    						yPos +=10;
    						nHeader = 0;
    
    						dcPrint.MoveTo (Rahmen_Links			,yPos-2);
    						//dcPrint.LineTo (Rahmen_Links			,yPos+3+nHeight);
    						dcPrint.MoveTo (PageWidth-Rahmen_Rechts	,yPos-2);
    						//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos+3+nHeight);
    						dcPrint.MoveTo (Rahmen_Links			,yPos-2);
    						//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos-2);
    
    						dcPrint.SelectObject(&fnArial);
    						dcPrint.TextOut (Pos_Addresse		,yPos,"Adr.");
    						dcPrint.TextOut (Pos_Org			,yPos,"Org");
    						dcPrint.TextOut (Pos_FeldName		,yPos,"Feldname");
    						dcPrint.TextOut (Pos_Index			,yPos,"Index");
    						dcPrint.TextOut (Pos_Beschreibung	,yPos,"Beschreibung");
    						dcPrint.TextOut (Pos_Skalierung		,yPos,"Skal.");
    						dcPrint.TextOut (Pos_InhaltDez		,yPos,"Inhalt dez.");
    						dcPrint.TextOut (Pos_InhaltPhysik	,yPos,"Inhalt physik.");
    
    						yPos +=8;
    						rect.SetRect(Pos_Beschreibung,yPos,Pos_Skalierung-10,yPos+1);
    						str =  element->getContent();
    						rect.SetRect(Pos_Beschreibung,yPos,Pos_Skalierung-10,yPos+1);
    						nHeight = dcPrint.DrawText(str,rect, DT_CALCRECT|DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS); 
    					}
    
    					dcPrint.MoveTo (Rahmen_Links			,yPos-2);
    					//dcPrint.LineTo (Rahmen_Links			,yPos+3+nHeight);
    					dcPrint.MoveTo (PageWidth-Rahmen_Rechts	,yPos-2);
    					//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos+3+nHeight);
    					dcPrint.MoveTo (Rahmen_Links			,yPos+3+nHeight);
    					//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos+3+nHeight);
    					dcPrint.MoveTo (Rahmen_Links			,yPos-2);
    					//dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos-2);
    
    					dcPrint.SetTextAlign(TA_LEFT+TA_TOP);
    					str = element->getName();
    					if(str=="Spare")
    					{
    
    					Anzahl++;
    						if(Anzahl>1)
    						{
    							dcPrint.TextOut(Pos_Addresse,yPos,Kurz);
    						}
    						else
    						{
    							Anzahl=0;
    
    							str = element->getDataAdress();
    							dcPrint.TextOut(Pos_Addresse,yPos,str);
    
    							str = _T( (element->getType()==2)?'W':'B' );
    							dcPrint.TextOut(Pos_Org,yPos,str);
    
    							str = element->getName();
    							dcPrint.TextOut(Pos_FeldName,yPos,str);
    							if(str!=FeldName)
    							{						
    								dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos-2);
    							}
    							FeldName=str;
    
    							str.Format("%.4d",element->getIndex());
    							dcPrint.TextOut(Pos_Index,yPos,str);
    
    							str =  element->getContent();
    							dcPrint.DrawText(str, rect,DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS);
    
    							dcPrint.SetTextAlign(TA_RIGHT+TA_TOP);
    
    							str.Format("%4.1f",element->getScale());
    							dcPrint.TextOut(Pos_Skalierung + Width_Skalierung,yPos,str);
    
    							str.Format("%d",element->getValue());
    							dcPrint.TextOut(Pos_InhaltDez + Width_InhaltDez,yPos,str);
    
    							str.Format("%5.2f",element->getValue()/element->getScale());
    							dcPrint.TextOut(Pos_InhaltPhysik + Width_InhaltPhysik,yPos,str);
    
    							dcPrint.SetTextAlign(TA_LEFT+TA_TOP);
    
    							str = _T(element->getUnit());
    							dcPrint.TextOut(Pos_InhaltPhysik + Width_InhaltPhysik + 1 ,yPos,str);
    
    							str = _T(element->getInfoFile());
    							dcPrint.DrawText(str, rect,DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS);
    
    							yPos +=5+nHeight;
    						}
    					}
    					else
    					{				
    
    					str = element->getDataAdress();
    					dcPrint.TextOut(Pos_Addresse,yPos,str);
    
    					str = _T( (element->getType()==2)?'W':'B' );
    					dcPrint.TextOut(Pos_Org,yPos,str);
    
    					str = element->getName();
    					dcPrint.TextOut(Pos_FeldName,yPos,str);
    					if(str!=FeldName)
    					{						
    						dcPrint.LineTo (PageWidth-Rahmen_Rechts	,yPos-2);
    					}
    					FeldName=str;
    
    					str.Format("%.4d",element->getIndex());
    					dcPrint.TextOut(Pos_Index,yPos,str);
    
    					str =  element->getContent();
    					dcPrint.DrawText(str, rect, DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS);
    
    					dcPrint.SetTextAlign(TA_RIGHT+TA_TOP);
    
    					str.Format("%4.1f",element->getScale());
    					dcPrint.TextOut(Pos_Skalierung + Width_Skalierung,yPos,str);
    
    					str.Format("%d",element->getValue());
    					dcPrint.TextOut(Pos_InhaltDez + Width_InhaltDez,yPos,str);
    
    					str.Format("%5.2f",element->getValue()/element->getScale());
    					dcPrint.TextOut(Pos_InhaltPhysik + Width_InhaltPhysik,yPos,str);
    
    					dcPrint.SetTextAlign(TA_LEFT+TA_TOP);
    
    					str = _T(element->getUnit());
    					dcPrint.TextOut(Pos_InhaltPhysik + Width_InhaltPhysik + 1 ,yPos,str);
    
    					str = _T(element->getInfoFile());
    					dcPrint.DrawText(str, rect, DT_TOP|DT_LEFT|DT_WORDBREAK|DT_NOCLIP|DT_EXPANDTABS);
    
    					yPos +=5+nHeight;
    					}
    				}
    			}
    
    			//Seitenzahl letzte Seite Drucken (NF)
    
    			str.Format ("-%02i-",nSeitenzahl);
    			dcPrint.DrawText (str,CRect(0,SeitenEnde-nHeight, PageWidth,SeitenEnde),DT_CENTER | DT_BOTTOM | DT_SINGLELINE);
    
    			// Seite auswerfen
    			dcPrint.EndPage();
    
    			// Dokument schließen
    			dcPrint.EndDoc();
    			TRACE("[Druck] Ende \n");
    
    			// Alte Zeichenobjekte wiederherstellen
    			dcPrint.SelectObject(pOldFont);
    		}
    		else {
    			AfxMessageBox("Dokument konnte nicht gedruckt werden");
    		}
    		// Druckergerätekontext löschen
    		dcPrint.DeleteDC();
    	}
    	}
    }
    
    int CData::getGroupCount()
    {
    	return m_oaGroups.GetSize ();
    }
    
    /**
     * Konstruktor CData
     * 
     * Parameter:  int groesse
     * Returnwert: void
     *
     */
    CData::CData(int groesse)
    {
      verzeichnis     = new Eintrag[groesse];
      this->groesse   = groesse;
      anzahlEintraege = 0;
    }
    
    //Kopierkonstruktor
    CData::CData(CData & rempfad)
    {
      groesse = rempfad.groesse;
      verzeichnis  = new Eintrag[groesse];
      anzahlEintraege = rempfad.anzahlEintraege;
      for (int i = 0; i < anzahlEintraege; i++)
        verzeichnis[i] = rempfad.verzeichnis[i];  
    }
    
    /**
     * Methode eintragen
     * hinzufügen der Werte
     *
     * Parameter:  CString name, long nummer
     * Returnwert: void
     *
     */
    // Neue Einträge 
    void CData::eintragen(CString name, long nummer) 
    {
    
        verzeichnis[anzahlEintraege].name = name;
    
        verzeichnis[anzahlEintraege].nummer = nummer;
    
        anzahlEintraege++;
    
    }
    
    /**
     * Methode suchen
     * Name zur dazugehörigen Nummer werden gesucht
     *
     * Parameter:  CString & name, long  nummer
     * Returnwert: bool
     *
     */
    //Eintrag suchen
    bool CData::suchen(CString & name, long  nummer) 
    {
    	fstream f;
    	f.open("Gucken.txt",ios::app);
      for (int i = anzahlEintraege-1; i >= 0; i--)
      {
    	  if (verzeichnis[i].nummer == nummer)
        {
          name = verzeichnis[i].name;
    	  f<<name;
          return true;
    	   }
      }
      f.close();
      return false;
    }
    
    //Zuweisung als überladener Operator
    CData & CData::operator= (CData & rempfad)
    {
        anzahlEintraege = rempfad.anzahlEintraege;
        for (int i = 0; i < anzahlEintraege; i++)
        {
          verzeichnis[i] = rempfad.verzeichnis[i];
        }
      return *this;
    }
    
    long & CData::operator[](CString name)
    {
      //Nach dem Namen suchen
      for (int i = 0; i < anzahlEintraege; i++)
      {
        if (verzeichnis[i].name == name)
          return verzeichnis[i].nummer;
      }
      verzeichnis[anzahlEintraege].name   = name;
      verzeichnis[anzahlEintraege].nummer = 0; 
      return verzeichnis[anzahlEintraege ++].nummer;
    }
    


  • Der Defaultkonstruktor von ListOperation (den du in CData::copyItemsToList verwendest) initialisiert die Member nicht.

    Und nebenbei: Ich halte es für eine Frechheit, hier so viel Code abzuladen, der nichts mit dem Problem zu tun hat.



  • Sorry, wenns soviel Code ist, aber du wolltest den Zusammenhang wissen.

    Was leider noch erschwerend dazu kommt ist meine Unwissenheit, die ich wohl damit mal wieder an den Tag gelegt hab.

    Aber danke, denn jetzt funktioniert es.



  • Scalls schrieb:

    Sorry, wenns soviel Code ist, aber du wolltest den Zusammenhang wissen.

    Nein, ich wollte

    MFK schrieb:

    ein vollständiges, kompilierbares Minimalbeispiel, das den Fehler reproduziert.

    Was du hier abgeladen hast, war nicht kompilierbar, und schon gar nicht minimal.

    Aber danke, denn jetzt funktioniert es.

    Das ist die Hauptsache 🙂


Anmelden zum Antworten