TDM

Naja, Enumerations können auch Objekte als Typen enthalten (nur dass du wegen einem privaten Konstruktor keine zusätzlichen Objekte erzeugen kannst.) Hoffentlich hau ich jetzt nicht allzuviel zwischen Java und C# durcheinander.

public class MyClass { static const int ID_one = 1; static const int ID_two = 2; } public class Luncher{ void run() { ... int ID = obj.getID(); switch (ID) { case MyClass.ID_one: //... break; case MyClass.ID_two: //... break; //... } } :mod:

Zu viel Aufwand. Wenn du schon eine ID hast, dann kannst du die dann in einer Variable speichern und dann z.B. Folgendes machen: int ID = obj.getID(); switch (ID) { case MyClass.ID_one: //... break; case MyClass.ID_two: //... break; //... } Würd ich jedenfalls so meinen. Aber ist natürlich dir überlassen

Ich würde die Schritte mit einem Integer repräsentieren. Diese werden dann in einer Collection gespeichert. Durch die Methode doSchritt(int schritt) kannst du dann die einzelnen Schritte ausführen. Es ist nur die Frage, ob du Zahlen eingeben lässt oder Text als Schrittaufruf.

int restart; austauschen mit char restart; Damit man später auch im Fehlerfall sieht, dass man was falsches gemacht hat: #include <iostream> using namespace std; #define START_E_END -1 #define START_L_END -2 int calc(int, int); // Prototyp (Bekanntmachen der Funktion vor main) void main() { int start, end, sum; char restart; do { cout << "\n\n\tGeben sie bitte den Anfangswert ein!"; cin >> start; cout << "\n\n\t Geben Sie bitte den Endwert ein!"; cin >> end; sum = calc(start, end); //Funktion von heut früh aufrufen if (sum == START_E_END) { cout << "Summe gleich Ende" << endl; } else if (sum == START_L_END ) { cout << "Summe groesser Ende" << endl; } else { cout << "Summe:\t" << sum << endl; //Summe ausgeben } cout << "Nochmal ? (j/n):"; // Abfrage ob nochmal cin >> restart; // Einlesen // könnte man alternativ getch() oder getchar() machen } while(restart == 'j'); // prüfen ob j eingegeben wurde // bei mehr zeichen dann halt einen Array oder string nehmen } int calc(int start, int end) { int tmp = end-1; //die größte zu zählende Zahl int sum = 0; //Summer erstmal auf 0 setzen if (start == end) { return START_E_END; } else if (start > end) { return START_L_END; } else { do { // do-while = fussgesteuert sum += tmp; // summe = summe + tmp (beim ersten Mal entspricht das // summe = 0 + (end - 1)) } while ((--tmp)>(start)); // die nächstgrößte zu zählende Zahl setzen; // prüfen auf > start return sum; // Freude, weil return (Summe wird zurückgegeben) } }

und nochmal alles: #include <iostream> using namespace std; int calc(int, int); // Prototyp (Bekanntmachen der Funktion vor main) void main() { int start, end, sum; int restart; do { cout << "\n\n\tGeben sie bitte den Anfangswert ein!"; cin >> start; cout << "\n\n\t Geben Sie bitte den Endwert ein!"; cin >> end; sum = calc(start, end); //Funktion von heut früh aufrufen cout << "Summe:\t" << sum << endl; //Summe ausgeben cout << "Nochmal ? (j/n):" // Abfrage ob nochmal cin >> restart; // Einlesen // könnte man alternativ getch() oder getchar() machen } while(restart == 'j'); // prüfen ob j eingegeben wurde // bei mehr zeichen dann halt einen Array oder string nehmen } int calc(int start, int end) { int tmp = end-1; //die größte zu zählende Zahl int sum = 0; //Summer erstmal auf 0 setzen if ((start == end) || (start < end)) return sum; // vorher prüfen ob der Start // vor dem Ende liegt bzw. // ob start gleich ende // (deswegen hasse ich fussgesteuerte Schleifen) do { // do-while = fussgesteuert sum += tmp; // summe = summe + tmp (beim ersten Mal entspricht das // summe = 0 + (end - 1)) } while ((--tmp)>(start)); // die nächstgrößte zu zählende Zahl setzen; // prüfen auf > start return sum; // Freude, weil return (Summe wird zurückgegeben) }

hmm ich dachte der schreibt die Klasse um ich würde eher sowas machen wie: getParameter(int schritt) bzw. doSchritt(int schritt) und getAusgabe(int Schritt) dann kannst du auch dein Switching auch benutzen. Vielleicht denk ich auch grad vollkommen in die verkehrte Richtung

über die main folgendes schreiben (wenn noch nicht da) #include <iostream> using namespace std; Die Funktion calc musst du natürlich auch mit in die cpp-Datei schreiben.

Naja, aber die Schritte bleiben doch gleich oder stellst du dann die neuen Funktionen in der Ausgabe zur Verfügung ? Es gibt sowas wie Add(funktion) ? Die implementiert eine Funktionkomplet mit Methodenrumpf und so ? :eek Ich glaub ich sollte auch mal C# lernen... Dann brauch ich mich nicht wie bei Java und C++ mit Kompilieren rumschlagen.

hier mal die main: void main() { int start, end, sum; int restart; do { cout << "\n\n\tGeben sie bitte den Anfangswert ein!"; cin >> start; cout << "\n\n\t Geben Sie bitte den Endwert ein!"; cin >> end; sum = calc(start, end); //Funktion von heut früh aufrufen cout << "Summe:\t" << sum << endl; //Summe ausgeben cout << "Nochmal ? (j/n):" // Abfrage ob nochmal cin >> restart; // Einlesen // könnte man alternativ getch() oder getchar() machen } while(restart == 'j'); // prüfen ob j eingegeben wurde // bei mehr zeichen dann halt einen Array oder string nehmen }

Ich für meinen Teil, würde hier lieber Parameter = 5 (Integer) nehmen. Sekunden kannst du dann immer noch dazudichten. Ansonsten stellt sich für mich die Frage, warum du die Sachen nicht als Variablen implementierst ? Text ausgaben ect. funktionieren ja auch so. btw: eine Klasse für einzelne Schritte halte ich nicht für effizient

Aus der Kalten würde ich sagen, dass du einfach ein Interface benutzt, welches eine Funktion implementiert, die dann jede Klasse besitzt. Diese leitet dann einfach an die entsprechende Funktion weiter oder so. Dann kannst du dir Switching auch sparen. Müsst ich mir aber genauer anschauen.

Also ich hab nochmal nachgeschaut und Objekte funktionieren wirklich nicht. Switch Statement & Objects - .NET C# Also entweder du schreibst selber eine Type-Safe-Enumeration, gehst über foreach oder machst ein schönes if-else. Was willst du eigentlich prüfen mit dem Switch ?

Meines Wissens können unter C# keine Objekte für das 'Switching' verwendet werden. Du kannst ja eine eindeutige Variable für jedes Objekt erzeugen lassen. (Z.B. Hashcode oder eben wie bereits erwähnt den Namen) und diese dann prüfen. Eine Enumeration würde hier glaub ich auch gehen.

Frühmorgensübungen sind was Tolles int calc(int start, int end) { int tmp = end-1; //die größte zu zählende Zahl int sum = 0; //Summer erstmal auf 0 setzen if ((start == end) || (start < end)) return sum; // vorher prüfen ob der Start // vor dem Ende liegt bzw. // ob start gleich ende // (deswegen hasse ich fussgesteuerte Schleifen) do { // do-while = fussgesteuert sum += tmp; // summe = summe + tmp (beim ersten Mal entspricht das // summe = 0 + (end - 1)) } while ((--tmp)>(start)); // die nächstgrößte zu zählende Zahl setzen; // prüfen auf > start return sum; // Freude, weil return (Summe wird zurückgegeben) PS: den Rest schaffst du hoffentlich allein. :floet:

Naja, ich dachte ja nicht daran c_str() als Buffer einzusetzen... eher sowas in der Art: char buffer[20]; int zahl=123; _itoa(zahl, buffer, 10); string str = string(buffer); oder so ähnlich... hmm... wobei - wenn _itoa auch einen char * zurückgibt... int zahl=123; string str = string(_itoa(zahl, new char[20],10)); ... müsste ja auch das gehen. Aber da es nicht zum Standard gehört, kann man es glaub ich eh für sauberen Code vergessen. Edit: ahh, ok, jetzt versteh ich was du meintest. c_str() darf man natürlich nicht als Parameter verwenden. :hells:

Dafür gibt es ja die Funktion c_str(). Edit: Ok, da war ja noch eine Seite, die ich nicht gesehen hab.

ok, ich weiß wie du es meintest: struct SValues_t { int m_nKey; string m_lpeSName; string m_lpeFName; string m_lpeTel; string m_lpeSG; int m_nCount; } m_seMembers;

Hab ich doch, damit ich auf die Variablen zugreifen kann: [B]struct[/B] { int m_nKey; string m_lpeSName; string m_lpeFName; string m_lpeTel; string m_lpeSG; int m_nCount; } [B]m_seMembers[/B]; Oder wo meinst du ?

Neben Klotzkopfs Vorschlag gibt es da noch die Funktionen _itoa(int, char*, int) und _ftoa(...)

Hallo, ich habe das Problem, dass ich eine etwas ... "merkwürdige" Fehlermeldung bei folgender Klasse bekomm class CUser { public: BOOL p_bSetSName(const string& p_lpSName); void p_save(); CUser(); ~CUser(); static CUser* s_p_opagetUsers(); static void s_p_setFileProperties(const SFileProperties_t &p_sNewFileProperties); static int s_p_ncCountUsers(void); private: void m_writeFName(const string&p_lpKey); void m_writeKey(const string&p_lpKey); void m_writeSG(const string&p_lpKey); void m_writeSName(const string& p_lpKey); void m_writeTel(const string&p_lpKey); static SFileProperties_t s_m_seFileProperties; struct { int m_nKey; string m_lpeSName; string m_lpeFName; string m_lpeTel; string m_lpeSG; int m_nCount; } m_seMembers; }; Kann mir jemand sagen, woran das liegt, dass ich keine string-Objekte in einer internen Struktur verwenden kann ? Sobald ich char* nehm, geht es jedenfalls (ich will mir aber die Pointerarbeit ersparen.)

eben drum

Wie gesagt, Pseudocode... strings würd ich für sowas nicht verwenden. Lieber ein Char(-Array) und dann auf (cArray[0] == 'j' ) prüfen. Edit: ich seh grad - da fehlt so und so eine Schleife...: int main() { //int müsste hier auch gehen... int nEnd = 0; do { abfrage(); switch (zahl) { case 1: primProg (); break; case 2: sekProg (); break; default: cout << "Ende?:\t" cin >> nEnd; break; }while(nEnd != 'j'); return 0; }

ihh globale Variablen... ich würd das so machen: int main() { abfrage(); switch (zahl) { case 1: primProg (); break; case 2: sekProg (); break; default: string lpEnd; cout << "Ende?:\t" cin >> lpEnd; if (lpEnd == "ja") return 0; break; } return 0; } Achtung, Pseudocode - der soll nur zum Denken anspornen. void exitProg () {cout<<"Moechten Sie das Programm wirklich beenden?"<<endl; cin>>antwort; // Es konnte kein Systemoperator gefunden werden, der einen rechtseitigen Operanden vom Typ 'std:string' akzeptiert (oder keine geeigntete Konvertierung möglich) if antwort==("ja") //systemfehler bezeichner 'antwort'exit(); else abfrage() // ungültiges else ohne dazugehöriges if }

return 0; oder exit(0); für "hartes" Beenden Edit: Wenn es eine Win32-Anwendung ist.