Hinzufügen eines weiteren Elements



  • Hallo,

    ich habe eine Funktion zum Einfügen von Elementen und zum Anzeigen. Nun benötige ich noch eine Funktion mit der ich ein weiteres Element zu den bereits bekannten hinzufügen kann mit einer id soll diese Gruppe ausgewählt werden.
    Nun weiß ich leider nicht wie man das Element dann genau zu der Gruppe hinzufügt und wie die Ausgabe dann aussehen soll,da ja ein weiteres Element nun dazugekommen ist.

    int einfuegen(array *dh, int id, char *q,char *r,char *s,char *t)
    {
    	if (dh->n_elements == 0) //noch ohne Elemente 
    	{
    		dh->array_ptr = (bestellung*)malloc(sizeof(bestellung)* N_START); //Speicherreservierung
    		if (dh->array_ptr == NULL) { return 0; } //Fehler bei Speicheralloziierung
    		dh->n_allocated = N_START;  // allokierte Elemente =3
    	}
    
    	if (dh->n_elements + 1> dh->n_allocated) // ist Anzahl der Elemente+1 größer als die allokierten
    	{
    		dh->array_ptr = (bestellung*)realloc(dh->array_ptr, sizeof(bestellung) * (dh->n_allocated + N_DELTA)); //Neuallokierung
    		if (dh->array_ptr == NULL) { return 0; }  //Fehler bei Speicheralloziierung
    		dh->n_allocated = dh->n_allocated + N_DELTA; //Anzahl der allokierten ist nun allokierte +2
    	}
    	dh->array_ptr[dh->n_elements].id = id;
    	strcpy(dh->array_ptr[dh->n_elements].q, q);
    	strcpy(dh->array_ptr[dh->n_elements].r, r);
    	strcpy(dh->array_ptr[dh->n_elements].s, s);
    	strcpy(dh->array_ptr[dh->n_elements].t, t);
    	dh->n_elements = dh->n_elements + 1;
    
    	return 1;
    }
    
    void anzeigen(array dh)
    {
    	int i;	
    for (i = 0; i < dh.n_elements; i++) 
    	printf("ID: %d \t q %s \t r %s \t s %s \t t %s \t\n", dh.array_ptr[i].id, dh.array_ptr[i].q, dh.array_ptr[i].r, dh.array_ptr[i].s, dh.array_ptr[i].t);
    


  • du machst dir entweder eine verkettete liste und hängst das element da einfach ran oder du erstellst dir ein array mit nem zeiger auf das erste freie element und fügst das ann einfach da ein.

    bei der liste gibst du dann einfach so lange aus, bis du das ende erreicht hast und bei dem array nimmst du als grenze für die schleife die differenz zwischen erstem element im array und dem zeiger auf das erste freie element.



  • Okay die Sache ist so, ich möchte das ganze über ein Menu steuern.
    Hier der gesamte Quelltext:
    Ich bräuchte eine Funktion hinzufügen, ich dachte das sollte so ähnlich wie bei löschen sein.
    Zudem benötige ich bei der Ausgabe einmal alles mit BESTELLT ohne Zahlungsdatum und dann mit Zahlungsdatum und BEZAHLT. Ich hatte bereits sehr viel herumprobiert aber es klappte nie so richtig.

    #include <stdio.h> 
    #include <string.h> 
    #include <stdlib.h> 
    #include <ctype.h> 
    #include <memory.h> 
    #pragma warning(disable: 4996)
    #define STRLEN 100 
    
    #define N_START 3 
    #define N_DELTA 2 
    
    typedef struct {
    	int bnr;
    	char bd[STRLEN];
    	char anr[STRLEN];
    	char az[STRLEN];
    	char knr[STRLEN];
    	char zdt[STRLEN];
    } bestellung;
    
    typedef struct {
    	bestellung *array_ptr;
    	int n_spezial;
    	int n_elements;
    	int n_allocated;
    } dynarray_handle;
    
    char pruefe_eingabe(char *string)
    {
    	unsigned int i;
    	while (string[0] == ' ') strcpy(string, &string[1]);
    	for (i = 0; i<strlen(string); i++)
    		string[i] = toupper(string[i]);
    	return string[0];
    }
    
    void anzeigen(dynarray_handle dh)
    {
    	int i;
    	int j;
    
    	for (i = 0; i < dh.n_elements; i++) 
    	printf("Bestellnummer: %d \t Bestelldatum:%s \t Kundennummer: %s \t Artikelnummer: %s \t Anzahl: %s  \tBEZAHLT \t Zahlungsdatum: %s\n", dh.array_ptr[i].bnr, dh.array_ptr[i].bd, dh.array_ptr[i].anr, dh.array_ptr[i].az, dh.array_ptr[i].knr, dh.array_ptr[j].zdt);
    	printf("\n");
    	}
    
    int einfuegen(dynarray_handle *dh, int bnr, char *bd,char *anr,char *az,char *knr)
    {
    	if (dh->n_elements == 0) //noch ohne Elemente 
    	{
    		dh->array_ptr = (bestellung*)malloc(sizeof(bestellung)* N_START); //Speicherreservierung
    		if (dh->array_ptr == NULL) { return 0; } //Fehler bei Speicheralloziierung
    		dh->n_allocated = N_START;  // allokierte Elemente =3
    	}
    
    	if (dh->n_elements + 1> dh->n_allocated) // ist Anzahl der Elemente+1 größer als die allokierten
    	{
    		dh->array_ptr = (bestellung*)realloc(dh->array_ptr, sizeof(bestellung) * (dh->n_allocated + N_DELTA)); //Neuallokierung
    		if (dh->array_ptr == NULL) { return 0; }  //Fehler bei Speicheralloziierung
    		dh->n_allocated = dh->n_allocated + N_DELTA; //Anzahl der allokierten ist nun allokierte +2
    	}
    	dh->array_ptr[dh->n_elements].bnr = bnr;
    	strcpy(dh->array_ptr[dh->n_elements].bd, bd);
    	strcpy(dh->array_ptr[dh->n_elements].anr, anr);
    	strcpy(dh->array_ptr[dh->n_elements].az, az);
    	strcpy(dh->array_ptr[dh->n_elements].knr, knr);
    	dh->n_elements = dh->n_elements + 1;
    
    	return 1;
    }
    int hinzufuegen(dynarray_handle *dh, int bnr, char *bd, char*anr, char*az, char*knr, char *zdt) {
    	{
    		int i, p = -1;
    
    		for (i = 0; i < dh->n_elements; i++)
    			if (dh->array_ptr[i].bnr == bnr)
    			{
    				p = i;
    				break;
    			}
    
    		if (p >= 0) 
    		{
    			for (i = p + 1; i < dh->n_elements; i++)
    				dh->array_ptr[i - 1] = dh->array_ptr[i];
    			strcpy(dh->array_ptr[dh->n_spezial].zdt, zdt);
    		}
    		return 1;
    	}
    	return 0;
    }
    
    int loeschen(dynarray_handle *dh, int bnr)
    {
    	int i, p = -1;
    
    	for (i = 0; i<dh->n_elements; i++)
    		if (dh->array_ptr[i].bnr == bnr)
    		{
    			p = i;
    			break;
    		}
    
    	if (p >= 0) 
    	{
    		for (i = p + 1; i<dh->n_elements; i++)
    			dh->array_ptr[i - 1] = dh->array_ptr[i];
    		dh->n_elements = dh->n_elements - 1;
    
    		if (dh->n_elements < dh->n_allocated - N_DELTA)
    		{
    			dh->array_ptr = (bestellung*)realloc(dh->array_ptr, sizeof(bestellung) * (dh->n_allocated -N_DELTA));
    			dh->n_allocated = dh->n_allocated - N_DELTA;
    		}
    		return 1;
    	}
    
    	return 0;
    }
    
    int main()
    {
    	char eingabestring[STRLEN], bd[STRLEN], anr[STRLEN], az[STRLEN], knr[STRLEN], zdt [STRLEN];
    	int a = 0;
    	int auswahl;
    	int bnr, rc;
    	char ende = 0;
    
    	dynarray_handle dh = { NULL,0, 0, 0 }; //(arrayptr,nelemente,nallokierte)
    
    	printf("Demonstration eines dynamischen Arrays\n");
    	do {
    		printf("Funktionsauswahl [E]infuegen [L]oeschen [H]inzufuegen [A]nzeigen [Q]uit :");
    		scanf("%s", eingabestring);
    		auswahl = pruefe_eingabe(eingabestring);
    
    		switch (auswahl)
    		{
    		case 'A': (anzeigen(dh));
    			break;
    		case 'E':
    			printf("Eingabe Bestellnummer:"); scanf("%d", &bnr);
    			printf("Eingabe Bestelldatum:"); scanf("%s", &bd);
    			printf("Eingabe Artikelnummer:"); scanf("%s", &anr);
    			printf("Eingabe Anzahl:"); scanf("%s", &az);
    			printf("Eingabe Kundennummer:"); scanf("%s", &knr);
    			rc = einfuegen(&dh, bnr, bd,anr,az,knr);
    			if (rc == 1)
    				printf("Neues Element uebernommen: Elemente: %d genutzt, %d allokiert \n", dh.n_elements, dh.
    					n_allocated);
    			else
    				printf("Fehler bein Einfuegen: Elemente: %d genutzt, %d allokiert \n", dh.n_elements, dh.n_allocated);
    			break;
    		case 'H':printf("Eingabe Bestellnummer:"); scanf("%d", &bnr);
    			printf("Eingabe Zahlungsdatum:"); scanf("%s", &zdt);
    			rc = hinzufuegen(&dh, bnr,bd,knr,anr,az,zdt);
    			if (rc == 1) {
    				printf("Zahlungsdatum hinzugefuegt\n");
    			}
    			else
    				printf("Zahlungsdatum konnte nicht hinzugefuegt werden\n");
    			break;
    		case 'L': printf("Eingabe Bestellnummer:"); scanf("%d", &bnr);
    			rc = loeschen(&dh, bnr);
    			if (rc == 1)
    				printf("Element geloescht: Elemente: %d genutzt, %d allokiert \n", dh.n_elements, dh.n_allocated);
    			else
    				printf("Element wurde nicht gefunden\n");
    			break;
    		case 'Q': ende = 1; break;
    		}
    
    	} while (!ende);
    	printf("\nEnde\n");
    	getchar();
    	getchar();
    }
    


  • Das sieht doch schon gut aus.
    Definiere mal deinen Fehler konkret.
    - hinzufuegen und einfuegen sollten den Namen tauschen
    - Zeile 55-60 entfernen
    - keine malloc Casts
    - loeschen funktioniert so nicht, besser ohne realloc und manuelles Verschieben
    - praktischer ist "* N_DELTA" statt "+ N_DELTA"
    - pruefe_eingabe ist umständlich und überflüssig
    - String-Eingaben prüfen die max. Länge und evtl vorh. Whitespaces nicht
    - ...



  • Ich würde gern zusätzlich zu BN,KNR usw. mit einer Option HINZUFÜGEN noch das Zahlungsdatum einbinden, allerdings weiß nicht wie ich das machen soll.

    Es soll so ablaufen:

    Man drückt E gibt ein und dann drückt man H und fügt hinzu.
    Nun muss ich allerdings auch bei Anzeigen etwas ändern weil ursprünglich das Zahlungsdatum fehlt.Wenn das Zahlungsdatum eingegeben wurde soll statt BESTELLT nun BEZAHLT stehen.

    So würde ich es mir vorstellen:

    BNR,BDT,ANR,AZ,KNR BESTELLT (beim einfügen mit e)
    BNR,BDT,ANR,AZ,KNR BEZAHLT Zahlungsdatum (nach dem hinzufügen des Zahlungsdatums)



  • wie wäre es damit, das zahlungsdatum standardmäßig einfach auf 0 zu setzenund dann abzufragen, ob es 0 ist? Wenn ja, dann noch nicht bezahlt und sonst eben bezahlt. Ganz einfache Geschichte mit if-Else.



  • Das wird nicht gehen man muss es irgendwie an einer for-Schleife festmachen mit n_elements.



  • HansKlaus schrieb:

    wie wäre es damit, das zahlungsdatum standardmäßig einfach auf 0 zu setzenund dann abzufragen, ob es 0 ist? Wenn ja, dann noch nicht bezahlt und sonst eben bezahlt. Ganz einfache Geschichte mit if-Else.

    Das war auch mein erster Gedanke.

    Detlef7able schrieb:

    Das wird nicht gehen man muss es irgendwie an einer for-Schleife festmachen mit n_elements.

    Welches Problem siehst du dabei?



  • also wenn du eine Bestellung erstellst, schreibst du bd[0] =0 und später wenns bezahlt ist, änderst du das einfach. Oder willst du teilzahlungen erlauben?



  • und dann musst du in deiner ausgabe-schleife natürlich abfragen, ob bd[0]==0 ist oder eben nicht und dann entsprechend bestellt oder bezahlt ausgeben.


Anmelden zum Antworten