C-Programm – Dynamische Speicherverwaltung

closeDieser Beitrag wurde vor mehr als drei Monaten veröffentlicht. Bedenke bitte, dass die hier angebotene Information nicht mehr aktuell und gültig sein könnte. Informiere dich daher bitte auch an anderer Stelle über dieses Thema. Sollten sich neue Informationen ergeben haben, so kannst du mich auch gerne auf diese über einen Kommentar hinweisen. Vielen Dank!

In diesem Beispiel zeigt ich, wie man Speicher dynamisch anlegen bzw. verwalten kann …

/*
============================================================================
Autor          : Lars Moelleken
Datum          : 10.02.2011
Beschreibung   : Preiskalkulation
Version        : 1.0
Compiler       : gcc 4.6.2-12
Programmschnittstelle: int main(void)
Das Programm gibt den Wert 0 oder 1 zurück.
Es werden keine Argumente erwartet.
============================================================================
*/

/*
============================================================================
Praeprozessoranweisungen
============================================================================
*/
#include 
#include 
#include 
#include 
#if defined __linux__
#include 
#elif defined _WIN32 || defined _WIN64
#define false 0
#define true 1
#endif

#define FUNSTAR_PREIS 1243.43
#define FUNSTAR_NAME "Fun Star"
#define HIGHEND_PREIS 1658.50
#define HIGHEND_NAME "High End"
#define MULTIMEDIASTAR_PREIS 698.20
#define MULTIMEDIASTAR_NAME "Multimedia Star"
#define OFFICESTAR_PREIS 1015.39
#define OFFICESTAR_NAME "Office Star"
#define GEHAEUSE_NAME "Gehaeuse"
#define LX100_PREIS 97.05
#define LX100_NAME "Compucase LX100 weiss"
#define LX120_PREIS 68.89
#define LX120_NAME "Compucase LX120 schwarz"
#define LX34A_PREIS 103.60
#define LX34A_NAME "Compucase LX34A weiss"
#define MAINBOARD_PREIS 193.03
#define MAINBOARD_NAME "Mainboard"
#define CPU_PREIS 334.65
#define CPU_NAME "CPU"
#define FESTPLATTEN_PREIS 130.95
#define FESTPLATTEN_NAME "Festplatte"
#define GRAFIKKARTEN_PREIS 319.13
#define GRAFIKKARTEN_NAME "Grafikkarte"

// die Struktur existiert nach der Deklaration als neuer Datentyp
// per typedef kann ein Synonym fuer die Strucktur erstellt werden 
typedef struct 
{
   char *pcKundenname, *pcProduktname;
   int iKundenNr, iProduktanzahl, iLieferung, iMontage;
   double dPreis;
} kunden;

/*
============================================================================
Funktionsprototypen
============================================================================
*/
// neuer Datentyp "kunden" wird hier direkt verwendent
kunden* datenEinlesen(kunden *s,int *iAnzahl, char *pcKundenname, 
   char *pcProduktname, int iKundenNr, int iProduktanzahl,
   int iLieferung,int iMontage,double dPreis);
int cls(void);
int new_fflush(void);
int InArray(int x, int iArray[], int iSize);
int loeschen(kunden *s, int *iAnzahl, int i);
double berechnungPreis(double dInputPreis, int iLieferung,
   int iMontage, int iAusgabe);
int ausgabeWarenkorb(kunden *s, int iAnzahl);
int ausgabeGesamtpreis(kunden *s, int iAnzahl);
int sucheNachKundenNr(kunden *s, int iAnzahl, int iKundenNr);
int sucheNachName(kunden *s, int iAnzahl, char *pcKundenname);
char *readKundenName(kunden *s, int iAnzahl, int iKundenNr);
int readProduktanzahl(void);
int readMontage(void);
int readLieferung(void);
int readKundenNr(void);
int printMenu(void);
int printMenuStandard(void);
int printMenuEinzel(void);
int printMenuGehaeuse(void);

/*
============================================================================
Funktion main() - Hauptfunktion
============================================================================
*/
int main(void)
/*
Rückgabewert:    0 ==> alles OK
                 1 ==> es ist ein Fehler aufgetreten
Es werden keine Argumente übergeben!
*/
{
   char cNamePuffer[100], cProduktPuffer[100], cInput;
   int iAnzahl=0, i, iKundenNr, inputStandard, auswahl, iProduktanzahl, 
      iShowMenu=true, iLieferung=false, iMontage=false;
   double dPreis;
 
   // Zeiger auf einen Eintrag definieren 
   kunden *s;
   // neuen Speicherbereich fuer die Struktur "kunden" anlegen
   s = (kunden*) malloc(sizeof(iAnzahl));
   // falls kein Speicherplatz zur Verfuegung steht ...
   if (s == NULL)
   {
      printf("Fehler: .......Speicherplatzmangel\n");
      exit(1);
   }
 
   // solange bis '0' eingegeben wird ...
   do 
   {
      if (iShowMenu == 1) 
      {
         cls();
         // Ausgabe vom Warenkorb
         ausgabeGesamtpreis(s,iAnzahl);
         // Ausgabe vom Menue
         printMenu();
      }  
      // Eingabe
      scanf("%c", &cInput);
      new_fflush();
      // Auswahl zur Eingabe 
      switch (cInput) 
      {
         // Einlesen
         case 'a': case 'A':
            iShowMenu=false;
            // i = 1 => true
            i = 1;
            // solange i = true ...
            while (i == true)
            {
               do
               {
                  cls();
                  // Ausgabe vom Warenkorb
                  ausgabeGesamtpreis(s,iAnzahl);
                  // Ausgabe vom MenueStadard
                  printMenuStandard();
                  scanf("%d", &inputStandard);
                  new_fflush();
               } 
               while (inputStandard != 0 && 
               		 inputStandard != 1 && 
               		 inputStandard != 2 && 
               		 inputStandard != 3 && 
               		 inputStandard != 4);
               // Auswahl zur Eingabe 
               switch (inputStandard) 
               {
                  case 1:
                     dPreis=FUNSTAR_PREIS;
                     strncpy(cProduktPuffer,FUNSTAR_NAME,
                     		 strlen(FUNSTAR_NAME) +1);
                     break;
                  case 2:
                     dPreis=HIGHEND_PREIS;
                     strncpy(cProduktPuffer,HIGHEND_NAME,
                     		 strlen(HIGHEND_NAME) +1);
                     break;
                  case 3:
                     dPreis=MULTIMEDIASTAR_PREIS;
                     strncpy(cProduktPuffer,MULTIMEDIASTAR_NAME,
                     		 strlen(MULTIMEDIASTAR_NAME) +1);
                     break;
                  case 4:
                     dPreis=OFFICESTAR_PREIS;
                     strncpy(cProduktPuffer,OFFICESTAR_NAME,
                     		 strlen(OFFICESTAR_NAME) +1);
                     break;
                  default:
                     dPreis=0;
                     // i = 0 => false => while-Schleife wird verlassen
                     i=false;
                     cls();
                     iShowMenu=true;
                     break;
               }
               if (dPreis != 0)
               {
                  iKundenNr=readKundenNr();
                  strcpy(cNamePuffer,readKundenName(s, iAnzahl, iKundenNr));
                  iProduktanzahl=readProduktanzahl();
                  iLieferung=readLieferung();

                  cls();
                  berechnungPreis(dPreis, iLieferung, iMontage, 1);

                  printf("\n\nIn den Warenkorb? ('j' fuer ja) ");
                  // Einlesen von cInput
                  scanf("%c", &cInput);
                  new_fflush();
                  printf("\n\n");
                  // wenn Eingabe ungleich j ist, dann ...
                  if (cInput == 'j') 
                  {
                     // Speicher wird per Funktion (datenEinlesen) erstellt
                     s = datenEinlesen(s,&iAnzahl,cNamePuffer,cProduktPuffer,
                     		 iKundenNr,iProduktanzahl,iLieferung,iMontage,dPreis);

                     printf("\n**Eintrag gespeichert**\n");
                     printf("\n\tweiteren Eintrag anlegen? ('j' fuer ja) ");
                  }
                  else
                  {
                     printf("\n\tanderen Eintrag anlegen? ('j' fuer ja) ");
                  }

                  // Einlesen von cInput
                  scanf("%c", &cInput);
                  new_fflush();
                  printf("\n\n");
                  // wenn Eingabe ungleich j ist, dann ...
                  if (cInput != 'j') 
                  {
                     // i = 0 => false => while-Schleife wird verlassen
                     i=false;
                     cls();
                     iShowMenu=true;
                  }
                  else
                  {
                     cls();
                     iShowMenu=false;
                  }
               }
            }
            // beendet eine Schleife bzw. eine case-Anweisung 
            break;
         // Einlesen
         case 'b': case 'B':
            cls();
            iShowMenu=false;
            // i = 1 => true
            i = true;
            // solange i==true ...
            while (i == true)
            {
               do
               {
                  cls();
                  // Ausgabe vom Warenkorb
                  ausgabeGesamtpreis(s,iAnzahl);
                  // Ausgabe vom MenueStadard
                  printMenuEinzel();
                  scanf("%d", &inputStandard);
                  new_fflush();
               } 
               while (inputStandard != 0 && 
               		 inputStandard != 1 && 
               		 inputStandard != 2 && 
               		 inputStandard != 3 && 
               		 inputStandard != 4 && 
               		 inputStandard != 5);
               // Auswahl zur Eingabe 
               switch (inputStandard) 
               {
                  case 1:
                     // i = 0 => false => while-Schleife wird verlassen
                     i=false;
                     do
                     {
                        cls();
                        // Ausgabe vom Warenkorb
                        ausgabeGesamtpreis(s,iAnzahl);
                        // Ausgabe vom MenueStadard
                        printMenuGehaeuse();
                        scanf("%d", &inputStandard);
                        new_fflush();
                     } 
                     while (inputStandard != 0 && 
                     		 inputStandard != 1 && 
                     		 inputStandard != 2 && 
                     		 inputStandard != 3);
                     // Auswahl zur Eingabe 
                     switch (inputStandard)
                     {
                        case 1:
                           dPreis=LX100_PREIS;
                           strncpy(cProduktPuffer,LX100_NAME,
                           		 strlen(LX100_NAME) +1);
                           break;
                        case 2:
                           dPreis=LX120_PREIS;
                           strncpy(cProduktPuffer,LX120_NAME,
                           		 strlen(LX120_NAME) +1);
                           break;
                        case 3:
                           dPreis=LX34A_PREIS;
                           strncpy(cProduktPuffer,LX34A_NAME,
                           		 strlen(LX34A_NAME) +1);
                           break;
                        default:
                           dPreis=0;
                           // i = 0 => false => while-Schleife wird verlassen
                           i=false;
                           cls();
                           iShowMenu=true;
                           break;
                     }
                     break;
                  case 2:
                     dPreis=MAINBOARD_PREIS;
                     strncpy(cProduktPuffer,MAINBOARD_NAME,
                     		 strlen(MAINBOARD_NAME) +1);
                     break;
                  case 3:
                     dPreis=CPU_PREIS;
                     strncpy(cProduktPuffer,CPU_NAME,
                     		 strlen(CPU_NAME) +1);
                     break;
                  case 4:
                     dPreis=FESTPLATTEN_PREIS;
                     strncpy(cProduktPuffer,FESTPLATTEN_NAME,
                     		 strlen(FESTPLATTEN_NAME) +1);
                     break;
                  case 5:
                     dPreis=GRAFIKKARTEN_PREIS;
                     strncpy(cProduktPuffer,GRAFIKKARTEN_NAME,
                     		 strlen(GRAFIKKARTEN_NAME) +1);
                     break;
                  default:
                     dPreis=0;
                     // i = 0 => false => while-Schleife wird verlassen
                     i=false;
                     cls();
                     iShowMenu=true;
                     break;
               }
               if (dPreis != 0)
               {
                  iKundenNr=readKundenNr();
                  strcpy(cNamePuffer,readKundenName(s, iAnzahl, iKundenNr));
                  iProduktanzahl=readProduktanzahl();
                  iLieferung=readLieferung();
                  iMontage=readMontage();
 
                  cls();
                  berechnungPreis(dPreis, iLieferung, iMontage, 1);

                  printf("\n\nIn den Warenkorb? ('j' fuer ja) ");
                  // Einlesen von cInput
                  scanf("%c", &cInput);
                  new_fflush();
                  printf("\n\n");
                  // wenn Eingabe ungleich j ist, dann ...
                  if (cInput == 'j') 
                  {
                     // Speicher wird per Funktion (datenEinlesen) erstellt
                     s = datenEinlesen(s,&iAnzahl,cNamePuffer,cProduktPuffer,
                     		 iKundenNr,iProduktanzahl,iLieferung,iMontage,dPreis);

                     printf("\n**Eintrag gespeichert**\n");
                     printf("\n\tweiteren Eintrag anlegen? ('j' fuer ja) ");
                  }
                  else
                  {
                     printf("\n\tanderen Eintrag anlegen? ('j' fuer ja) ");
                  }

                  // Einlesen von cInput
                  scanf("%c", &cInput);
                  new_fflush();
                  printf("\n\n");

                  // wenn Eingabe ungleich j ist, dann ...
                  if (cInput != 'j') 
                  {
                     // i = 0 => false => while-Schleife wird verlassen
                     i=false;
                     cls();
                     iShowMenu=true;
                  }
                  else
                  {
                     cls();
                     iShowMenu=false;
                  }
               }
            }
            // beendet eine Schleife bzw. eine case-Anweisung 
            break;
         // Ausgabe
          case 'c': case 'C':
            cls();
            iShowMenu=false;
            // wenn Anzahl gleich 0, dann ...
            if (iAnzahl==0) 
            {
               printf("\n\n**Kein Eintrag gefunden**\n\n");
            } 
            else 
            {
               ausgabeWarenkorb(s,iAnzahl);
            }
            printf("\ndrueke 'Enter' um fortzufahren: ...\n");
            if (getchar() == '\n')
            {
               cls();
               iShowMenu=true;
            }
            // beendet eine Schleife bzw. eine case-Anweisung 
            break;
         // Nach Kunden-Namen suchen
         case 'd': case 'D':
            cls();
            iShowMenu=false;
            printf("Suchen (Kunden-Name): ");
            // Einlesen von cNamePuffer (pcKundenname)
            scanf("%99s", cNamePuffer);
            new_fflush();
            // Funktion wird aufgerufen 
            sucheNachName(s,iAnzahl,cNamePuffer);
            printf("\ndrueke 'Enter' um fortzufahren: ...\n");
            if (getchar() == '\n')
            {
               cls();
               iShowMenu=true;
            }
            // beendet eine Schleife bzw. eine case-Anweisung 
            break;
         // Nach Kunden-Nr. suchen
         case 'e': case 'E':
            cls();
            iShowMenu=false;
            printf("Suchen (Kunden-Nr.): ");
            // Einlesen von iKundenNr
            scanf("%d",&iKundenNr);
            new_fflush();
            // Funktion wird aufgerufen 
            sucheNachKundenNr(s,iAnzahl,iKundenNr);
            printf("\ndrueke 'Enter' um fortzufahren: ... \n");
            if (getchar() == '\n')
            {
               cls();
               iShowMenu=true;
            }
            // beendet eine Schleife bzw. eine case-Anweisung 
            break;
         // Einen Eintrag löschen
         case 'f': case 'F':
            cls();
            iShowMenu=false;
            printf("Loeschen: ");
            i=true;
            while (i == true) 
            {
               if (iAnzahl != 0) 
               {
                  for (i=0; i != iAnzahl; i++) 
                  {
                     printf("\n\t---------------------------------------");
                     printf("\n\tIndex: %d -> Kunde: %s (%d)", i, 
                     		 s[i].pcKundenname, s[i].iKundenNr);
                     printf("\n\t---------------------------------------");
                  }
                  printf("\n\nIndex angeben: ");
                  scanf("%d",&auswahl);
                  new_fflush();
                  if (auswahl < 0 || auswahl >= iAnzahl) 
                  {
                     cls();
                     printf("\nungueltige Eingabe\n\n");
                  } 
                  else 
                  {
                     printf("\n\tEintrag wirklich loeschen? ('j' fuer ja) ");
                     // Einlesen von cInput
                     scanf("%c", &cInput);
                     new_fflush();
                     printf("\n\n");

                     // wenn Eingabe gleich j ist, dann ...
                     if (cInput == 'j') 
                     {
                        loeschen(s,&iAnzahl,auswahl);
                        i=false;
                           printf("\n\n**Eintrag geloescht !**\n\n");
                     }
                     else
                     {
                        // i = 0 => false => while-Schleife wird verlassen
                        i=false;
                        iShowMenu=true;
                     }

                  }
               } 
               else 
               {
                  i=false;
                  printf("\n\n**Kein Eintrag gefunden**\n\n");
               }
               printf("\ndrueke 'Enter' um fortzufahren: ... \n");
               if (getchar() == '\n')
               {
                  cls();
                  iShowMenu=true;
               }
            }
            // beendet eine Schleife bzw. eine case-Anweisung 
            break;
         // Speicher wieder freigeben (free)
         case 'x': case 'X':
            for (i=0; i != iAnzahl; i++) 
            {
               // "free" gibt den Speicher wieder frei
               free(s[i].pcKundenname);
            }
            // testing
            //free(s);
            // Alternative schreibweise:
            // realloc(s,0);
            // beendet eine Schleife bzw. eine case-Anweisung
            break;
         // Standard 
         default:
            iShowMenu=true;
            break;
      }
   // solange in der Schleife bleiben, bis 0 eingegeben wird 
   } 
   while (cInput != 'x' && cInput != 'X');
 
   return 0;
}

/*
============================================================================
Funktion datenEinlesen() - der Speicher wird bereitgestellt und die Eingaben 
               an die Strucktur uebergeben
============================================================================
*/
kunden* datenEinlesen(kunden *s, int *iAnzahl, char *pcKundenname,
   char *pcProduktname, int iKundenNr, int iProduktanzahl,
   int iLieferung, int iMontage, double dPreis)
/*
Rückgabewert:    s ==> neuen Speicherbereich
Argumente:    *s ==> Zeiger auf den neuen Speicherbereich
      *iAnzahl ==> Zeiger auf die Anzahl an Eintraegen
      *pcKundenname ==> Zeiger auf den Kunden-Namen
      *pcProduktname ==> Zeiger auf den Produkt-Namen 
      iKundenNr ==> Kunden-Nr.
      iProduktanzahl ==> Anzahl vom bestellten Produkten
      iLieferung ==> Lieferung (1=ja || 0=nein)
      iMontage ==> Montage (1=ja || 0=nein)
      dPreis ==> Preis pro Produkt
*/
{
   //
   // realloc() -    kann Speicherplatz von einem bereits zugeteilten 
   //      Blocks vergroeßern oder verkleinern, dazu wird ein 
   //      Zeiger auf die Anfangsadresse des neu reservierten 
   //      Speicherblocks gesetzt, dabei bleibt der Inhalt des 
   //      urspruenglichen Speicherblocks erhalten und der neue 
   //      Speicherblock wird hinten angefuegt
   //
   // Speicherbereich wird vergroeßert
   s=(kunden*)realloc(s,sizeof(kunden)*(*iAnzahl +1));
   //
   // strlen -    gibt die Anzahl der Zeichen eines Strings 
   //      ohne das Null-Zeichen zurueck
   // strcpy -    Stringfunktion zum kopieren einer Zeichenkette       
   //
   // malloc() -    reserviert genau so viel zusammenhaengenden Speicher, 
   //      wie angegeben wird, zurueckgegeben wird ein typenloser 
   //      Zeiger auf void mit der Anfangsadresse des 
   //      Speicherbereichs
   //
   // z.B.: 
   // Speicher fuer 100 int-Elemente reservieren 
   // ptr = malloc(100 * sizeof(int));
   // ...
   // Speicher auf 50 int-Elemente verkleinern 
   // ptr = realloc(ptr, 50 * sizeof(int));
   // ...
   // Speicher von 256 auf 512 int-Elemente vergroeßern 
   // int block = 256;
   // ptr = malloc(block * sizeof(int));
   // block += block;
   // ptr = reallloc(ptr, block * sizeof(int));
   //
   // neuen Speicherbereich fuer einen neuen Namen anlegen
   // +1 wegen \0 -> am Ende vom String
   s[*iAnzahl].pcKundenname=(char*) malloc(strlen(pcKundenname) +1); 
   // falls kein Speicherplatz zur Verfuegung steht ...
   if (s[*iAnzahl].pcKundenname == NULL) 
   {
      printf("Fehler: .......Speicherplatzmangel\n");
      exit(1);
   }
   // der Strucktur (kunden) wird die Variable "pcKundenname" hinzugefuegt 
   strncpy(s[*iAnzahl].pcKundenname,pcKundenname,strlen(pcKundenname) +1);
   // der Strucktur (kunden) wird die Variable "iKundenNr" hinzugefuegt
   s[*iAnzahl].iKundenNr=iKundenNr;
   // neuen Speicherbereich fuer einen neuen Produktnamen anlegen
   // +1 wegen \0 -> am Ende vom String
   s[*iAnzahl].pcProduktname=(char*) malloc(strlen(pcProduktname) +1);
   // falls kein Speicherplatz zur Verfuegung steht ...
   if (s[*iAnzahl].pcProduktname == NULL) 
   {
      printf("Fehler: .......Speicherplatzmangel\n");
      exit(1);
   }
   // der Strucktur (kunden) wird die Variable "pcProduktname" hinzugefuegt 
   strncpy(s[*iAnzahl].pcProduktname,pcProduktname,strlen(pcProduktname) +1);
   // der Strucktur (kunden) wird die Variable "iProduktanzahl" hinzugefuegt   
   s[*iAnzahl].iProduktanzahl=iProduktanzahl; 
   // der Strucktur (kunden) wird die Variable "iLieferung" hinzugefuegt   
   s[*iAnzahl].iLieferung=iLieferung;
   // der Strucktur (kunden) wird die Variable "iMontage" hinzugefuegt   
   s[*iAnzahl].iMontage=iMontage;
   // der Strucktur (kunden) wird die Variable "dPreis" hinzugefuegt 
   s[*iAnzahl].dPreis=dPreis;
   // die Anzahl der Kunden um 1 erhoehen
   ++*iAnzahl;
   return s;
}

/*
============================================================================
Funktion cls() - clear
============================================================================
*/
int cls(void)
/*
Rückgabewert:    0 ==> alles OK
Es werden keine Argumente übergeben!
*/
{
#if defined __linux__
   printf("\033[2J");
#elif defined _WIN32 || defined _WIN64
   system("cls");
#endif
   return 0;
}

/*
============================================================================
Funktion new_fflush() - fflush(stdin) for Linux and Windows
============================================================================
*/
int new_fflush(void)
/*
Rückgabewert:    0 ==> alles OK
Es werden keine Argumente übergeben!
*/
{
#if defined __linux__
   int ch;
   while ((ch = getchar()) != '\n' && ch != EOF);                  
#elif defined _WIN32 || defined _WIN64
   fflush(stdin);
#endif
   return 0; 
}

/*
============================================================================
Funktion InArray() - check if 'x' in the 'iArray'
============================================================================
*/
int InArray(int x, int iArray[], int iSize)
/*
Rückgabewert:    inArray ==> is in Array or not ;)
Argumente:   x ==> checking 'x'
      iArray[] ==> in this iArray
      iSize ==> iSize of the iArray
*/
{
   // default is "false"
   int inArray=false;
   int i;
   for (i=0; i alles OK
Argumente:   *s ==> Zeiger auf den neuen Speicherbereich
      *iAnzahl ==> Zeiger auf die Anzahl an Eintraegen
      i ==> Auswahl des Indexes 
*/
{
   // solange Index nicht Anzahl ist ...
   for (i; i != *iAnzahl; i++) 
   {
      // Strucktur-Eintraege um 1 erhoehen
      s[i].pcKundenname=s[i+1].pcKundenname;
      s[i].iKundenNr=s[i+1].iKundenNr;
      s[i].pcProduktname=s[i+1].pcProduktname;
      s[i].iProduktanzahl=s[i+1].iProduktanzahl;
      s[i].iLieferung=s[i+1].iLieferung;
      s[i].iMontage=s[i+1].iMontage;
      s[i].dPreis=s[i+1].dPreis;
   }
   // Anzahl -1 
   --*iAnzahl;
   // Speicherbereich wird verkleinert
   s=(kunden*) realloc(s,sizeof(kunden) * (*iAnzahl));
   return 0;
}

// Funktion: berechnungPreis
double berechnungPreis(double dInputPreis, int iLieferung,
		int iMontage, int iAusgabe)
{
   // Ausgabe ...
   if (iAusgabe == 1) 
   {
      printf("\n\n\tListenpreis pro Artikel:\t%7.2lf", dInputPreis);
      printf("\n\t\t+ Lagerkosten:\t\t%7.2lf", dInputPreis * 0.1);
   }
   dInputPreis = dInputPreis + (dInputPreis  * 0.1);
   if (iAusgabe == 1) 
   {
      printf("\n\t---------------------------------------");
      printf("\n\tMaterialkosten:\t\t\t%7.2lf", dInputPreis);
      printf("\n\t\t+ Verwaltungskosten:\t%7.2lf", dInputPreis * 0.1);
   }
   dInputPreis = dInputPreis + (dInputPreis * 0.1);
   if (iAusgabe == 1) 
   {
      printf("\n\t---------------------------------------");
      printf("\n\tSelbstkosten:\t\t\t%7.2lf", dInputPreis);
      printf("\n\t\t+ Gewinn:\t\t%7.2lf", dInputPreis * 0.1);
   }
   dInputPreis = dInputPreis + (dInputPreis * 0.1);
   if (iAusgabe == 1) 
   {
      printf("\n\t---------------------------------------");
      printf("\n\tBarverkaufspreis:\t\t%7.2lf", dInputPreis);
   }
   if (iLieferung == 1)
   {
      if (iAusgabe == 1) 
      {
         printf("\n\t\t+ Versand:\t\t%7.2lf", dInputPreis * 0.05);
      }
      dInputPreis = dInputPreis + (dInputPreis * 0.05);
      if (iAusgabe == 1) 
      {
         printf("\n\t---------------------------------------");
         printf("\n\tVersandpreis:\t\t\t%7.2lf", dInputPreis);
      }
   }
   if (iMontage == 1)
   {
      if (iAusgabe == 1) 
      {
         printf("\n\t\t+ Montage:\t\t%.2lf", dInputPreis * 0.15);
      }
      dInputPreis = dInputPreis + (dInputPreis * 0.15);
      if (iAusgabe == 1) 
      {
         printf("\n\t---------------------------------------");
         printf("\n\tHerstellungskosten:\t\t%7.2lf", dInputPreis);
      }
   }
   return dInputPreis;
}

/*
============================================================================
Funktion ausgabeWarenkorb() - Warenkorb ausgeben
============================================================================
*/
int ausgabeWarenkorb(kunden *s, int iAnzahl) 
/*
Rückgabewert:    0 ==> alles OK
Argumente:   *s ==> Zeiger auf den neuen Speicherbereich
      iAnzahl ==> Anzahl an Eintraegen
*/
{
   int i, iArray[100];
   double gesamtpreis[100], dPreis[100];
   printf("\nWarenkorb (Einzelpreise):\n");
   // von 0 bis Anzahl ...
   for (i=0; i alles OK
Argumente:   *s ==> Zeiger auf den neuen Speicherbereich
      iAnzahl ==> Anzahl an Eintraegen
*/
{
   int i;
   double gesamtpreis=0, dPreis[32];
   // von 0 bis Anzahl ...
   for (i=0; i alles OK
      1 ==> es ist ein Fehler aufgetreten
Argumente:   *s ==> Zeiger auf den neuen Speicherbereich
      iAnzahl ==> Anzahl an Eintraegen
      iKundenNr ==> Kunden-Nr.
*/
{
   int i,x=false;
   double dPreis[100];
   // von 0 bis Anzahl ...
   for (i=0;i != iAnzahl; i++) 
   {
      // wenn der Eintrag gleich dem Suchbegriff ist ...
      if (s[i].iKundenNr==iKundenNr) 
      {
         dPreis[i] = berechnungPreis(s[i].dPreis, s[i].iLieferung,
         		 s[i].iMontage, 0);
         dPreis[i] = dPreis[i] * s[i].iProduktanzahl;
         printf("\n(Index: %3d)\nKunde: %s\nKunden-Nr: %d\nProdukt: %s\n"
         		 "Preis: %.2lf\n\n",i,s[i].pcKundenname,s[i].iKundenNr,
         		 s[i].pcProduktname,dPreis[i]);
         // x=1 -> Eintrag gefunden
         x=true;
      }
   }
   // wenn Eintrag nicht gefunden wurde, dann ...
   if (x==false) 
   {
      printf("\n\n**Kein Eintrag gefunden**\n\n");
      return 1;
   }
   else
   {
      return 0;
   }
}

/*
============================================================================
Funktion sucheNachName() - Infos ueber eine bestimmten Kunden-Namen
============================================================================
*/
int sucheNachName(kunden *s, int iAnzahl, char *pcKundenname)
/*
Rückgabewert:    0 ==> alles OK
      1 ==> es ist ein Fehler aufgetreten
Argumente:   *s ==> Zeiger auf den neuen Speicherbereich
      iAnzahl ==> Anzahl an Eintraegen
      *pcKundenname ==> Kunden-Name
*/
{
   int i,x=false;
   double dPreis[100];
   // von 0 bis Anzahl ...
   for (i=0;i != iAnzahl;i++) 
   {
      // Vergleich (strcmp) von char-Arrays bzw. String
      if ( !strcmp(pcKundenname,s[i].pcKundenname) ) 
      {
         dPreis[i] = berechnungPreis(s[i].dPreis, s[i].iLieferung,
         		 s[i].iMontage, 0);
         printf("\n(Index: %3d)\nKunde: %s\nKunden-Nr: %d\nProdukt: %s\n"
         		 "Preis: %.2lf\n\n",i,s[i].pcKundenname,s[i].iKundenNr,
         		 s[i].pcProduktname,dPreis[i]);
         // x=1 -> Eintrag gefunden
         x=true;
      }
   }
   // wenn Eintrag nicht gefunden wurde, dann ...
   if (x==false) 
   {
      printf("\n\n**Kein Eintrag gefunden**\n\n");
      return 1;
   }
   else
   {
      return 0;
   }
}

/*
============================================================================
Funktion readKundenName() - scanf with check
============================================================================
*/
char *readKundenName(kunden *s, int iAnzahl, int iKundenNr)
/*
Rückgabewert:    cNamePuffer ==> Kunden-Name
Argumente:   *s ==> Zeiger auf den neuen Speicherbereich
      iAnzahl ==> Anzahl an Eintraegen
      iKundenNr ==> Kunden-Nr.
*/
{
   int check=true, i;
   static char cNamePuffer[100];
   if (iAnzahl != 0) 
   {
      for (i=0; i != iAnzahl; i++) 
      {
         if (s[i].iKundenNr == iKundenNr)
         {
            strncpy(cNamePuffer,s[i].pcKundenname,
            		strlen(s[i].pcKundenname) +1);
            check=false;
         }
      }
   }
   if (check==true)
   {
      do 
      {
         printf("\tKunde (Name): ");
         // Einlesen von cNamePuffer (pcKundenname)
         scanf("%99s", cNamePuffer);
         new_fflush();
         if (!isalpha(cNamePuffer[0]))
         {
            printf("\n\n**Bitte einen korrekten Namen eingeben!!!**\n\n");
         }
      } 
      while (!isalpha(cNamePuffer[0]));
   }
   return cNamePuffer;
}

/*
============================================================================
Funktion readProduktanzahl() - scanf with check
============================================================================
*/
int readProduktanzahl(void)
/*
Rückgabewert:    iProduktanzahl ==> Produktanzahl
Es werden keine Argumente übergeben!
*/
{
   int check=true, iProduktanzahl;
   check=true;
   do 
   {
      printf("\tAnzahl: ");
      // Einlesen der Produktanzahl
      check = !scanf("%d", &iProduktanzahl);
      new_fflush();
      if (check)
      {
         printf("\n\n**Bitte eine korrekte Produktanzahl eingeben!!!**\n\n");
      }
   } 
   while (check);
   return iProduktanzahl;
}

/*
============================================================================
Funktion readLieferung() - scanf with check
============================================================================
*/
int readMontage(void)
/*
Rückgabewert:    iMontage ==> Montage (1 | 0)
Es werden keine Argumente übergeben!
*/
{
   int iMontage=0;
   char cInput;
   do 
   {
      printf("\tMontage: ('j' fuer ja) ");
      // Einlesen der Montage
      scanf("%c", &cInput);
      new_fflush();
      if (!isalpha(cInput))
      {
         printf("\n**Bitte eine korrekte Eingabe taetigen!!!**\n");
      }
   } 
   while (!isalpha(cInput));
   if (cInput == 'j') 
   {
      iMontage=true;
   }
   return iMontage;
}

/*
============================================================================
Funktion readLieferung() - scanf with check
============================================================================
*/
int readLieferung(void)
/*
Rückgabewert:    iLieferung ==> Lieferung (1 | 0)
Es werden keine Argumente übergeben!
*/
{
   int iLieferung=0;
   char cInput;   
   do 
   {
      printf("\tLieferung: ('j' fuer ja) ");
      // Einlesen der Lieferung
      scanf("%c", &cInput);
      new_fflush();
      if (!isalpha(cInput))
      {
         printf("\n\n**Bitte eine korrekte Eingabe taetigen!!!**\n\n");
      }
   } 
   while (!isalpha(cInput));
   if (cInput == 'j') 
   {
      iLieferung=true;
   }
   return iLieferung;
}

/*
============================================================================
Funktion readKundenNr() - scanf with check
============================================================================
*/
int readKundenNr(void)
/*
Rückgabewert:    iKundenNr ==> Kunden-Nr.
Es werden keine Argumente übergeben!
*/
{
   int check=true, iKundenNr;
   do 
   {
      printf("\n\tKunden-Nr.: ");
      // Einlesen der iKundenNr
      check = !scanf("%d", &iKundenNr);
      new_fflush();
      if (check)
      {
         printf("\n\n**Bitte eine korrekte Kunden-Nr. eingeben!!!**\n\n");
      }
   } 
   while (check);
   return iKundenNr;
}

/*
============================================================================
Funktion printMenu() - Ausgabe vom Menue
============================================================================
*/
int printMenu(void) 
/*
Rückgabewert:    0 ==> alles OK
Es werden keine Argumente übergeben!
*/
{
   printf("\n\tP R E I S K A L K U L A T I O N");
   printf("\n\t===============================");
   printf("\n\n\ta: Standardkonfiguration");
   printf("\n\n\tb: Einzelkomponenten");
   printf("\n\n\tc: Warenkorb anzeigen"); 
   printf("\n\n\td: Suchen (Kunden-Name)");
   printf("\n\n\te: Suchen (Kunden-Nr.)");
   printf("\n\n\tf: Loeschen");
   printf("\n\n\tx: Ende");
   printf("\n\n\n\tAuswahl: ");
   return 0;
}

/*
============================================================================
Funktion printMenuStandard() - Ausgabe vom Standard-Menue
============================================================================
*/
int printMenuStandard(void) 
/*
Rückgabewert:    0 ==> alles OK
Es werden keine Argumente übergeben!
*/
{
   printf("\n\tS T A N D A R D K O N F I G U R A T I O N");
   printf("\n\t=========================================");
   printf("\n\n\t1: %s\t\t%5.2f", FUNSTAR_NAME, FUNSTAR_PREIS);
   printf("\n\t2: %s\t\t%5.2f", HIGHEND_NAME, HIGHEND_PREIS);
   printf("\n\t3: %s\t% 5.2f", MULTIMEDIASTAR_NAME, MULTIMEDIASTAR_PREIS);
   printf("\n\t4: %s\t\t%5.2f", OFFICESTAR_NAME, OFFICESTAR_PREIS);
   printf("\n\t0: Abbruch");
   printf("\n\n\n\tAuswahl: ");
   return 0;
}

/*
============================================================================
Funktion printMenuEinzel() - Ausgabe vom Einzel-Menue
============================================================================
*/
int printMenuEinzel(void) 
/*
Rückgabewert:    0 ==> alles OK
Es werden keine Argumente übergeben!
*/
{
   printf("\n\tE I N Z E L K O M P O N E N T E N");
   printf("\n\t=================================");
   printf("\n\n\t1: %s", GEHAEUSE_NAME);
   printf("\n\t2: %s\t\t%5.2f", MAINBOARD_NAME, MAINBOARD_PREIS);
   printf("\n\t3: %s\t\t\t%5.2f", CPU_NAME, CPU_PREIS);
   printf("\n\t4: %s\t\t%5.2f", FESTPLATTEN_NAME, FESTPLATTEN_PREIS);
   printf("\n\t5: %s\t\t%5.2f", GRAFIKKARTEN_NAME, GRAFIKKARTEN_PREIS);
   printf("\n\t0: Abbruch");
   printf("\n\n\n\tAuswahl: ");
   return 0;
}

/*
============================================================================
Funktion printMenuEinzel() - Ausgabe vom Einzel-Menue
============================================================================
*/
int printMenuGehaeuse(void) 
/*
Rückgabewert:    0 ==> alles OK
Es werden keine Argumente übergeben!
*/
{
   printf("\n\tG E H A E U S E K O M P O N E N T E N");
   printf("\n\t=====================================");
   printf("\n\n\t1: %s\t %5.2f", LX100_NAME, LX100_PREIS);
   printf("\n\t2: %s\t %5.2f", LX120_NAME, LX120_PREIS);
   printf("\n\t3: %s\t%5.2f", LX34A_NAME, LX34A_PREIS);
   printf("\n\t0: Abbruch");
   printf("\n\n\n\tAuswahl: ");
   return 0;
}
  • http://suckup.de/howto/c/c-programm-dynamische-speicherverwaltung/ strukturen

    stukturen von feldern