hallo zusammen!
habe ein problem, ich muss als studienleistung ein programm schreiben mit
folgender aufgabenstellung:
--------------------------------------------------------------------------------------------------------------------------
Berechnung des Werts eines logischen Ausdrucks
Eingabe (in Hauptprogramm):
Wahrheitswerte Wahr/Falsch in der Form W,w,F oder f
Verknüpfungszeichen:
- Und (Zeichen *),
- inklusives Oder (Zeichen +)
- exklusives Oder (Zeichenfolge xor, XOR oder auch Mischung
Klein-/Großbuchstaben)
Behandlung mit folgender Hierarchie:
*/xor höher als + (die beiden Operatoren * und xor in gleicher Vorrangstufe,
d.h. Abarbeitung von links nach rechts)
Leerzeichen beliebig (auch innerhalb xor)
max. Länge etwa 80 Zeichen (Eingabe als eine Zeichenkette), innerhalb dieser
Länge beliebig viele Operatoren und zugehörige Operanden.
Gesatprogramm als Schleife; Ende bei Eingabe eines $-Zeichens.
----------------------------------------------------------------------------------------------------------------------------
habe hier jetzt ein programm, das diesen zweck erfüllt. könnte man noch was
verbessern (siehe kommentare im text)?
----------------------------------------------------------------------------------------------------------------------------
*********** Berechnung des Wertes eines logischen Ausdrucks ********/
#include <iostream.h>
const int max=80;
//hier werden die Funktionen deklariert
int umwandlung(char zeile[max]);
int loeschBlanks(char zeile[max]);
int logischesUnd(char zeile[max]);
int logischesOderXor(char zeile[max]);
int main()
{
char zeile[max];
cout << "Dieses Programm berechnet einen korrekten logischen Wert," <<
endl;
cout << "der in folgenden Zeile eingegeben werden kann." << endl;
cout << "Sie koennen es durch Eingabe eines -$- beenden." << endl;
//die Schleife fuehrt das programm aus,
//bis ein $ eingegeben wird
while(zeile[0]!= '$') {
cout << "Bitte geben sie einen korrekten logischen Wert in die zeile
ein:" << endl;
//einlesen der Zeile
cin.getline(zeile,sizeof(zeile));
umwandlung(zeile);
cout << "Hier wird die eingegebene Zeile in eine einheitliche Form
umgewandelt" << endl;
cout << zeile << endl;
loeschBlanks(zeile);
cout << "Hier werden alle Leerzeichen entfernt" << endl;
cout << zeile << endl;
logischesUnd(zeile);
cout << "Hier werden die Werte die mit und verknüpft wurden ermitelt" <<
endl;
cout << zeile << endl;
logischesOderXor(zeile);
cout << "Hier werden nun noch die Werte die mit xor bzw oder vernüpft
wurden ermitelt" << endl;
cout << zeile << endl;
if (zeile[0] == '1')
cout << endl << "Der eingegebene Wert der Zeile war WAHR " << endl <<
endl<< endl;
if (zeile[0] == '0')
cout << endl << "Der eingegebene Wert der Zeile war FALSCH " << endl <<
endl<< endl;
if (zeile[0] == '$')
cout << endl << "Abbruch durch den Benutzer" << endl << endl<< endl;
//anmerkung: diese bedingung findet einige Fehler aber nicht alle.
//Fehler wie: fer for w*wghghg werden hier nicht erkannt
if (zeile[0] != '$' && zeile[0] != '1' && zeile[0] != '0')
cout << endl << "Sie haben einen fehlerhaften zeile eingegeben!" << endl <<
endl<< endl;
}
return 0;
}
//hier werden die Funktionen definiert
//Schreibe logischen zeile in einheitliche Form um, wichtig, damit die
//folgenden Schleifen die Operatoren erkennen
int umwandlung(char zeile[max]) {
int zeichen;
zeichen = 0;
while (zeichen!=max)
{
if (zeile[zeichen] == 'f' || zeile[zeichen] == 'F')
zeile[zeichen] = '0';
if (zeile[zeichen] == 'w' || zeile[zeichen] == 'W')
zeile[zeichen] = '1';
if (zeile[zeichen] == 'X')
zeile[zeichen] = 'x';
if (zeile[zeichen] == 'O')
zeile[zeichen] = 'o';
if (zeile[zeichen] == 'R')
zeile[zeichen] = 'r';
++zeichen;
}
return zeile[max];
}
//entferne alle blanks aus der Zeile
int loeschBlanks(char zeile[max]) {
int zeichen, kopieZeichen;
for (zeichen=0; zeichen!=max; ++zeichen)
{
if (zeile[zeichen] == ' ')
{for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+1];
zeichen=0;}
}
return zeile[max];
}
// zunächst das "und", da es höherrangig als oder und xor ist bekommt es
// eine eigene Schleife und wird zuerst ausgewertet
int logischesUnd(char zeile[max]) {
int zeichen, kopieZeichen;
for (zeichen=0; zeichen!=max; ++zeichen)
{
if (zeile[zeichen] == '*' )
{if (zeile[zeichen-1] == '1' && zeile[zeichen+1] == '1')
{zeile[zeichen-1] = '1';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+2];
zeichen=0;
}
if (zeile[zeichen-1] == '0' || zeile[zeichen+1] == '0' )
{zeile[zeichen-1] = '0';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+2];
zeichen=0;
}
}
}
return zeile[max];
}
// nun das "oder", das oder und das xor können in eine gemeinsame
//schleife berechnet werden
int logischesOderXor(char zeile[max]) {
int zeichen, kopieZeichen;
for (zeichen=0; zeichen!=max; ++zeichen)
{
if (zeile[zeichen] == '+' )
// "oder"
{if (zeile[zeichen-1] == '1' || zeile[zeichen+1] == '1')
{zeile[zeichen-1] = '1';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+2];
zeichen=0;
}
if (zeile[zeichen-1] == '0' && zeile[zeichen+1] == '0' )
{zeile[zeichen-1] = '0';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+2];
zeichen=0;
}
}
else {
//nun noch das "xor"
if (zeile[zeichen] == 'x' && zeile[zeichen+1] == 'o' &&
zeile[zeichen+2] == 'r')
{if (zeile[zeichen-1] == '1' && zeile[zeichen+3] == '0')
{zeile[zeichen-1] = '1';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+4];
zeichen=0;
}
if (zeile[zeichen-1] == '0' && zeile[zeichen+3] == '1')
{zeile[zeichen-1] = '1';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+4];
zeichen=0;
}
if (zeile[zeichen-1] == '0' && zeile[zeichen+3] == '0' )
{zeile[zeichen-1] = '0';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+4];
zeichen=0;
}
if (zeile[zeichen-1] == '1' && zeile[zeichen+3] == '1' )
{zeile[zeichen-1] = '0';
for (kopieZeichen=zeichen; kopieZeichen!=max; ++kopieZeichen)
zeile[kopieZeichen] = zeile[kopieZeichen+4];
zeichen=0;
}
}
}
}
return zeile[max];
}
---------------------------------------------------------------------------------------------------
