Klotzkopp

Wie gesagt, es ist nicht festgelegt, welche Member die FILE-Struktur hat. Na sicher. Bedenke aber, dass du laut Aufgabenstellung kein Array benutzen darfst

Die Funktion gets liest von der Standardeingabe und schreibt in den Puffer, den du ihr übergibst. Warum sollte beim zweiten scanf-Aufruf das erste Zeichen nochmal gelesen werden?

Ich kann dir ein wenig Arbeit ersparen: Soweit ich weiß, gibt es keinen portierbaren Weg, mit Standard-C die in einem Eingabestream gepufferten Daten zu entfernen, ohne dass das blockiert, wenn gar keine drin sind. Wo hast du das denn her? Das sieht ja abenteuerlich aus. Der Standard schreibt nicht vor, dass die FILE-Struktur irgendwelche bestimmten Member haben muss. FILE sollte für den Entwickler opak sein, ein FILE* ist nur ein Handle. Außerdem halte ich es für extrem gefährlich, in einen von der C-Runtime verwalteten Puffer zu schreiben. Ich würde das so machen: void reverse() { char c; scanf( "%c", &c ); if( c != '\n' ) reverse(); printf( "%c", c ); }[/code]

Ist genauso unportierbar. Rewind muss nur auf solchen FILE* funktionieren, die Positionierungsanfragen unterstützen. Pipes und Terminals gehören üblicherweise nicht dazu. Die Verwendung von getch und conio.h ist auch nicht portierbar.

Das geht nicht, weil Variablen (wie ich bereits geschrieben habe) nur in dem Block gültig sind, in dem sie deklariert wurden. Deine Variablen würden dann außerhalb deiner Initialisierungsfunktion gar nicht existieren.

Nur, wenn du dieser Funktion die zu initialisierenden Variablen übergibst. Und weil die Funktion die Variablen dazu verändern muss, musst du sie "by reference" übergeben, in C also als Zeiger. Warum initialisierst du die Variablen nicht gleich bei der Deklaration?

Das ist auch so beabsichtigt. Variablen sind in C nur innerhalb des Blocks sichtbar, in dem sie definiert sind. Und bevor du fragst: Globale Variablen sind keine Lösung für dieses Problem, sondern ein manchmal notwendiges Übel. Und bitte mach das hier nicht zu deinem persönlichen Supportthread. Ein Thema - ein Thread. Wenn du noch eine Frage zu einem anderen Thema hast, mach bitte einen neuen Thread auf.

Der Exitcode 0 signalisiert üblicherweise, dass alles in Ordnung war.

Doch, du musst immer noch den operator[] implementieren, weil du von std::vector nicht erben sollst. Das könnte so aussehen: class CMatrix { private: vector<vector<double> > mat; public: CMatrix(int z, int s, double wert); //parametrisierter Konstruktor CMatrix(int z, int s); //parametrisierter Konstruktor int getLines(void) const;//gibt die Zeilenanzahl zurueck int getCols(void) const; //gibt die Spaltenanzahl zurueck const vector<double>& operator[] (int i) const;//prueft den Indexwert auf Gueltigkeit vector<double>& operator[](int i);//prueft den Indexwert auf Gueltigkeit CMatrix& operator+=(const CMatrix&);//Addition zweier Matrizen und Zuweisung void print() const; //Bildschirmausgabe void setWert(int z, int s, double WertTmp);//traegt Wert an bestimmte Stelle in Matrix ein double sum(void) const; //bildet Summe der Matrix double getWert(int z, int s) const; //gibt Wert an bestimmter Stelle in Matrix zurueck }; CMatrix::CMatrix(int z, int s, double wert) : mat( z, vector<double>( s, wert ) ) { } CMatrix::CMatrix(int z, int s) : mat( z, vector<double>( s ) ) { } int CMatrix::getLines(void) const { return mat.size(); } int CMatrix::getCols(void) const { return mat[0].size(); } vector<double>& CMatrix::operator[](int i) { return mat.at(i); } const vector<double>& CMatrix::operator[](int i) const { return mat.at(i); } CMatrix& CMatrix::operator+=(const CMatrix& m) { if (getCols() == m.getCols() && getLines() == m.getLines() ) { for (int i = 0; i < getLines(); ++i) { for (int j = 0; j < getCols(); ++j) { mat[i][j] += m.mat[i][j]; } } } return *this; } void CMatrix::print() const //Bildschirmausgabe { for (int i = 0; i < getLines(); i++) { for (int j = 0; j < getCols(); ++j) { cout << mat[i][j] << " "; } cout << endl; } } void CMatrix::setWert(int z, int s, double WertTmp) { mat[z][s] = WertTmp; //und Werte kopieren } double CMatrix::sum(void) const { double sum = 0.0; //Wert zurueck setzen for(size_t i = 0; i < mat.size(); i++) { sum = accumulate( mat[i].begin(), mat[i].end(), sum ); } return sum; } double CMatrix::getWert(int z, int s) const { return mat[z][s]; }[/code] Für accumulate brauchst du <numeric>.

Das Problem ist, was Guybrush Threepwood bereits erwähnt hat. CMatrix erbt von CZeile, was totaler Blödsinn ist. Damit enthält jedes CMatrix-Objekt ein CZeile-Objekt. Da CZeile aber keinen sauberen Default-Konstruktor hat, bleibt der z-Member dieses Objekts uninitialisiert. Und wenn ein CMatrix-Objekt zerstört wird, wird auch der Basisklassendestruktor ausgeführt. Der ruft dann delete auf einen unitialisierten Zeiger auf -> Peng. Übrigens, CZeile braucht auch Copykonstruktor und Copy-Zuweisungsoperator. Und überhaupt wäre das ganze mit std::vector viel, viel einfacher.

Nein, b ist hier ein int. Bedanke dich bei der seltsamen Deklarationssyntax.

Das sieht schon besser aus. Allerdings würde ich den Umweg für Wert < 1 weglassen - schlimmstenfalls wird eben unten mit 0 multipliziert, da kommt dasselbe heraus. Und schließlich würde ich zuerst die additiven Zuschläge ermitteln, und danach die multiplikativen, weil sie auch in dieser Reihenfolge in der Aufgabenstellung stehen. Dann kommt nämlich bei bestimmten Kombinationen etwas Anderes heraus.

Ist denn jeder Mitarbeiter entweder Führungs- oder Halbtagskraft? Dein PAP lässt nicht zu, dass jemand keines von beiden ist - oder beides.

Das sollte schon passen, denn die Winkelfunktionen haben da an der passenden Stelle Vorzeichenwechsel. Allerdings sieht der Code etwas seltsam aus. Zunächst ist der Umrechnungsfaktor zwischen Grad und Bogenmaß Pi/180, nicht Pi/360. Und dein Mittelpunkt liegt bei (x2-x1)/2; (y2-y1)/2. Auch der Radius ist doppelt so groß wie er sein sollte.

Das ist wohl eher ein Problem des Editors, als der Programmiersprache. Welches Programm benutzt du denn, um den Code einzugeben? Im Browser funktioniert es ja offenbar. Kannst du die Klammer mit Copy&Paste im Code einfügen?

Der Code lässt sich so überhaupt nicht kompilieren. Erstens hat CZeile keinen Defaultkonstruktor, und zweitens hat weder CMatrix noch CZeile einen operator[]. Da sind noch andere Fehler drin, die nahelegen, dass mars12 hier versucht hat, "Beispielcode" zu zeigen. Das eigentliche Problem vermute ich darin, dass hier vergessen wurde, die Regel der großen Drei zu befolgen: Wenn eine Klasse eines dieser drei hat: - Nichttrivialer Destruktor - Copykonstruktor - Copy-Zuweisungsoperator Dann braucht sie alle drei.

Nein, darum steht da ja "else if". Deine zusätzliche Bedingung ist unnötig.

Genau diese Einstellung, gepaart mit Inkompetenz, sichert mir meinen Job. Weiter so

Das ist nur dann sinnvoll, wenn man diese Klassen auch immer zusammen braucht. Man holt sich nämlich damit ein anderes Problem ins Haus: Wenn man irgendetwas an diesem "Sammelheader" ändern muss, muss man alle Quellcodedateien, die diesen Header einbinden, neu erstellen. Bei gut aufgeteilten Headern muss man nur die neu compilieren, die den geänderten Teil wirklich brauchen. Stichwort Compilezeitabhängigkeiten. Das kann bei größeren Projekten einen immensen Zeitunterschied ausmachen.

Das meinte ich nicht. Wenn du auf out[0] und out[1] zugreifst, musst du out auch als Array mit 2 Elementen deklarieren. Du hast es (in der ursprünglichen Version) als Array mit einem einzigen Element deklariert. Und auch in deiner neuen Version ist out um 1 zu klein.

Die erste Zeile ist noch richtig, die weiteren Parameter zerschießen dir möglicherweise den Stack. Ach ja, und ein einfaches strcpy hätte es hier auch getan. Ich verstehe sowieso nicht, warum du die Daten immer erst in einen lokalen Puffer schreibst, und den dann mit strncpy nochmal umkopierst.

Ein Bruchstrich bedeutet implizit eine Klammer um Zähler und Nenner. Den Nenner hast du zwar geklammert, den Zähler aber nicht (dafür aber den Gesamtausdruck). Ach ja, es wäre auch schön, wenn du dem Array out auch ein zweites Element gönnst, wenn du schon drauf zugreifst.

Hier wären ein paar Klammern angebracht.

Du machst es dir unnötig schwer. Dein Programm soll nicht für jede mögliche Kombination von Zusatzregeln einen Pfad enthalten. Jeder mögliche Sonderzustand beinhaltet keinen neuen Endbetrag, sondern nur eine Veränderung. Betrag: 200 Behindert: Betrag um 50 erhöhen Außendienst: Betrag um 100 erhöhen usw. Am Ende multiplizierst du das ganze dann mit der Dauer der Betriebszugehörigkeit in Jahren / 5.

Das ist ein Argument, dass dir bei C und C++ schnell Kopfschmerzen bereiten kann, weil beide Sprachen leider an allen Ecken und Enden das beliebte "undefinierte Verhalten" haben. Daraus, dass dein Code funktioniert, kannst du nicht folgern, dass er richtig ist. Es ist möglich, dass er schon morgen, oder auf einem anderen Rechner, oder mit einem anderen Compiler, nicht mehr funktioniert. Wie gesagt, wenn du einen Compiler hast, der bei fflush auf Eingabeströmen etwas Definiertes tut, und wenn Portabilität für dich kein Thema ist, ist das in Ordnung. Ansonsten solltest du das lieber lassen.