4. Speicherfehler?! / Zeiger / malloc / verkettete Listen

Speicherfehler?! / Zeiger / malloc / verkettete Listen

  • A

    Hi,
    geht um folgendes:

    wir sollen ne einfach verkettet liste erstellen und daran so wien kleines message system aufbauen mit lesen erstellen und löschen.
    Habe nun auch schon etwas auf die beine gestellt.
    Mein problem ist, er erstellt die strukturen gibt die Zeiger auf die nächsten Strukturen weiter etc. nur leider passieren komische sporadisch fehler wie das er in ein bereits belegten string warum auch immer irgendwelche dummen dinge schreibt und ich nicht weis warum er auf diese eine Stelle zugreift des weiteren ist das mysteriöse das es ab und zu geht ab und zu wieder nich also muss irgendwas mit der Speicherreservierung etc. schiefgehen
    Vlt hat ja ma jemand die Zeit und hackt das ganze in sein compiler ich weis einfach nicht mehr weiter.
    Das nächste is ja in MS VS06 läuft der code ohne fehler unter netbeans gibbet die Mysteriösen speicherausreißer ^^

    schonma danke im voraus hoffe hab mich al zu dumm angesetllt

    "meine vermutung: er merkt sich einfach nich welche Speicherfelder er nicht überschreiben darf"

    /* 
 * File:   message.h
 */

#ifndef _BELEG_H
#define	_BELEG_H

#ifdef	__cplusplus
extern "C" {
#endif

#ifdef	__cplusplus
}
#endif

#endif	/* _BELEG_H */

/*************************************************************** 
 ************* deklarieren Struktur "message" ******************
 **************************************************************/

 #define maxBody 300
 #define maxAutor 20
 #define maxBetreff 20

 struct message{
    struct content* content;
    struct message* nextAddress;
 };

 struct content{
    char author[maxAutor];
    char body[maxBody];
    char subject[maxBetreff];
 };

    /* 
 * File:   struktur.c
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "message.h"
//#include <conio.h>

/*firstChainMember enthält die erste Adresse der verketteten Liste*/
struct message* firstChainMember=NULL;

/****************************************************************************** 
 * Funktion zur dynamischen message erzeugung *********************************
 * Parameter: keine ***********************************************************
 * Rückgabe: zeiger auf erzeugte strukutr *************************************
 ******************************************************************************/
struct message* createEmptyMessage(){
    struct message* sm_EmptyMessage = (struct message*) malloc(sizeof(struct message*));

    sm_EmptyMessage->content = NULL;
    sm_EmptyMessage->nextAddress = NULL;

    return sm_EmptyMessage;
}

/****************************************************************************** 
 * Funktion zur befüllung einer leeren message Struktur ***********************
 * Paramter: char body[maxBody], char author[maxAutor], char subject[maxBetreff], Zeiger auf struktur *****
 * Rückgabe: keine ************************************************************
 ******************************************************************************/
struct content* fillEmptyContent(char body[maxBody], char author[maxAutor], char subject[maxBetreff]){

    struct content* ptr_filledContent;

    ptr_filledContent = ( struct content* ) malloc ( sizeof ( struct content* ) );

    strcpy(ptr_filledContent->author,author);

    strcpy(ptr_filledContent->body,body);

    strcpy(ptr_filledContent->subject,subject);
        //strcpy(ptr_EmptyMessage->author,author);
	//strcpy(ptr_EmptyMessage->body,body);
	//strcpy(ptr_EmptyMessage->subject,subject);
	//ptr_EmptyMessage->author = author;
        //ptr_EmptyMessage->body = body;
        //ptr_EmptyMessage->subject = subject;
    return ( ptr_filledContent );
}

/****************************************************************************** 
 *Funktion zum erzeugen/befüllen/überprüfen der struktur message **************
 * Paramter: char body[maxBody], char author[maxAutor], char subject[maxBetreff] **************************
 * Rückgabe: keine ************************************************************
 ******************************************************************************/
struct message* createFilledMessage(char body[maxBody], char author[maxAutor], char subject[maxBetreff]){

    struct message* ptr_createEmptyMessage;

    ptr_createEmptyMessage = createEmptyMessage();

    ptr_createEmptyMessage->content = fillEmptyContent ( body , author , subject );

    return ( ptr_createEmptyMessage );
}

/******************************************************************************
 * Funktion zum durchlaufen der kompletten Liste *********************************
 * Parameter: abbruchbedingung z.B. NULL (Ende der Liste) *******************************************
 * Rückegabe: Adresse des gewünschten listenstücks **************************************
 ******************************************************************************/
struct message* walkThrought(){

    struct message* m_LastMessage;

    struct message* m_LastAddress;

    m_LastMessage = firstChainMember;

    m_LastAddress = firstChainMember->nextAddress;

    while(m_LastAddress != NULL){

        m_LastMessage = m_LastAddress;

        m_LastAddress = m_LastMessage->nextAddress;

    }

    return ( m_LastMessage );

}

/******************************************************************************
 * Funktion zum erstellen eines Listenstücks *********************************
 * Parameter: char author[maxAutor], char body[maxBody], char subject[maxBetreff] *******************************************
 * Rückegabe: Adresse der Listenstruktur **************************************
 ******************************************************************************/
struct message* createChainMember(char author[maxAutor],char subject[maxBetreff],char body[maxBody]){

    struct message* newChainMember;

    struct message* m_LastMessage;

    newChainMember = createFilledMessage(body,author,subject);

    if(firstChainMember!=NULL){

        m_LastMessage = walkThrought();

        m_LastMessage->nextAddress = newChainMember;

    } else {

        firstChainMember = newChainMember;

    }

}

/******************************************************************************
 * Funktion zum löschen eines Listenstückes *********************************
 * Parameter: Adresse des listenstücks *******************************************
 * Rückegabe: keine **************************************
 ******************************************************************************/
void deleteChainMember(int i){

}

/******************************************************************************
 * Funktion zum auslesen eines Listenstückes *********************************
 * Parameter: Adresse des Listenstücks *******************************************
 * Rückegabe: Autor, Betreff, Text, adresse vom nächsten Stück **************
 ******************************************************************************/
void* readChainMember(struct message* m_chainMember){
    return(m_chainMember->nextAddress);
}

int main() {

    int iOption=1;

    while(iOption==1||iOption==2||iOption==3){

    /**************************************************************************
	 * Ausgabe des Benutzermenues *********************************************
	 **************************************************************************/

        printf("Willkommen beim AMessenger 2000.\n\nSie haben hier die Moeglichkeit "
               "Nachrichten zu schreiben diese zu Speichern und zu loeschen.\n\n"

			   "Sie haben nun folgenden Optionen:\n\n"
               "1: Nachrichten anzeigen\n"
               "2: Nachrichte ertsellen\n"
               "3: Nachrichten loeschen\n"
               "4: Beenden\n\n"
               "Bitte geben Sie nun die Zahl ihrer gewuenschten Aktion an: ");

        scanf("%i",&iOption);

		/**************************************************************************
		 * wird ausgeführt wenn "Nachricht anzeigen" gewählt wurde ****************
		 **************************************************************************/
        if(iOption==1){

			struct message* m_nextMessage;
			int i_MessageNr=1;
			int i_selectMessageNr=0;

			system("cls"); //Fenster leeren

			if(firstChainMember!=NULL){

				printf("Nr.:\tAutor:\t\tBetreff:\n");

				m_nextMessage = firstChainMember->nextAddress;

				//printf("%i\t%s\t\t%s\n",i_MessageNr,firstChainMember->author,firstChainMember->subject);

				while(m_nextMessage!=NULL){

					i_MessageNr++;
					//printf("%i\t%s\t\t%s\n",i_MessageNr,m_nextMessage->author,m_nextMessage->subject);
					m_nextMessage = m_nextMessage->nextAddress;	

				}

				printf("\n\nBitte geben Sie die Nachrichtennummer ein welche ausgegeben werden soll:");
				scanf("%i",&i_selectMessageNr);

			}

			system("cls"); //Fenster leeren

        }

		/**************************************************************************
		 * wird ausgeführt wenn "Nachricht erstellen" gewählt wurde ****************
		 **************************************************************************/
        if(iOption==2){
            char sAuthor[maxAutor] = "Test Test";
            char sSubject[maxBetreff] = "Test Nachricht";
            char sBody[maxBody] = "Hierbei handelt es sich um eine Testnachricht.";

			system("cls"); //Fenster leeren

            printf("Sie moechten eien neue Nachricht erstellen.\n");
            printf("Bitte geben Sie nun ein:\n\n");
            printf("Autor:");
			//scanf("%s",&sAuthor);
            //sAuthor="Test";
            printf("Betreff:");
			//scanf("%s",&sSubject);
            //sSubject="Test eMail";
            printf("Body:");
			//scanf("%s",sBody);
            //sBody="text testxt tadaskjd safhafhdshf kjdshfdshf hskfhsdgf";

            createChainMember(sAuthor,sSubject,sBody);

			system("cls"); //Fenster leeren
        }

		/**************************************************************************
		 * wird ausgeführt wenn "Nachricht löschen" gewählt wurde ****************
		 **************************************************************************/
        if(iOption==3){
            system("cls"); //Fenster leeren

        }
    }
    return (EXIT_SUCCESS);
}
    0
  • L

    Was mir spontan auffällt: Du hast bei den mallocs als Größe grundsätzlich die Größe des Zeigers (sizeof(struct xyz*)) angegeben. Sinnvoll wäre hingegen die Größe der Struktur (sizeof(struct xyz)). Ein Zeiger ist immer nur vier Bytes groß, da ist kein Wunder dass Du Dir den Speicher zerschießt.

    0
  • A

    großes fettes danke ich wuste das is nur irgend ne kleinigkeit ^^ echt cool

    0
Anmelden zum Antworten