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;
}
