Warum läuft das Programm nicht?
-
Hallo liebe Sachkundige,
ich habe hier ein Programm,
das leider nicht unter MicrosoftVisual C++ 6.0 laufen sollte,
es wurde mit einem anderen Compiler/Editor erstellt und läuft aber mit dem
Bloodshed Dev-C++ einwandfrei!
Es wäre prima,wenn mir da jemand weiterhelfen könnte!
Vielen Dank im **voraus
Dennis
/* getraenkdoc.c */
/* Aufgabentext:Schreiben Sie ein Programm automat.c, das ein Getraenke-Automat simuliert
Der Automat soll verschiedene Getränke zu verschiedenen Preisen anbieten.
(Cola: 0,75 Wasser: 0,50 Bluna: 0,65). Der Automat muß einen definierten
Bestand an Flaschen aufweisen und einen definierten Bestand an allen
gängigen Münzen.
Der Ablauf des Programms:
Geld einwerfen (in einzelnen Münzen)
Sorte wählen
Prüfen ob ausreichend Geld eingeworfen
Prüfen ob Geldwechseln möglich
Falls alle Bedingungen erfüllt sind, Flasche ausgeben
Aktuellen Füllstand mit Geld (nach Münzen) und Getränken
(nach Sorten) ausgeben.
Dies wird wiederholt, bis der Benutzer das Programm beendet. (STRG-C) *//* Deklarations der verwendeten Bibliotheken */
#include <stdio.h> /* Dateioperationen, Eingabe, Ausgabe /
#include <string.h> / Funktionen fuer Zeichenketten /
#include <unistd.h> / (LIFE_INTERVAL); *//*************************************************************************/
/* Deklarations-Block *//* Deklaration von Textersatz /
#define ANZAHL 3 / definierter Bestand an Flaschen*/
#define LIFE_INTERVAL 1 /* Intervall zwischen den Segmenten *//* Hier werden die Preise für die einzelnen Sorten festgelegt
dies wurde mit Hilfe von Textersatz durchgeführt, da man
somit schnell diese abändern kann. */#define blunapreis 0.65 /* definierter Preis für Bluna /
#define colapreis 0.75 / definierter Preis für Cola /
#define wasserpreis 0.50 / definierter Preis für Wasser */
/* Preise übernommen aus obiger Aufgabenstellung */int Runterzaehlspeicher; /* damit wir am Ende eines Durchlaufs
die Änderung der Flaschen-Anzahl
berechnen können *//* Vereinbarung der Objekte Cola, Bluna, Wasser, Wahl
dabei wird die Anzahl und der Preis gespeichert.
das Objekt Wahl dient zur Verarbeitung im Durchlauf, da man
sonst für jedes Produkt einen speziellen Durchlaufalgorithmus
schreiben muss, wobei sich dieser jeweils nur immer in einem
Wort unterscheiden würde. Welches auch bei den anderen
Funktionen zutrifft, so dass bei einer Erweiterung jedes Mal
komplett neue Prozeduren/Funktionen erstellt werden muessen.
Wobei bei diesem Programm die Erweiterungen nur an ein paar
Stellen vorzunehmen sind, so dass ein hoechstmoeglicher Grad
an Effizienz des Programms realisiert worden ist. */struct sorte {
int anzahl;
double preis;
};
struct sorte cola, bluna, wasser, wahl;
/* schon an dieser Stelle wird der benoetigte Speicher-
platz fuer die Containerinhalte des Types Sorte geschaffen *//* Wir vereinbaren hier die Kasse, den Geldeinwurf und das
Wechselgeld. Es gibt hierbei jeweils eine Variable die
stellvertretend für die einzelnen Münzen steht. */
struct wgeld {
int eincent;
int zweicent;
int fuenfcent;
int zehncent;
int zwanzigcent;
int fuenfzigcent;
int eineuro;
int zweieuro;
};
struct wgeld kasse, geldeinwurf, rueckgeld;
/* schon an dieser Stelle wird der benoetigte Speicher-
platz fuer die Containerinhalte des Types Sorte geschaffen *//* Deklarations - Block - Ende
/*****************************************************************************//* void reset (void)
Diese Prozedur wird dann ausgeführt, wenn der Benutzer
die Rueckgabe seiner Muenzen fordert. setzt alle Werte des
eingeworfenen Geldes wieder auf 0, so dass keine Münze
mehr eingegeben sind! *//*Rückgabewert Name Parameter */
void reset (void) {geldeinwurf.eincent=0;
geldeinwurf.zweicent=0;
geldeinwurf.fuenfcent=0;
geldeinwurf.zehncent=0;
geldeinwurf.zwanzigcent=0;
geldeinwurf.fuenfzigcent=0;
geldeinwurf.eineuro=0;
geldeinwurf.zweieuro=0;rueckgeld = geldeinwurf;
}
/----------------------------------------------------------------------------/
/* Diese Funktion initialisiere hat keinen Rückgabewert, und
bekommt keine Parameter übergeben
es wird hiermit der Startzustand hergestellt*/void initialisiere (void) {
kasse.eincent = 50;
kasse.zweicent=50;
kasse.fuenfcent=50;
kasse.zehncent=20;
kasse.zwanzigcent=20;
kasse.fuenfzigcent=10;
kasse.eineuro=5;
kasse.zweieuro=5;cola.anzahl=ANZAHL;
bluna.anzahl=ANZAHL;
wasser.anzahl=ANZAHL;cola.preis=colapreis;
bluna.preis=blunapreis;
wasser.preis=wasserpreis;reset(); /* Aufruf der Funktion reset () */
}
/----------------------------------------------------------------------------/
/*Diese Funktion hat als Rückgabewert eine Gleitkommazahl
bekommt aber keine Parameter übergeben.
Diese Funktion berechnet uns den Wert der eingegebenen
Münzen, damit wir somit die Rückgeldberechnung in Angriff
nehmen können. */double wertgeldeinwurf (void) {
return (0.01geldeinwurf.eincent+
0.02geldeinwurf.zweicent+
0.05geldeinwurf.fuenfcent+
0.10geldeinwurf.zehncent+
0.20geldeinwurf.zwanzigcent+
0.50geldeinwurf.fuenfzigcent+
1geldeinwurf.eineuro+
2geldeinwurf.zweieuro);}
/* Abfrage von der Standardeingabe
gibt den eingegebenen Wert als Integer zurück
bekommt keine Parameter uebergeben
*/int eingabe (void){
int uebergabe;
/* Marke "anfang" wird hier gesetzt /
anfang:
printf("?= \a"); / \a ist ein Klingelzeichen */
scanf("%d", & uebergabe); /*einlesen eines Integer-Wertes */if ( (uebergabe >= 0) && (uebergabe <= 9) ) return uebergabe;
else {
printf("Falsche Eingabe\a\n");
sleep(LIFE_INTERVAL); /* friert kurz ein /
printf("\a"); / gibt Tonsignal aus */
goto anfang; /*es wird wieder nach oben gesprungen*/
};
}/----------------------------------------------------------------------------/
/* Muenzeinwerfen
realisiert den Vorgang des Muenzeinwerfens
hierzu wird der Nummernblock verwendet, da man nicht das realistische
Einwerfen simulieren kann
hat keine uebergebenen Parameter und hat keinen Rueckgabewert
*/void muenzeinwerfen (void) {
int abbruch;
abbruch=0;
do { /* solange der User nicht abbricht fuehre aus */switch (eingabe()) {
case 1: geldeinwurf.eincent++;break;
case 2: geldeinwurf.zweicent++;break;
case 3: geldeinwurf.fuenfcent++;break;
case 4: geldeinwurf.zehncent++;break;
case 5: geldeinwurf.zwanzigcent++;break;
case 6: geldeinwurf.fuenfzigcent++;break;
case 7: geldeinwurf.eineuro++;break;
case 8: geldeinwurf.zweieuro++;break;case 9: reset();break;
case 0: abbruch=1;break;
}}
while (abbruch != 1);
}/############################################################################/
/* Diese Funktion implementiert den Wählvorgang. Es wird ein Zeichen von
der Standardeingabe geholt, und anhand dieses Zeichen ordnet man die
Wahl der Sorte zu */void wahlsorte (void) {
int c ;
printf("Bitte geben Sie die gewuenschte Sorte ein! \n");
c=eingabe ();
Runterzaehlspeicher = c;switch(c) {
case 1: { wahl.anzahl = cola.anzahl;
wahl.preis=cola.preis;
printf("Cola gewaehlt\n");
break;}case 2: { wahl.anzahl = bluna.anzahl;
wahl.preis=bluna.preis;
printf("Bluna gewaehlt\n");
break;}case 3: { wahl.anzahl = wasser.anzahl;
wahl.preis=wasser.preis;
printf("Wasser gewaehlt\n");
break;}
}}
/--------------------------------------------------------------------------------/
/* Kontroll-Funktionen *//* Testroutine ob die gewählte Sorte vorhanden ist
Die Funktion hat keine übergebenen Parameter und hat als Rückgabewert
einen Integer Ausdruck, welcher in diesem Fall mit einem booleschen Ausdruck
gleichzusetzen ist, dabei gilt 1 fuer vorhanden und 0 fuer nicht vorhanden
*/int sortevorhanden (void) {
return ( (wahl.anzahl > 0) ? 1 : 0) ;
}
/----------------------------------------------------------------------------/
/* Diese Funktion hat keinen Rückgabewert, bekommt aber auch keine Parameter
übergeben. Diese Funktion testet ob der Nutzer des Automaten genügend
Geld eingeworfen hat */void genuggeld (void) {
while ((wertgeldeinwurf()) < wahl.preis) {
/* weniger Geld eingeworfen als gewaehlter Preis */
printf("Weiter Geld einwerfen!mit 0 beenden!\a\n");
muenzeinwerfen();
}}
/----------------------------------------------------------------------------/
/* Testet ob eine Rückgabe möglich ist, indem man die einzelnen Münzinhalte
der Rückgabemenge mit der den einzelnen Münzinhalte der Kasse
Die Funktion bekommt keine Parameter übergeben, er hat als Rückgabewert
einen Booleschen Ausdruck */int rueckgabemoeglich (void) {
if ( (rueckgeld.eincent <= kasse.eincent) &&
(rueckgeld.zweicent <= kasse.zweicent) &&
(rueckgeld.fuenfcent <= kasse.fuenfcent) &&
(rueckgeld.zehncent <= kasse.zehncent) &&
(rueckgeld.zwanzigcent <= kasse.zwanzigcent) &&
(rueckgeld.fuenfzigcent <= kasse.fuenfzigcent) &&
(rueckgeld.eineuro <= kasse.eineuro) &&
(rueckgeld.zweieuro <= kasse.zweieuro)) return 1 ;
else return 0;
}
/*********************************************************************************//* Diese Funktion hat keine uebergebenen Parameter hat aber als Rueckgabewert
einen Integer, den man in diesem Fall wieder als Booleschen Ausdruck
interpretieren kann, dabei steht 1 für der Automat enthaelt noch Flaschen,
und 0 sagt aus, dass der Automat keine Flasche mehr enthaelt. */int liquiditaet (void) {
return (((cola.anzahl == 0) && (bluna.anzahl==0) && (wasser.anzahl==0) ) ? 0 : 1);
}/############################################################################/
/* Ende der Deklaration der Kontroll-Funktionen */
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* Ausgabe-Funktionen *//* keinen Rückgabewert und auch keine übergebenen Parameter
Diese Funktion gibt den aktuellen Füllstand mit Geld (nach Münzen geordnet)
und Getränken (nach Sorten sortiert) aus. */void ausgabeaktuell(void) {
printf("\n"); /* gibt Trennzeile aus */
printf("Fuellstatus\n");
printf("%6d",cola.anzahl); printf("%10s","Cola\n");
/*s für String d für Double */
printf("%6d",bluna.anzahl); printf("%10s","Bluna\n");
printf("%6d",wasser.anzahl); printf("%10s","Wasser\n");printf("Kassenstand\n");
printf("%6d",kasse.eincent); printf("%20s","Ein cent\n");
printf("%6d",kasse.zweicent); printf("%20s","Zwei cent\n");
printf("%6d",kasse.fuenfcent); printf("%20s","Fuenf cent\n");
printf("%6d",kasse.zehncent); printf("%20s","Zehn cent\n");
printf("%6d",kasse.zwanzigcent); printf("%20s","Zwanzig Cent\n");
printf("%6d",kasse.fuenfzigcent); printf("%20s","Fuenfzig cent\n");
printf("%6d",kasse.eineuro); printf("%20s","Ein Euro\n");
printf("%6d",kasse.zweieuro); printf("%20s","Zwei Euro\n");printf("Rueckgeld\n");
printf("%6d",rueckgeld.eincent); printf("%20s","Ein cent\n");
printf("%6d",rueckgeld.zweicent); printf("%20s","Zwei cent\n");
printf("%6d",rueckgeld.fuenfcent); printf("%20s","Fuenf cent\n");
printf("%6d",rueckgeld.zehncent); printf("%20s","Zehn cent\n");
printf("%6d",rueckgeld.zwanzigcent); printf("%20s","Zwanzig Cent\n"); printf("%6d",rueckgeld.fuenfzigcent); printf("%20s","Fuenfzig cent\n");
printf("%6d",rueckgeld.eineuro); printf("%20s","Ein Euro\n");
printf("%6d",rueckgeld.zweieuro); printf("%20s","Zwei Euro\n");sleep(LIFE_INTERVAL);
/*realisiert eine kleine Zeitspanne zum Lesen der Informationen */}
//////////////////////////////////////////////////////////////////////////////
/* Erstausgabe zur Information bei der Benutzung des Users */
void erstausgabe (void) {
printf("****Getraenke-Automat****\n");
printf("Hinweise zur Muenzeinwurf\n");
printf("1 fuer 1cent\n");
printf("2 fuer 2cent\n");
printf("3 fuer 5cent\n");
printf("4 fuer 10cent\n");
printf("5 fuer 20euro\n");
printf("6 fuer 50cent\n");
printf("7 fuer 1euro\n");
printf("8 fuer 2euro\n");
printf("9 Rueckgabeknopf\n");
printf("0 Abbruch\n");
printf("\n");printf("Zur Wahl der Sorte :\n");
printf("1 Cola : ");
printf("%f",cola.preis);/* an dieser Stelle wird der vordefinierte Preis eingesetzt*/
printf(" Euro\n");
printf("2 Bluna : ");
printf("%f",bluna.preis);/* an dieser Stelle wird der vordefinierte Preis eingesetzt*/
printf(" Euro\n");
printf("3 Wasser : ");
printf("%f",wasser.preis);/* an dieser Stelle wird der vordefinierte Preis eingesetzt*/
printf(" Euro\n");
printf("\n");}
/----------------------------------------------------------------------------/
/* Berechnungs-Funktionen *//* Diese Funktion dient zur Berechnung des neuen Speicherzustandes des
Automaten. Keine Parameter werden übergeben , und auch keinen
Rückgabewert */void sorteaenderung (void) {
switch (Runterzaehlspeicher) {/* in Abhaengigkeit der gewählten Sorte /
case 1: cola.anzahl--;break; / dekrementiert die Anzahl der Colaflaschen /
case 2: bluna.anzahl--;break;/ dekrementiert die Anzahl der Blunaflaschen /
case 3: wasser.anzahl--;break;}/ dekrementiert die Anzahl der Wasserflaschen /
}
/----------------------------------------------------------------------------*//* Berechnet die Änderung der Kasse, wenn Rückgeld ausgegeben wird.
keinen Rückgabewert und keine übergebenen Parameter */void aenderungkasse(void) {
kasse.eincent = kasse.eincent + geldeinwurf.eincent;
kasse.zweicent = kasse.zweicent + geldeinwurf.zweicent;
kasse.fuenfcent = kasse.fuenfcent + geldeinwurf.fuenfcent;
kasse.zehncent = kasse.zehncent + geldeinwurf.zehncent;
kasse.zwanzigcent = kasse.zwanzigcent + geldeinwurf.zwanzigcent;
kasse.fuenfzigcent = kasse.fuenfzigcent + geldeinwurf.fuenfzigcent;
kasse.eineuro = kasse.eineuro + geldeinwurf.eineuro;
kasse.zweieuro = kasse.zweieuro + geldeinwurf.zweieuro;kasse.eincent = kasse.eincent - rueckgeld.eincent;
kasse.zweicent = kasse.zweicent - rueckgeld.zweicent;
kasse.fuenfcent = kasse.fuenfcent - rueckgeld.fuenfcent;
kasse.zehncent = kasse.zehncent - rueckgeld.zehncent;
kasse.zwanzigcent = kasse.zwanzigcent - rueckgeld.zwanzigcent;
kasse.fuenfzigcent = kasse.fuenfzigcent - rueckgeld.fuenfzigcent;
kasse.eineuro = kasse.eineuro - rueckgeld.eineuro;
kasse.zweieuro = kasse.zweieuro - rueckgeld.zweieuro;}
/******************************************************************************/
/*Berechnet uns die Anzahl der einzelnen Münzen die notwendig sind, um
dem Nutzer das Restgeld zurückzugeben
bekommt eine Fließkommazahl (double) uebergeben, hat aber keinen
Ruechgabewert */void rueckgeldberechnung (double zwischen) {
while (zwischen >= 2) {zwischen=zwischen-2;rueckgeld.zweieuro++;}
/* zaehle solange zweieuro hoch, wie die Differenz groeßer ist als 2 */
while (zwischen >= 1) {zwischen=zwischen-1;rueckgeld.eineuro++;}
/* zaehle solange eineuro hoch, wie die Differenz groeßer ist als 1 */
while (zwischen >= 0.5) {zwischen=zwischen-0.5;rueckgeld.fuenfzigcent++;}
/* zaehle solange fuenfzigcent hoch, wie die Differenz groeßer ist als 0.5 */
while (zwischen >= 0.2) {zwischen=zwischen-0.2;rueckgeld.zwanzigcent++;}
/* zaehle solange zwanzigcent hoch, wie die Differenz groeßer ist als 0.2 */
while (zwischen >= 0.1) {zwischen=zwischen-0.1;rueckgeld.zehncent++;}
/* zaehle solange zehncent hoch, wie die Differenz groeßer ist als 0.1 */
while (zwischen >= 0.05) {zwischen=zwischen-0.05;rueckgeld.fuenfcent++;}
/* zaehle solange fuenfcent hoch, wie die Differenz groeßer ist als 0.05 */
while (zwischen >= 0.02) {zwischen=zwischen-0.02;rueckgeld.zweicent++;}
/* zaehle solange zweicent hoch, wie die Differenz groeßer ist als 0.02 */
while (zwischen > 0) {zwischen=0;rueckgeld.eincent++;}
/* zaehle solange eincent hoch, wie die Differenz groeßer ist als 0 */}
/******************************************************************************/
/*Hat eine Gleitkommazahl als Rueckgabewert, bekommt aber keine
Parameter übergeben.
berechnet die Differenz zwischen eingegebener Münzmenge und Preis */double differenz (void) {
return (wertgeldeinwurf() - (wahl.preis));
}
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
/* Ende der Deklaration der Berechnungs-Funktionen /
/*****************************************************************************************//* Realisierung eines effezienten endlichen Automaten
zur Simulation eines Getraenke-Automaten*//* Der Prozedurdurchlauf hat keinen Rückgabewert und bekommt
keine Parameter übergeben. Dieser dient zur Realisierung eines
Ablaufes */void durchlauf (void) {
reset() ; /* Stellt Muenzeinwurf und Rueckgeld auf Null */
erstausgabe (); /*gibt Informationen aus */
if (liquiditaet() == 1 )
{
muenzeinwerfen (); /*es werden die Münzen vom Nutzer verlangt */
wahlsorte (); /*es wird die Sorte vom Nutzer abgefragt */if (sortevorhanden() != 0) /* wenn Sorte vorhanden /
{
genuggeld(); / verlangt solange Geld bis genug Geld eingeworfen wurde */
rueckgeldberechnung(differenz());
/*es wird Wechselgeld berechnet */if (rueckgabemoeglich() != 0) /* wenn wechseln moeglich ist */
{ aenderungkasse();
/* Kassenaenderungen werden ausgeführt */
sorteaenderung();
/* Bestand der gewaehlten Sorte wird dekrementiert /
}
else {
printf("Rueckgabe ist nicht moeglich!\n");
rueckgeld = geldeinwurf;
sleep(LIFE_INTERVAL);
}
}
else { printf("Sorte nicht mehr vorhanden!\n");
/*wenn Sorte nicht vorhanden Ausgabe */
rueckgeld = geldeinwurf;
/* es wird das eingeworfene Geld ausgeworfen/
}sleep(LIFE_INTERVAL);
ausgabeaktuell(); /*gibt die Daten aus*/
printf("\nHat der Benutzer noch einen Wunsch ?(1 fuer Neue Flasche/0 fuer Leergut)\n");}
else {
printf("Leider ist der Automat nicht mit Flaschen gefuellt\n");
}}
/*****************************************************************************************/
void beleergut (void) {
reset();
rueckgeld.zehncent++;
rueckgeld.fuenfcent++;
if (rueckgabemoeglich() != 0) /* wenn wechseln moeglich ist */
{ aenderungkasse();
/* Kassenaenderungen werden ausgeführt */
}
else {
printf("Rueckgabe ist nicht moeglich! Keine Annahme von Leergut!\n");
rueckgeld.zehncent=0;
rueckgeld.fuenfcent=0;
}
ausgabeaktuell();
printf("\nHat der Benutzer noch einen Wunsch ?(1 fuer Neue Flasche/0 fuer Leergut)\n");
}/* Ende der Deklaration der Funktionen/Prozeduren */
/---------------------------------------------------------------------------------------/
/* Hauptprogramm */int main (void) {
initialisiere(); /* Stellt den Automat beim Start ein */
hier:
durchlauf(); /* endlicher Automat wird ausgefuehrt */
goto abfrage;leergut:
beleergut(); /* Leergutannahme wird ausgeführt */
goto abfrage;abfrage: /* Entscheidung ob neue Flasche oder Leergutannahme*/
if (eingabe() == 1) goto hier;
else goto leergut;}
/*Programmabbruch mit STRG-C*/**
-
Was war nochmal deine Frage?
-
Crossposting!
Warum funzt es nicht unter MsVisualC++