[cybeegirl]

Huhu ihr Lieben,

Habe ein einfaches Shell App geschrieben, das ich selber auskommentieren soll um es bei der MüPrf zu erklären ...

Meine Frage ist nu, ob es soweit auskommentiert um es zu verstehen (bzw fehler enthalten sind)

Es handelt sich um C++ Code geschrieben unter VS2008 (C++99)

// sc.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

/*Globale Variablen*/

	/*Eingabe Variablen*/
	int z1;
	int z2;
	char oA;
	/*Meldungen & Warnungen*/
	string note		= ("------------------\nRechnung: ");
	string note1	= ("Achtung nur +-*/ erlaubt");
	string note2	= ("Magst bitte die ");
	string note3	= (" Zahl eingeben!\n");
	string note4	= ("------------------");
	/*Fehlermeldungen*/
	string err2	 =  ("Derzeit werden nur Ganzzahlen berechnet!");
	string err1 = ("Es wurde was falsches oda nix eingegeben");	

class ScTst //ShellCalcTest 
{
// Von Main aus zugreifbare Funktionen und Methoden
public:
	/*-----Fehlerprüfung-----*/
	static void errMethod1()
	{
				
		if(cin.fail())
		{
			cout<<err1<<endl;			
		}
	}
	/*-----Ein Ausgabe Block-----*/

	static void Ganzzahlen()
	{
	//Initialisierung ProgHead

	//Ausgabe Körper
	/*-----Ausgabe UI ------*/
	cout<<"Shell Calc\n"<<endl; // Titel
	cout<<"Ganzahlen berechnen\n"<<endl;
	cout<<note2<<"erste"<<note3<<endl; //Aufforderung Erste Zahl
	cin>>z1; // Eingabe Stream der ganzzahl z1
	ScTst::errMethod1(); //Fehlerprüfung der Eingabe
	cout<<note2<<" Operation eigeben"<<endl;
	cin>>oA; // Eingabe Stream
	ScTst::errMethod1();	
	cout<<note2<<"naechste"<<note3<<endl;

	cin>>z2;
	ScTst::errMethod1();
	cout<<note4<<endl; //Meldung Unterteilungs Striche

	//angezeigte ergebnisse für ganzzahlen, integer
	/*Berechnuns Blöcke*/
	int ergebnis1 = z1 + z2;
	int ergebnis2 = z1 - z2;
	int ergebnis3 = z1 * z2;
	int ergebnis4 = z1 / z2;
	char oAb; //globale variable wird übergeben
	oAb = oA;//eingegebener Wert für Operation wird übergben
	switch (oAb)//bezeichner der operative wird in schleife verwendet
		{
			// Addition
			case ('+')://bei angegebenen zeichen berechnungs block ausführen
				{
				cout<< note << z1 << " + " << z2 << " = " << ergebnis1 <<"\n" <<endl;//Ereignis mit vorangeganger Eingabe wieder geben
				}
			break;

			case ('-'):
				{
					cout << note << z1 << " - " << z2 << " = " << ergebnis2 <<"\n"<<endl;
				}
			break;

			case ('*'):
				{
					cout << note << z1 <<" * "<< z2 << " = " << ergebnis3 <<"\n"<<endl;
				}
			break;

			case ('/'):
				{
					cout << note << z1 << " / " << z2 << " = " << ergebnis4 <<"\n"<<endl;
				}
			break;
			default:
				{
					cout<<"fehlerhafte Eingabe"<<endl;
				}
				
		}
	system("Pause"); //anzeige des ergebnisses anzeigen
	ScTst::Main(); //zurück zur Hauptmethode der Klasse ScTst
	}
	static void Main()
	{
		system("cls"); //leeren des bildschirms
		ScTst::Ganzzahlen(); //methode erneut aufrufen
	}
};
int _tmain(int argc, _TCHAR* argv[])
{
	ScTst::Main(); //methode aufrufen	
}

Thx 4 Feedback

Eure Cybeegirl

[harbok]

Ich finde die Formatierung etwas unglücklich gewählt, so daß es schwer fällt, das zu lesen. Das ist aber auch meist eine Frage der persönlichen Präferenz bzw. Gewohnheit.


Ist es denn ok, dass Du den windowsspezifischen Kram in dem Code behältst?

[gosha16]

Kannst du die ganzen Globalen Variablen erklären?

[haze303]

string err1 = ("Es wurde was falsches oda nix eingegeben");

Ich würde das ändern in: "Es wurde etwas falsches oder nichts eingegeben."

Und gewöhne dir am besten gleich noch das "oda", "aba" und so weiter ab. Das wirkt total unseriös und unprofessionell - wirklich ganz ganz schlimm.

Ansonsten schließe ich mich harbok an, dass die Formatierung etwas unübersichtlich ist und das (unter anderem) ClearScreen nur unter Windows funktioniert.
Es ist dein Stil und wenn es keine Noten auf die Formatierung geben sollte, musst du es ja nicht unbedingt ändern, solang das Programm ansich funktioniert.

Viele Grüße,
haze303

[harbok]

Ich meinte primär TCHAR und die stdafx.h, die für einen Neuling reichlich schwer zu erklären wären. Die "Standard" main( ) ist nun mal eine andere.


Aber meine Anmerkungen zum Inhalt:

	int z1;
	int z2;

Sprechliche Variablen heisse nicht z1 und z2, sondern in diesem Fall operator1 und operator2, da sie genau das sind: Operatoren für ein Rechenprogramm.
Wenn Du die ungarische Notation wählen möchtest, wären die korrekten Namen für diese Variablen "nOperator1" und "nOperator2". Mit z1 und z2 kann niemand etwas anfangen.

	string note		= ("------------------\nRechnung: ");
	string note1	= ("Achtung nur +-*/ erlaubt");
	string note2	= ("Magst bitte die ");
	string note3	= (" Zahl eingeben!\n");
	string note4	= ("------------------");

Du kannst daraus einen string machen und es ist immer gut, wenn man bei Hochdeutsch und ganzen Sätzen bleibt, da das "Magst" leider nicht dazu zählt, würde ich es streichen. Hier wäre ein: "Achtung: Es sind nur +-*/ Operationen möglich\nBitte die Zahl eingeben:\n-------------------" neutraler und sachlicher.

	string err1 = ("Es wurde was falsches oda nix eingegeben");

Wie mein Vorredner schon sagte, ist kiddie chatslang inakzeptabel. Das "was" ist ebenfalls kein Hochdeutsch, sondern ein verschlucktes "etwas" und das "nix" ersetzt man besser durch ein "nichts". "Falsches" und "Nichts" würde in diesem Fall ausserdem gross geschrieben werden.

class ScTst //ShellCalcTest 
{
// Von Main aus zugreifbare Funktionen und Methoden
public:

Klassennamen sollten sprechlich sein. Niemand weiss in zwei Monaten, was die Klasse ScTst denn macht.
Der Satz zur Sichtbarkeit ist in diesem Zusammenhang vollkommen korrekt, aber nicht allgemeingültig. Public ist eine öffentliche Sichtbarkeit, d.h. diese Methoden sind nicht nur von main, sondern von jedem zugänglich.
Übrigens ist der Term "Funktionen" in diesem Zusammenhang nicht korrekt, da Du (sollte ich nichts übersehen haben) nur Prozeduren deklarierst und definierst. Eine Funktion liefert immer einen Wert zurück. Zudem spricht man in der OOP für gewöhnlich nur von den Methoden einer Klasse.

oAb = oA;//eingegebener Wert für Operation wird übergben
switch (oAb)//bezeichner der operative wird in schleife verwendet
		{

Hier gibt es einen Tippfehler im oberen Kommentar und die switch Anweisung ist mißverständlich beschrieben. Es handelt sich um eine Fallunterscheidung und nicht um die Verwendung einer Schleife.

system("Pause"); //anzeige des ergebnisses anzeigen
ScTst::Main(); //zurück zur Hauptmethode der Klasse ScTst

Der Kommentar "Ergebnis anzeigen" ist beim Aufruf des Betriebssystembefehls "Pause" leider sehr fehl am Platze, denn das hat nichts miteinander zu tun und die Zeile darunter ist ein echter Fehler: Dort geht es nicht zurück zur Hauptfunktion, sondern diese wird erneut aufgerufen. Das ist ein immenser Unterschied, denn die Hauptfunktion selbst ruft diese ja auch wieder auf und das fortwährende gegenseitige Aufrufen ohne je zu beenden führt irgendwann zu einem StackOverflow und man verliert die ganze Zeit konstant Speicher.
Hier wäre eine Ausbesserung des Programmfehlers sicherlich ratsam, da so ein Fehler natürlich eine tolle Gelegenheit ist, fiese Fragen in einer mündlichen Prüfung zu stellen.

int _tmain(int argc, _TCHAR* argv[])

Wie oben schon kurz erwähnt: Du solltest wissen, was TCHAR denn eigentlich ist. Das ist kein Standard C/C++ und lädt natürlich auch zu tollen Rückfragen ein.


Ansonsten ist es ganz ok. Der Programmierstil lässt noch klar erkennen, dass der Programmierer eher unerfahren ist, aber das wäre ja auch wahrscheinlich sehr seltsam, wenn Du mit einem perfekt geschliffenen Programm aufwarten würdest. Für mündliche Prüfungen kann ich Dir den Tipp geben, das Programm vorher mal irgendwem zu erklären, der vielleicht auch Rückfragen stellen kann. Am besten zwei, drei Mal - dann bist Du bei der eigentlichen Prüfung viel flüssiger und das wirkt immer kompetent

[haze303]

Wie mein Vorredner schon sagte, ist kiddie chatslang inakzeptabel. Das "was" ist ebenfalls kein Hochdeutsch, sondern ein verschlucktes "etwas" und das "nix" ersetzt man besser durch ein "nichts". "Falsches" und "Nichts" würde in diesem Fall ausserdem gross geschrieben werden.

Das habe ich total unterschlagen bzw. überlesen. "Flasch" und "Nichts" wird in diesem Fall in der Tat groß geschrieben. Dein ganzer Post ist eine tolle Korrektur und Hilfestellung von deiner Seite.

Viele Grüße,
haze303

[cybeegirl]

Hi,


dafür liebe ich dieses Board, klares ausdrucksstarkes und tiefgründiges Feedback, das mein ich ernst.
Werde die aufgezeigten Patzer beherzigen und entsprechend noch Hintergrundwissen (TCHAR) beilesen, damit ich mich da net lächerlich mache. *zitter*

//anzeige des ergebnisses anzeigen

huch da fehlte noch was ^^

//*Pausieren des Programms zum Anzeigen des Ergebnisses

Vielen Dank ihr Lieben

Eure Cybeegirl

[gosha16]

Oben das wurde wohl falsch verstanden.
Wenn ich in böser Programmierenlehrer wär würde ich folgendes fragen:
"Sie benutzen hier eine Menge globaler Variablen die nur in der Klasse verwendung finden. Warum sind diese Variablen Global?"

[cybeegirl]

Dann würde ich sagen:

"sie wurden deshalb global deklariert, damit sie von überall zugreifbar sind
wenn ich sie brauche. Da die Möglichkeit erhalten bleiben soll, den Informationskörper bzw die Fehlermeldung auch in andere Klassen mit einzubauen.
In Späteren Klassen die der gleichen Variablen oder Zeichenfolgen bedürfen bräuchte ich nicht unnötig wieder eine Variable oda ZeichenFolge deklarieren
Ansonsten gibt es keinen Grund diese global zu setzen."

[harbok]

Argumentier lieber damit, dass das Programm in diesem Fall damit übersichtlicher gestaltet ist und Du bei mehreren Klassen natürlich soweit nur möglich auf globale Variablen verzichten wirst, da sie zu erheblichen Problemen führen und in der objektorientierten Programmierung aus gutem Grunde kaum noch eine Rolle spielen und ihre Verwendung verpönt ist. Eine Ausnahme stellen dabei zeitkritische Systeme dar.


Die dann kommende Rückfrage, ob Du ein solches erhebliches Problem benennen kannst, beantwortest Du dann mit:

Die Verwendung globaler Variablen ist eine grosse und oftmals schwer zu findende Fehlerquelle. In grossen Projekten werden die globalen Variablen sehr schnell unübersichtlich und es kommt zu Überlagerungen oder funktionalen Entfremdungen, wenn viele Entwickler an einem Programm arbeiten. In Programmen mit parallel ausgeführten Programmteilen führen globale Variablen auch oftmals zu race conditions, die sehr schwer zu debuggen sind und eine sichere Threadsynchronisation erfordern.

[urga]

dann würde ich antworten, global variablen sind trotzdem baba. großes baba!

wenn man die überall verfügbar braucht, dann kann man sie in einer eigenen fehlerklasse kapseln.

[urga]

sag ich doch, globals sind baba

und das warum einem anfänger in einem posting zu erklären halte ich schlicht für unmöglich.

[cybeegirl]

Vielen Vielen Dank, für Eure Mühen und die Zeit :-)

Das war sehr lieb von Euch und es hat mir den entsprechenden "HintKick" gegeben meine Auslegung hinsichtlich global deklarierten Variablen zu überdenken.

Faulheit zahlt sich letztendlich doch net aus - wie war :-)

Deshalb habe ich sie letztendlich einfach rausgelassen.

P.S.: hatte gar net damit gerechnet, dass sich wer meinem salat anvertraut