Problem im Release/Debug Modus

[GRxRedZero]

Hallo Leute, ich hab ein seltsames Problem in C++ was ich mir einfach nicht erklären kann. Folgendes:

Ich will eine 2 Dimensionale Matrix einmal in der Konsole anzeigen lassen.
Wenn ich mein Programm kompiliere zeigt mir mein Programm im Release/Debug-Modus folgendes an:
http://fs2.directupload.net/images/150728/9m7myyra.jpg

Wenn ich das Programm schritt für schritt debugge, dann macht er das so wie er das soll:
http://fs2.directupload.net/images/150728/qaqthzn4.jpg

Was zur Hölle?

Was er macht hab ich festgestellt. Er nimmt die nächste Zahl, das wäre in der nächsten Reihe die erste und wird durch diese überschrieben. Nur warum??

Wäre um eine Lösung oder um Beihilfe sehr dankbar.
mfg GRxRedzero
Ich verwende:
Codeblocks13.12
GCC 4.7.1 TDM (SJLJ) - 32-bit
Settings: Have g++ follow the C++ 11 ISO C++ language standart [-std=c++ 11]

Quellcode:

int **MapIOModul::leseMapDatei(std::string map)
{
	/**
	 * ----------------------------------------------------
	 * +++++++++++++++++++++++++++++++++++++++++++++++++
	 * Dieser Abschnitt überschreibt die Matrix    +++++
	 * +++++++++++++++++++++++++++++++++++++++++++++++++
	 * String to Integer
	 *  Von:
	 * [0][0]
	 * [0][0]
	 *
	 *  Auf:
	 * [5][1]
	 * [2][2]
	 * ----------------------------------------------------
	 */

	//	Deklaration
    int ** dyn_array;
	int temp_spalten;
    int temp_zeilen;
	int zahl_int;
    const char *zahl_char;
    const char *mapname;
	std::string temp_zahl;
	std::string zahl;

	//	Initialisiert
	mapname = map.c_str();
	std::fstream openfile(mapname);
	dyn_array = new int*[getZeile()];
	dyn_array = this->getMap();
	temp_spalten = 0;
    temp_zeilen = 0;

	//	Datei Lesen
    if(openfile.is_open())													//	Wenn Datei offen ist
    {																		//
        openfile >> chipset;												//	Der Name des Tilesets wird als string gespeichert
        std::cout << chipset;												//	Der Name wird ausgegeben
		while(!openfile.eof())												//	Solange das Dateiende noch nicht erreicht ist
        {																	//
			do																//	Füge alle Ziffern zu einer Zahl
			{																//
				temp_zahl = openfile.get();									//	Wert wird in temp Variable gespeichert
				if(temp_zahl != ",")										//	Es werden keine Kommas gespeichert
				{															//
						zahl.append(temp_zahl);								//	Vollständige Zahl Bsp: 1100
				}															//
			}while(temp_zahl != ",");										//
			//zahl_int = stoi(zahl);										//	Typumwandlung von string to int
			zahl_char = zahl.c_str();
			zahl_int = atoi(zahl_char);
			if(temp_spalten < getSpalte())									//	Wenn temp_spalten noch nicht bei spalten angekommen ist
			{																//
				if(temp_zeilen < getZeile())								//	Wenn temp_zeilen noch nicht bei zeilen angekommen ist
				{															//
					dyn_array[temp_spalten][temp_zeilen] = (int)zahl_int;	//	Speichert den Wert in die Matrix
					temp_zeilen++;											//	Nächste Zahl
				}//(temp_zeilen < zeilen)									//
				if(temp_zeilen == getZeile())								//	Nächste Zeile
				{															//
					temp_spalten++;											//
					temp_zeilen = 0;										//	Zeile wird zurückgesetzt
				}															//
				if(temp_spalten == getSpalte())								//	Ende erreicht
				{															//
					openfile.close();										//
					DruckeMapKonsole();
					return dyn_array;										//	RETURN
				}															//
			}//if(temp_spalten < getSpalte())								//
			zahl.erase();													//	Inhalt der Zahl wird gelöscht
        }//while(!openfile.eof())
    }//if(openfile.is_open())
}

[coder777]

Die Zeilen 34/35 machen wenig Sinn. Erst holst du dir Speicher, dann überschreibst du den Zeiger getMap().

Übrigens: Zeile 48 wird auch das EOF speichern.

Zeile 61: Bist du dir sicher, dass das nicht aus dem Breich rausgeht?

[sebi707]

Und aktivier mal ein paar mehr Warnungen. Deine Funktion returned überhaupt nur etwas wenn es keinen Fehler gab.

[sebi707]

Hat nichts mit dem Fehler zu tun aber du weißt schon, dass du auch direkt den c_str() Rückgabewert als Parameter nutzen kannst, ohne temp Variable?

mapname = map.c_str();
std::fstream openfile(mapname);

// [...]

zahl_char = zahl.c_str();
zahl_int = atoi(zahl_char);

[GRxRedZero]

Hallo erstmal danke für die Aufmerksamkeit.

@coder777
Manche Dinge sind vllt nicht ganz Trivial.
34/35. Speicher wird geholt und die wurde mit der Methode getMap() an jeder Position mit 0 beschrieben

[0][0][0][0]
[0][0][0][0]
[0][0][0][0]

61. Ja ich bin mir sicher das er in seinem bereicht bleibt. Mit std::cout habe ich mir anzeigen lassen wann an welcher position er was schreibt.
dyn_array[10][0] wäre also 666. wenn er durchgelaufen ist und die Prozedur wiederholt nicht mehr. wie gesagt beim Debuggen ist das ja zu 100% richtig nur eben nicht im Debug/release Modus. Mit VS2010 funktionierte das auch, erst seit dem ich den GCC nutze zeigt der mir den Mist an.

@sebi707
Ich weiß nicht genau was du mit Warnungen meinst, bin im ersten Jahr Fachinformatik Anwendungsentwicklung, so viel Erfahrung hab ich noch nicht
ich hab die Temp-Variable nur zu Testzwecken drin.

Wie gesagt schaut euch die Screens an, hat wer ne Erklärung warum es mit VS2010 bzw dem Debugger funktioniert und warum das Release/Debug vom GCC das anders darstellt? Vielleicht hilf mir das schon iwie weiter. Es sei denn ihr sehr direkt nen Fehler

Edit:
http://fs1.directupload.net/images/150728/lsqnghj4.jpg
Visual Studio Debug Modus
Der Code ist in sofern anders, dass ich statt atoi, stoi genutzt habe. Der GCC hat so seine Probleme das zu machen.

[sebi707]

GRxRedZero schrieb:

Manche Dinge sind vllt nicht ganz Trivial.
34/35. Speicher wird geholt und die wurde mit der Methode getMap() an jeder Position mit 0 beschrieben

Zeile 34 ist mindestens ein Memory Leak. Du reservierst Speicher für ein paar Pointer und überschreibst direkt danach den Pointer mit dem Rückgabewert von getMap(). Kannst du mal den Code von getMap() zeigen, oder wo auch immer der Speicher reserviert wird?

GRxRedZero schrieb:

Ich weiß nicht genau was du mit Warnungen meinst, bin im ersten Jahr Fachinformatik Anwendungsentwicklung, so viel Erfahrung hab ich noch nicht

Warnungen wie sowas: warning C4715: 'leseMapDatei': not all control paths return a value
Besonders wenn irgendwas nicht wie gewünscht funktioniert sollte man sich mal die Warnungen anschauen. Diese Warnung wird hier aber vermutlich nicht für den Fehler verantwortlich sein, trotzdem sollte man das Problem beheben.

[coder777]

34/35. Speicher wird geholt und die wurde mit der Methode getMap() an jeder Position mit 0 beschrieben

Das ist nicht möglich.

61. Ja ich bin mir sicher das er in seinem bereicht bleibt.

Glaub ich nicht. Was gibt getMap() zurück?

[GRxRedZero]

Klar kein Thema das ist die getter-Methode:
Das ergibt aber nur Sinn weil vorher andere Methoden auf die map** zugreifen. die eben den Matrixinhalt auf den int-Wert 0 setzt..

int **MapIOModul::getMap()
{
	return this->map;
}

Der Header:

#ifndef MAPIOMODUL_H
#define MAPIOMODUL_H

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cctype>
#include <fstream>
#include <stdio.h>
#include <tchar.h>

#pragma once

class MapIOModul
{
    public:
        //Standartkonstruktoren
        MapIOModul();
        virtual ~MapIOModul();
        MapIOModul(std::string dateiname);

        //Methoden
        int getZeile();
        int getSpalte();
        int zufallszahl(int min, int max);
        int **erstelleMatrix();
        int **getMap();
        int **leseMapDatei(std::string map);
        void erstelleMapDatei();
        void setMap(int **m_map);
        void DruckeMapKonsole();
        void setZeilenSpalten(std::string map);
        void mapGenerator();
        void schreibeInDatei(std::string mapname);
        std::string getChipset();
        void setChipset(std::string mapdatei);
    protected:
    private:
        //Attribute
        std::string chipset;
        std::string dateiname;
        int spalten;
        int zeilen;
        int **map;
};

#endif // MAPIOMODUL_H

Warnings:

||=== Build: Debug in Awake over the Stars (compiler: GNU GCC Compiler) ===|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp||In member function 'void MapIOModul::setZeilenSpalten(std::string)':|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp|166|warning: variable 'temp_spalten' set but not used [-Wunused-but-set-variable]|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp|167|warning: variable 'temp_zeilen' set but not used [-Wunused-but-set-variable]|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp||In member function 'int** MapIOModul::erstelleMatrix()':|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp|241|warning: variable 'temp_spalten' set but not used [-Wunused-but-set-variable]|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp|242|warning: variable 'temp_zeilen' set but not used [-Wunused-but-set-variable]|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp||In member function 'void MapIOModul::mapGenerator()':|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp|267|warning: missing braces around initializer for 'int [25]' [-Wmissing-braces]|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp||In member function 'int** MapIOModul::leseMapDatei(std::string)':|
K:\Awake over the Stars\AotS\src\level\MapIOModul.cpp|158|warning: control reaches end of non-void function [-Wreturn-type]|
||=== Build finished: 0 error(s), 6 warning(s) (0 minute(s), 3 second(s)) ===|

Ich kann ansonstan auch das VS2010 projekt zeigen, dort ist alles im zusammenhang drinne:
http://www.file-upload.net/download-10802275/MapGenerator.rar.html
Dort funktioniert es. Sobald es aber in MinGW kompiliert wird gibts nur Stress. Einmal wegen stoi und einmal, die falsche Darstellung meiner Matrix

[sebi707]

Naja in der getMap() Funktion wirds wohl auch keinen Fehler geben. Immerhin hast du das komplette Projekt angehängt. Ich habe da gerade mal etwas durchgeschaut und mindestens ein Problem gefunden. Das hier ist die Stelle wo du Speicher reservierst:

//	Allozierung - Dynamisches Array wird erstellt
dyn_array = new int*[zeilen];
for (int i = 0; i < zeilen; ++i){
    dyn_array[i] = new int[spalten];
}

Nach diesem Code kann man dann dein Array ansprechen mit dyn_array[zeile][spalte] (die Reihenfolge ist wichtig!). Wenn ich mir aber deinen restlichen Code anschaue, dann machst du überall dyn_array[spalte][zeile] und weil du unterschiedlich viele Zeilen und Spalten hast ließt du so über die Arraygrenzen hinweg. Entweder änderst du die Reihenfolge bei allen Zugriffen oder bei der Reservierung des Speichers.

Ansonsten gibts auch noch einige Punkte, die man dan deinem Code aufräumen/verbessern könnte. Ich guck nochmal in Ruhe und poste dann nochmal.

[SeppJ]

Offtopic:

GRxRedZero schrieb:

Settings: Have g++ follow the C++ 11 ISO C++ language stan**** [-std=c++ 11]

Lol. Du hast den Hilfetext aus deiner IDE kopiert und dann gemeint, dessen Rechtschreibung korrigieren zu müssen?

Ontopic:
Da ist noch viel mehr falsch im Code. Ein paar Dinge wurden ja schon genannt. Die Leselogik ist fehlerhaft. Du prüfst zur falschen Zeit auf die falschen Fehler. Überhaupt ist der Code voller Voodoo. Wo immer du diese Form der C++-Programmierung her hast: In Zukunft als Lehrer meiden! Falsches zu lernen ist schlimmer als gar nichts zu lernen.

Ein paar konkrete Tipps, unter deren Beachtung das Problem wahrscheinlich gar nicht erst aufgetreten wäre:

• Variablen so lokal wie möglich machen! Bei dir ist alles global innerhalb der Funktionen. Die Definitionen sind zudem weit vom Verwendungsort weg.
• Klare Trennung von Zuständigkeiten! Ein MapIOModul hat wohl kaum die Aufgabe, dynamisch Speicher zu besorgen und zu verwalten. Zumal du absolut jeden Fehler machst, den man dabei nur machen kann.
• Apropos dynamischer Speicher: Wie gesagt, gehört das in eine eigene Klasse, die nur dies tut und das auch richtig. Und, oh Wunder, das gibt es bereits alles fix und fertig in der Standardbibliothek. Wieso nutzt du nicht deren Container? In C++ muss man schon so weit gehen zu sagen, dass jeder Code der ein explizites new oder delete enthält falsch ist.

Anstatt zu versuchen, den vermurksten Code an dieser Stelle noch zu retten, würde ich viel eher vorschlagen unter den genannten Gesichtspunkten das Programm noch einmal neu zu schreiben. Da ist derzeit so viel falsch, dass eine einzelne Korrektur bloß bedeutet, dass man dafür einen anderen Fehler findet.

[sebi707]

So hier mal die gröbsten Sachen. Bitte nicht angegriffen fühlen, ich hab das hier aufgeschrieben damit du etwas lernen kannst, um besseren Code zu schreiben.

std::cout << (int)map[i][j] << ",";

Der Cast ist hier unnötig weil map[i][j] sowieso schon int ist. Gibt noch weitere unnötige Casts zu int.

if((alter_bustabe > 46) && (alter_bustabe < 58))			//  Wenn der letzte Bustabe eine Zahl war
{
  // Überflüssige Abfrage 
}
else
{
  // [...]
}

Erstmal heißen die Dinger Buchstaben und zweites meintest du wohl einfach nur Zeichen. Den leeren Fall beim if kann man los werden indem man die if-Bedingung umdreht. Für deinen Fall würde die umgedrehte Bedingung if(alter_bustabe < '0' || alter_bustabe > '9') lauten. Und wenn man schon mit den ASCII Werten arbeitet, kann man besser direkt die Zeichen hinschreiben. Du hast dich nämlich auch versehen, denn dein Test lässt '/' als Zahl durch. Und es gibt auch schon die fertige Funktion std::isdigit() .

Die gesamte void InitMap::erstelleMapDatei() Funktion ist abenteuerlich. Direkt nachdem du ein std::fstream Objekt erstellt hast, ist garantiert noch keine Datei offen. In dem zweiten datei.open(...) kommt dann auch zweimal std::ios_base::out vor. Macht zwar nichts für das logische OR, ist aber total unnötig. Überhaupt ist die ganze Funktion unnötig. Du kannst in der void InitMap::schreibeInDatei(std::string mapname) direkt die entsprechenden Flags zum löschen vorhandener Dateien angeben. Dazu verwenden erstelleMapDatei und schreibeInDatei unterschiedliche Namen für die Datei.

InitMap *initMap = new InitMap("map_123_test.txt");

Hier ist es nicht nötig ein Objekt dynamisch zu reservieren. Du kannst einfach InitMap initMap("map_123_test.txt"); schreiben.

Abschließend kann ich noch sagen, dass deine Klasse sehr schwer zu bedienen ist und man einfach irgendwas falsch machen kann, was dann zu Fehlern führt. Beispielsweise will ich nicht

initMap->setZeilenSpalten("map.txt");
initMap->setMap(initMap->erstelleMatrix());
initMap->leseMapDatei("map.txt");

schreiben müssen um eine Map zu laden. Ein einfaches initMap->leseMapDatei("map.txt"); sollte reichen. Das dabei entsprechend Speicher reserviert wird usw. sollte mich als Benutzer deiner Klasse nicht so sehr kümmern. Und wenn man dynamisch Speicher reserviert, sollte der auch irgendwo wieder freigegeben werden.

[GRxRedZero]

@sebi707
Ja ich hab mal hier und mal da x und y vertauscht verarbeitet wurden die aber richtig. Schließlich macht das Programm das unter VS2010 ja das was er soll.

Ich weiß auch das der (int)-cast unnötig ist, das steht da nur weil ich vorher was anderes geschrieben habe und das war es kein int.

In der If-Anweisungen waren noch Dinge enthalten, die ich noch gebraucht habe die ich gelöscht habe, Über den toten Code will ich gar nicht diskutieren, aber die Kritik nehme ich zur Kenntnis und werde versuchen das ansprechen der Methoden zu vereinfachen. Das mit der Speicherallozierung mache ich zum ersten mal. Trotzdem danke für die Kritik und dafür das du dir die Mühe gemacht hast da reinzuschauen.

@SeppJ

Offtopic:
GRxRedZero schrieb: 
[quote]Settings: Have g++ follow the C++ 11 ISO C++ language stan**** [-std=c++ 11] [/quote]
Lol. Du hast den Hilfetext aus deiner IDE kopiert und dann gemeint, dessen Rechtschreibung korrigieren zu müssen?

Bitte was? Ich habe abtippt wo ich in Codeblocks den Hacken anhabe. Die Sternchen hat das Forum erstellt.

In Zukunft als Lehrer meiden! Falsches zu lernen ist schlimmer als gar nichts zu lernen.

Wie unverschämt ist das denn? Deine Philosophie kannst du dir in deinen Arsch stecken, nur weil du deine 20.000 Beiträge hast, Moderator und 10 Jahre rum codest, ist deine Anmaßung wesentlich dreister als meine Reaktion. Dann lass ich das Forum mal schön hier beiseite und lass mich lieber von Leuten lehren die mich ernstnehmen, nicht von einem didaktischen Vollpfosten.
Ich werd mich auch direkt bei deinem Webmaster beschweren und mich direkt hier abwenden.
Nicht empfehlenswert!!!

return -1;

[cvcv]

Mein Gott, ey.

Du hast hier einen Haufen von Müll programmiert und das nach einem Jahr Ausbildung in dem Bereich.

Du wärst nun mal am besten beraten, ein Buch zu lesen. Wenn du mit dieser Code-Quality jemals irgendwo anders als in deiner Ausbildungsstelle arbeiten willst, dann fliegst du gehörig auf die Nase.

Generell solltest Du deine Mentalität, was das programmieren angeht, überdenken.

"Es funktioniert doch", "Steht da nur noch, weil vorher was anderes dastand", usw.

Programmieren ist weit mehr als nur irgendein Rotz zusammenzuwürfeln, der am Ende manchmal das tut, was man haben will.

Je eher Du das verstehst, desto eher kannst du anfangen, wirklich programmieren zu lernen.

Viel Erfolg.

[Columbo]

GRxRedZero schrieb:

@SeppJ

Offtopic:
GRxRedZero schrieb: 
[quote]Settings: Have g++ follow the C++ 11 ISO C++ language stan**** [-std=c++ 11] [/quote]
Lol. Du hast den Hilfetext aus deiner IDE kopiert und dann gemeint, dessen Rechtschreibung korrigieren zu müssen?

Bitte was? Ich habe abtippt wo ich in Codeblocks den Hacken anhabe. Die Sternchen hat das Forum erstellt.

Ja, weil aus irgendeinem unerfindlichen Grund in deinem Beitrag standart (standart) steht. Das hat der Compiler ganz sicher nicht ausgespuckt (und wenn doch, spielt wohl dein Locale verrück ).

Wie unverschämt ist das denn?

Das ist ein sehr guter Tipp. Glaub' mir.

Deine Philosophie kannst du dir in deinen Arsch stecken, nur weil du deine 20.000 Beiträge hast, Moderator und 10 Jahre rum codest, ist deine Anmaßung wesentlich dreister als meine Reaktion.

Deine Reaktion strotzt nur so vor naivem, beleidigendem Geplapper. SeppJ ist, soweit ich weiß, niemals dreist gewesen und wohl einer der vernünftigsten und kompetentesten Leute im Netz. Ich würde deine Beleidigung schleunigst zurücknehmen, dann haut er vielleicht für dich auch eine seiner genialen zweiseitigen Lektionen raus.
PS: Ich schätze er codet seit 15

Dann lass ich das Forum mal schön hier beiseite und lass mich lieber von Leuten lehren die mich ernstnehmen, nicht von einem didaktischen Vollpfosten.

Wenn du einen sehen möchtest, schau auf wenn du vor dem Pult stehst.
Und nein, die Moderation nimmt dich sehr ernst: Jetzt nur leider als Provokateur.

Ich werd mich auch direkt bei deinem Webmaster beschweren und mich direkt hier abwenden.

Der Webmaster wird wohl schlussfolgern, dass du mit dem ganzen Uni-Stress nicht klarkommst, und dich an einen Therapeuten verweisen.

Wo ist EOP wann man ihn braucht?

[GRxRedZero]

Man merkt schon, man ist umgeben von Offtopic. Ja natürlich steht im Vordergrund ein funktionierendes Programm. Warum? Weil es einen Abnehmer gibt. Der zahlt Geld, weils funktioniert. Ich könnte dem Abnehmer auch erklären, dass das Programm 10000€ mehr kostet weil ich erst einmal mit euch diskutieren muss was wie auszusehen hat.

Das ist ein sehr guter Tipp. Glaub' mir.

Ein guter Tipp ist also nichts lernen, statt Fehler machen? Dann dürfte niemand auf dem Planeten Programmierer werden. Guter Ansatz.

einer der vernünftigsten und kompetentesten Leute im Netz

Dann möchte ich Inkompetenz hier nicht erfahren. Kompetent heißt auch ein Thema didaktisch näher bringen und nicht nur furztrockene Sachkompetenz.

PS: Ich schätze er codet seit 15

Wow Klasse, coden tue ich seit 9 Monaten.
edit: Und weißt du was? Seit 5 Wochen C++

Programmieren ist weit mehr als nur irgendein Rotz zusammenzuwürfeln, der am Ende manchmal das tut, was man haben will.

Was wohl immer noch nicht angekommen ist. Ich bin im ersten Lehrjahr und nicht in der Uni, Software Engineering habe ich noch gar nicht gehabt. Dein Beitrag macht thematisch 0 Sinn.

Der Webmaster wird wohl schlussfolgern, dass du mit dem ganzen Uni-Stress nicht klarkommst, und dich an einen Therapeuten verweisen.

Das ist mir latte. Ich habe mich beschwert, weil sein Beitrag grundlos anmaßend ist.

Ich schreibe hier auch nur noch einmal um mich bei sebi707 zu bedanken. Für alle die es noch nicht begriffen haben, es ging mir um ein Problem mit einer Ausgabe von Zahlen nicht um eure Auffassung von der Herangehensweise wie etwas programmiert werden soll. Euer hübscher Moderator hat nur Müll geschrieben zu meinem Problem. Andere waren hier konkret und sachlich. Und darum haben mir auch Konkrete und sachliche Aussagen geholfen.

Nach diesem Code kann man dann dein Array ansprechen mit dyn_array[zeile][spalte] (die Reihenfolge ist wichtig!). Wenn ich mir aber deinen restlichen Code anschaue, dann machst du überall dyn_array[spalte][zeile] und weil du unterschiedlich viele Zeilen und Spalten hast ließt du so über die Arraygrenzen hinweg. Entweder änderst du die Reihenfolge bei allen Zugriffen oder bei der Reservierung des Speichers

Genau das ist das Problem gewesen, ich hab den unschönen Code vereinfacht vorallem aufgeräumt. X und Y sind jetzt einheitlich angeordnet und es geht.
Danke.

[deejey]

Mein Gott wie kann man sich nur so echauffieren wenn du schon bei solchen Lappalien so austickst dann solltest du überlegen ob Programmierung überhaupt das Richtige für dich ist und du vlt. als Dachdecker oder Schaffner besser aufgehoben bist. Als Entwickler hat man permanent mit irgendwas rumzukämpfen und ist auf das Web angewiesen, da sollte man nicht so dünnhäutig sein.

So, jetzt beschwere dich beim Forumsbeauftragten im Bundestag über diese meine Anmaßung.

[sebi707]

GRxRedZero schrieb:

Ja ich hab mal hier und mal da x und y vertauscht verarbeitet wurden die aber richtig. Schließlich macht das Programm das unter VS2010 ja das was er soll.

Aus "Code macht unter Compiler xy, was er soll" kann man leider nicht auf die Korrektheit des Codes schließen. Eigentlich fast immer hat man irgendwo einen Fehler im Code der durchaus schwer zu finden sein kann. Ich habe schon tagelang nach Fehlern gesucht, die nur sehr selten auftraten. Immer waren es Fehler im Code und kein Fehler des Compilers. Das ein Compiler ein fehlerhaftes Programm aus korrektem Code erzeugt ist sehr sehr unwahrscheinlich und betrifft höchstens irgendwelche ganz neuen Features oder irgendwelche komischen Sonderfälle die vom Standard (noch) nicht abgedeckt werden.

[cvcv]

So blöd, wie ein Abnehmer sein muss, dass er ausgerechnet dich für die Entwicklung von Müll bezahlt, könntest du diesem bestimmt auch erzählen, dass das Programm ihn jetzt 10k€ mehr kostet, weil heute Vollmond ist.

[Columbo]

Ja natürlich steht im Vordergrund ein funktionierendes Programm.

Echt verdammt witzig das von dir zu hören.

Warum? Weil es einen Abnehmer gibt. Der zahlt Geld, weils funktioniert.

Du solltest Komiker werden.

Das ist ein sehr guter Tipp. Glaub' mir.

Ein guter Tipp ist also nichts lernen, statt Fehler machen?

Nein. Ein guter Tipp ist es, nicht falsch zu lernen, sondern abzuwarten bis die Ressourcen vorhanden sind um richtig zu lernen.

Dann dürfte niemand auf dem Planeten Programmierer werden. Guter Ansatz.

Nein, dann dürfte niemand auf dem Planeten "C++ von A bis Z" lesen. Keiner dürfte eine Minute Bibel-Talk abbekommen, bevor er nicht eine grundlegende Unterweisung in Astrophysik und Evolutionstheorie erfahren hat. Keiner dürfte bei einem inkompetenten, halbherzig motivierten Trottel irgendeinen prähistorischen C-mit-Klassen Quark lernen.

Ich habe mich beschwert, weil sein Beitrag grundlos anmaßend ist.

Jeder außer dir erkennt korrekt dass sein Beitrag in keinster Weise anmaßend ist, und du einfach in deiner Frust angefangen hast, in den Brunnen zu spucken, aus dem du trinken wolltest.

Für alle die es noch nicht begriffen haben, es ging mir um ein Problem mit einer Ausgabe von Zahlen nicht um eure Auffassung von der Herangehensweise wie etwas programmiert werden soll.

Es tut uns gar so Leid, versucht zu haben, dir deine anderen Fehler aufzuzeigen! Es ist u.a. der Sinn dieses Forums, dir alle Fehler aufzeigen. Natürlich scheint es, als ob wir irgendwelche unerheblichen Kleinigkeiten erwähnt hätten, aber Programmierung lebt eben von Präzision und Perfektion. Es ist nicht wie ein Kunstwerk, wo e.g. ein relativ kleiner Flüchtigkeitsfehler das Gesamte nicht sonderlich herunterzieht. Es ist Logik pur - jedes Zeichen kann ein Programm zerstören. Deswegen, und weil du irgendwann sogar den deutschen Arbeitsmarkt als Entwickler unsicher machen könntest, fühlen sich die Mitglieder dieses Boards verpflichtet, in jedem Teil deines Programms nach verbesserungswürdigen Fehlern zu suchen. Das hilft nur dir.

Wenn du auf diese Art von Kollaboration verzichten und deine Frage lieber auf Stackoverflow stellen möchtest, viel Spaß: Ich close-vote dich dort gerne. Den Stil erkennt man schließlich wieder.

Euer hübscher Moderator hat nur Müll geschrieben zu meinem Problem.

Du hast dich wie ein Kleinkind benommen. Und das ist dein wirkliches Problem: Nicht, dass du noch nicht C++ beherrschst - wir standen schließlich auch mal da wo du nun stehst - sondern dass du nicht in der Lage bist, mit uns über deinen Code zu diskutieren. Wenn sich das nicht ändert, sieht's schlecht aus.

[Bengo]

Ein funktionierendes Programm ist eins, was auch wirklich funktionert, auch wenn man mal ein kleines Update gemacht hat.
Und solchen Code zu produzieren ist eine der schwersten Aufgaben die die Informatik noch zu bewältigen hat. Und es machen sich immer noch viele Leute gedanken, wie man sowas auch tatsächlich schaffen kann.
Und deshalb haben sich die Sprachen in Laufe der letzen Jahrzehnte extrem verändert (Kenne ich nur vom Hörensagen, so alt bin ich nicht mal :D).
Das ist gut für die Qualität des Codes, macht Einsteigern das Leben (meiner Meinung nach) immer schwerer. Ich kann mir nicht vorstellen, dass jemand in kurzer Zeit die Erkenntnisse von 20 Jahren verarbeiten kann.
Ich habe mit Code angefangen, der wahrscheinlich noch viel schlechter war, und mich langsam an die heutigen Standarts angepasst(was die meisten hier ja auch haben, da sie ja die lange Erfahrung haben) und kann nun besseren Code schreiben (ok bei C++ dauert es noch etwas) . In C++ ist das ganze auch noch mal ein paar Nummern schwieriger als in den meisten anderen Sprachen, weil man nicht auf das machinennahe verzichtet, aber trotzdem immer abstracter wird.

Lange Rede kurzer Sinn: Es macht keinen Sinn, fehlendes Verständnis auf schlechtes Lehrmaterial (und Personal) zu schieben. Ich glaube das ist einfach der Komplexität der Sache zu verschulden.
Ich habe keine Ahnung, ob ich direkt richtig Programmieren hätte können, wenn es mir jemand mit den heutigen Standarts beigebracht hätte. Ich glaube eher nicht.(Lasse mich aber gern vom Gegenteil überzeugen)

[GRxRedZero]

Das ist ja auch genau das Ding. Leute sind mit der Entwicklung der Sprache C++ groß geworden, während ich in den 5 Wochen C++ mich mit MFC auseinandergesetzt habe und seit 6 Tagen eigenständig was schreibe.
Und dann kommen so höhnische Antworten wie:

Echt verdammt witzig das von dir zu hören.

Du solltest Komiker werden.

Keiner dürfte eine Minute Bibel-Talk abbekommen, bevor er nicht eine grundlegende Unterweisung in Astrophysik und Evolutionstheorie erfahren hat.

Und, oh Wunder, das gibt es bereits alles fix und fertig in der Standardbibliothek.

Lol. Du hast den Hilfetext aus deiner IDE kopiert und dann gemeint, dessen Rechtschreibung korrigieren zu müssen?

In Zukunft als Lehrer meiden!

Einfach nur lol, ohne scheiß.