C-Programm – Dynamische Speicherverwaltung
Dieser 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 <stdio .h>
#include <string .h>
#include <stdlib .h>
#include <ctype .h>
#if defined __linux__
#include <stdbool .h>
#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 <img src='http://suckup.de/wp-includes/images/smilies/icon_wink.gif' alt=';)' class='wp-smiley' />
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<isize ; i++)
{
if (iArray[i] == x)
{
inArray=true;
// Schleife abbrechen
break;
}
}
// return "true" or "false"
return inArray;
}
/*
============================================================================
Funktion loeschen() - anhand des Indexes (i) wird ein Eintrag geloescht
============================================================================
*/
int loeschen(kunden *s, int *iAnzahl, int i)
/*
Rückgabewert: 0 ==> 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<ianzahl ; i++)
{
// Gesamtpreis auf 0 setzen
gesamtpreis[s[i].iKundenNr]=0;
}
for (i=0; i<iAnzahl; i++)
{
// runden auf 2 Nachkommastelle
//s[i].dPreis=( (int) ((s[i].dPreis) * 100.0 + 0.5)) / 100.0;
// Ausgabe ...
//printf("\n\n\tIndex: %i", i);
printf("\n\n\tKunde: %s (%d)", s[i].pcKundenname, s[i].iKundenNr);
//printf("\n\tKunden-Nr.: %d", s[i].iKundenNr);
printf("\n\tProdukt: %s", s[i].pcProduktname);
printf("\n\tAnzahl: %i", s[i].iProduktanzahl);
dPreis[i] = berechnungPreis(s[i].dPreis, s[i].iLieferung,
s[i].iMontage, 1);
// Gesamtpreis zusammenrechnen
gesamtpreis[s[i].iKundenNr] += dPreis[i] * s[i].iProduktanzahl;
}
printf("\n\n\nWarenkorb (Gesamtpreise):\n");
for (i=0; i<iAnzahl; i++)
{
// wenn die Kunden-Nummer nicht bereits im Array steht, dann ...
if (InArray(s[i].iKundenNr, iArray, sizeof(iAnzahl)) == 0)
{
// Kunden-Nummer im Array eintragen
iArray[i] = s[i].iKundenNr;
// Ausgabe ... (und auch nur zwei Nachkommastellen anzeigen)
printf("\n\n\t---------------------------------------");
printf("\n\t---------------------------------------");
printf("\n\tKunde: %s (%d)\n\tGesamtpreis:\t\t\t%7.2lf\n",
s[i].pcKundenname,s[i].iKundenNr,gesamtpreis[s[i].iKundenNr]);
}
}
for (i=0; i<iAnzahl; i++)
{
iArray[i]=0;
}
printf("\n");
return 0;
}
/*
============================================================================
Funktion ausgabeGesamtpreis() - Gesamtpreis ausgeben
============================================================================
*/
int ausgabeGesamtpreis(kunden *s, int iAnzahl)
/*
Rückgabewert: 0 ==> 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</ianzahl><ianzahl ; i++)
{
// runden auf 2 Nachkommastelle
// dPreis[i] = ( (int) ((s[i].dPreis) * 100.0 + 0.5)) / 100.0;
dPreis[i] = berechnungPreis(s[i].dPreis, s[i].iLieferung,
s[i].iMontage, 0);
// Gesamtpreis zusammenrechnen
gesamtpreis += (dPreis[i] * s[i].iProduktanzahl);
}
printf("\n\n\t\t\t\tWarenkorb: %.2lf\n\n",gesamtpreis);
return 0;
}
/*
============================================================================
Funktion sucheNachKundenNr() - Infos ueber eine bestimmten Kunden-Nr.
============================================================================
*/
int sucheNachKundenNr(kunden *s, int iAnzahl, int iKundenNr)
/*
Rückgabewert: 0 ==> 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;
}</ianzahl></isize></stdbool></ctype></stdlib></string></stdio> Bewertung:
(1 votes, average: 5.00 out of 5)Ähnliche Blog-Einträge:
C-Programm – doppelte Schleife
C-Programm – eulersche Zahl
C-Programm – Matrix-Addition
C-Programm – neueste Datei eines Verzeichnisses (Linux)
I like it! but i got a problem with my spica. When my screen is off or when it is in sleep mode, my background apps freezes […]
stukturen von feldern