Mr. Miyagi

Sehr schönes Tool und Danke für die Antwort zu den Statics. Ist tatsächlich kein Überbleibsel meines Programms. Es greift noch ein anderer Prozess auf den Ordner zu. Ist es eigentlich überhaupt möglich, dass ich mein Programm komplett beende, es noch irgendwo Reste im Speicher „herum liegen“ und man deswegen den Ordner nicht löschen kann? Nur für den Fall, dass mal kein weiterer Prozess auf meine Programme zugreift und ich anfange zu rätseln.

Tag alle zusammen, soweit ich das mitbekommen habe, werden statische Member einer Klasse oder Typen beim Start des Programms einmalig initialisiert, und können dann auch ohne eine Instanz des jeweiligen Objektes direkt aufgerufen werden (solange sie nicht protected oder private in dieser sind). Aber wann werden die Daten denn eigentlich wieder gelöscht ? Sind diese dann bis zum Programmende im Speicher, oder nur solange wie mindestens ein Objekt der jeweiligen Klasse existiert ? Was auch komisch wäre, da - wie oben erwähnt - sie ja kein Objekt der eigenen Klasse benötigen. Wenn ich z.B. versuche mein Projekt zu beenden und den Ordner zu löschen sagt mir Windows: „Die Aktion kann nicht abgeschlossen werden, da der Ordner in einem anderen Programm geöffnet ist.“ Hab ich da vergessen irgendwo Speicher wieder frei zu geben (verwende aber kein new *** in dem Projekt) oder hab ich was initialisiert, was ich vergessen hab wieder zu beenden? Danke für eure Hilfe.

Das mit dem Überladen war ja meine erste Idee. Nur will ich nicht den gleichen Funktionsnamen mit unterschiedlichen Parametern nutzen, sondern mit den gleichen Funktionsnamen, die gleichen Parameter, nur mit unterschiedlichen Rückgabewerten. Einzige Möglichkeit wäre die Variante, für jeden Datentyp seine eigene Funktion zu schreiben und als Rückgabewert dann den richtigen Wert. Denke es geht auch nicht anders, und wenn dann nur mit aufgeblähtem Code.

Also eigentlich kann ich den kompletten Code in eine Funktion schreiben. Hab es mal versucht und nun bläht sich das Programm nicht so im Arbeitsspeicher auf. Eigentlich kann ich nur abwägen zwischen einem langsameren Zugriff auf die Daten, dadurch das jedes mal abgefragt wird um welchen Typ es sich handelt, oder einen schnelleren Zugriff dadurch, dass die richtige Funktion je nach Parameter benutzt wird. Nachteil ist, dass ich für jeden Datentyp die Funktion erstellen muss. Denke aber das es einfach nicht anders gehen wird. Sieht dann ungefähr so aus. bla.h class bla { public: template <class T> T getValue(std::string Section, std::string Key) { T TheType; func(TheType,Section,Key); } private: void func(bool TheType,std::string Section,std::string Key); void func(int TheType,std::string Section,std::string Key); ... ... }; bla.cpp void bla::func(bool TheType,std::string Section,std::string Key) { ... } void bla::func(int TheType,std::string Section,std::string Key) { ... } ... ... Der Code benutzt jetzt keine Pointer oder Referenzen. Ist halt nur zur Veranschaulichung. Wenn ich aber so darüber nachdenke, ist das Template in der Form komplett überflüssig. Und eine Möglichkeit der Funktion "func()", einfach T als Parameter zu übergeben, funktioniert ja auch nicht. Ist ja schließlich kein Template. Oder gibt es da einen "Trick" das sowas doch funktioniert ?

Tag alle zusammen, erstmal beschreibe ich die aktuelle Situation. Ich bastle zur Zeit einer Klasse, die eine Ini File (oder beliebige txt) einließt, sie dann parst und ihre Werte in eine static std::map schreibt. Nun soll der Benutzer Werte auslesen können, indem er ein Objekt der Klasse erstellt, den Abschnitt und Schlüssel als Parameter einer Funktion übergibt und dann einen Pointer auf den Wert in der static std::map zurück liefert. Genau da liegt das Problem. Jetzt könnte ich für jeden Datentyp eine Funktion schreiben die mir den richtigen Typ zurück liefert das würde die Klasse aber einfach nur unnötig groß machen. Die eleganteste Variante die mir dann dazu eingefallen ist, ist die Benutzung von Templates. Mit Templates will ich zum Beispiel folgenden Funktionsaufruf erreichen. if(cfg.getValue<bool>("WINDOWSETUP","bFullScreen")) { ... } Sollte mir nach Möglichkeit einen Pointer auf den Boolean Wert in der Datenstruktur zurück liefern, tut es aber nicht, weil ein „undefined reference“ Fehler erzeugt wird. Deklariere ich das ganze als Inline Funktion innerhalb der Klasse bläht sich der Code zur Laufzeit extrem auf. Das sagt mir zumindest die Prozessanzeige im Task Manager. Meine Frage also: Wie kann man ein Template in einer Klasse verwenden ohne den Code in den Header zu schreiben und ohne den „undefined reference“ Fehler zu erzeugen ? Danke Schon mal für die Antworten.

Danke, Danke ^^ Wird die Favoriten-Liste wieder größer. Benutze den GCC Compiler und muss sagen ... ... Google findet eine Menge zu "Predefinied GCC Macros" Hab halt nur nach "Macro List C++" und sowas geguckt, aber bin nie auf predefinied gekommen. Danke noch mal.

Hi an Alle, wie man wahrscheinlich an der Überschrift schon erkennt, suche ich so etwas wie eine Makroliste, am besten speziel für CodeBlocks C++. Mein Problem ist, dass ich ein Makro suche welches aussagt ob Windows benutzt wird oder Linux und je nachdem der passende Code ausgeführt wird. So wie in etwa: #ifdef BUILD_DLL #define ***MACRO*** ***CODE*** #endif Hab schon in der C::B Manual geguckt und gegoogelt, doch ich finde nichts. Wäre schön so eine Liste zu sehen. Danke schon mal im Voraus

Hat sich schon erledigt. Habe in dem Projektordner einen Header zum DLL Export und einen für das Testen der Klassen und Funktionen. Habe die Klasse im Projektheader deklariert, aber in der Cpp-Datei den Header für den DLL Export noch zu stehen gehabt. Ist ja dann kein Wunder das die Klasse dann in der Cpp- Datei nicht erkannt wird. Na ja, war wohl gestern etwas blind auf den Augen. Danke euch ... Mr. Miyagi

Der Sinn soll sein, dass man eine Art Mainheader hat, den man einbindet und dieser dann mehrere Klassen beinhaltet. Anstatt dann alle Klassen einzeln in sein Projekt einzubinden, soll man einen großen Header einbinden können. Damit man nicht alles in eine Cpp-Datei macht, gibt es einen Header und mehrere Cpp-Dateien dazu die dann die jeweiligen Funktionen enthalten. Habe gerade ein kleines Beispiel gemacht, aber das führt er ohne Probleme aus. Werde erst einmal weiter versuchen das eigentliche Projekt auch so zum laufen zu bekommen.

Hi, wie der Titel schon sagt, möchte ich mehrere Klassen in einen Header unterbringen. Zum aktuellen Problem: Ich habe einen Header in den stehen mehrere Funktionen, die nicht teil einer Klasse sind. Innerhalb der Cpp-Datei befinden sich dann diese Funktionen. In der Cpp Datei selber befinden sich noch ein paar Funktionen die nicht im Header auftauchen, da man nicht auf diese zugreifen soll, wenn man den Header einbindet. Nun will ich eine Klasse hinzufügen ... Die Deklaration in der Header-Datei verläuft ohne Probleme, der Compiler meckert nicht und das Programm startet so wie es soll. Will ich nun aber in der Cpp-Datei den Constructor und Destructor hinzufügen, beendet das Programm mit der Compilermeldung: "Klasse" has not been declared" Ich hab sowohl den Header in die Cpp-Datei eingebunden (sonst würden die Funktionen davor schon nicht funktionieren), als auch den Namen der Klasse richtig geschrieben und auf Groß- und Kleinschreibung habe ich auch geachtet. Warum tut dann der Compiler trotzdem so als ob er die Klasse in der Cpp-Datei nicht kennt ? Danke schon mal im Voraus mfg Mr. Miyagi

Hab es nun hinbekommen eine DLL-Datei zu erstellen und diese statisch einzubinden. Habe ein schönes Tutorial gefunden, dass alles ziemlich gut erklärt. Wer selber mal Interesse hat ... ... hier befindet sich das Tutorial. Danke für eure Hilfe und das ihr mich auf die DLL's aufmerksam gemacht habt. mfg Mr. Miyagi

Hab mal im C::B Porjektordner geschaut und da legt er ja einen Ordner mit dem Namen Obj an. Dort sind dann *.o Dateien, welche ja compilierte Cpp Dateien sind. Da ich die selbe Dateiendung auch schon im lib Verzeichnis von C::B gesehen habe, dachte ich mir, dann kann ich ja einfach meinen Header in den Include Ordner packen und meine *.o Datei in den lib Ordner. Dann müsste ich ja nur noch im Linker die *o.Datei angeben und fertig. Es funktionierte aber wieder nicht. Es kam nur wieder der Fehler: Von dll Dateien habe ich absolut keine Ahnung. Hab mich da mal ein wenig eingelesen und würde auf anhieb entscheiden, wenn ich es denn so mache, eine statische dll zu erstellen. Erscheint mir persönlich einfacher. Also hab ich versucht in C::B ein neues dll Projekt zu erstellen. Da ist aber eine Menge Code den ich nicht verstehe. Wäre also nett wenn mir mal jemand den Code unten genauer erklären kann. Erstmal der Header der automatisch erzeugt wird. #ifndef __MAIN_H__ #define __MAIN_H__ #include <windows.h> /* To use this exported function of dll, include this header * in your project. */ #ifdef BUILD_DLL #define DLL_EXPORT __declspec(dllexport) #else #define DLL_EXPORT __declspec(dllimport) #endif #ifdef __cplusplus extern "C" { #endif void DLL_EXPORT SomeFunction(const LPCSTR sometext); #ifdef __cplusplus } #endif #endif // __MAIN_H__ Hier die Main.cpp die automatisch erzeugt wird. #include "main.h" // a sample exported function void DLL_EXPORT SomeFunction(const LPCSTR sometext) { MessageBoxA(0, sometext, "DLL Message", MB_OK | MB_ICONINFORMATION); } BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { switch (fdwReason) { case DLL_PROCESS_ATTACH: // attach to process // return FALSE to fail DLL load break; case DLL_PROCESS_DETACH: // detach from process break; case DLL_THREAD_ATTACH: // attach to thread break; case DLL_THREAD_DETACH: // detach from thread break; } return TRUE; // succesful } Was mir schon mal gar nicht gefällt ist, dass in dem Code viel zu oft Windows auftaucht. Deswegen wollte ich auch wissen ob man (außer in dem Beispiel) Windows weglassen kann. Wenn nicht: Gibt es eine Alternative zu den dll's die plattformunabhängig ist ? Noch ein Problem: Wenn ich auf Compilieren gehe kommt eine Fehlermeldung die sagt: "You must select a host application to run a libary ..." Geht man auf "Project->Set Programs' Arguments" kann man die host application auswählen, aber wozu braucht das Projekt eine *.exe um meine dll zu erstellen? Wenn ich dann dort eine beliebige *exe hinzufüge kommt aber wieder ein Fehler der dann sagt: "Execution of '"Test.exe" ' in 'C:\... DLLTest' failed." Übrigens habe ich dann im bin Verzeichnis trotz den Fehlermeldungen die Test dll zu stehen. Meine Fragen zusammen gefasst. Wie erstelle ich eine dll Datei und worauf muss man achten? Ist eine dll plattformunabhängig benutzbar? So das ist dann wieder eine kleine Geschichte hier, aber dafür beschreibt es mein Problem ausführlich. ^^ mfg Mr. Miyagi

Es funktioniert. Es hat tatsächlich am dem undefinierten Pointer gelegen. Den Satz vergess ich definitiv nicht. ^^ Dann bedanke ich mich nochmal für eure guten Tipps und die Hilfe. mfg Mr. Miyagi

Wie mache ich das dann mit meinen eigenen Headern? Ich will ja möglichst nur den Header deklarieren und dann gleich loslegen. Also ein Rundum-sorglos-Paket. Muss ich dafür eine eigene Bibliothek erstellen die in den lib Ordner kommt?! Wenn ja, woher weiß dann der Header wo diese ist ?! Irgendwie müssen ja die Header wissen woher sie ihre Daten bekommen.

Das ist nur 1,6 MB groß weil die SDL Bibliothek noch beiliegt. Ich wollte ja nur das Gesuche nach den Dateien vermeiden. Ja ehm. Wenn der Zeiger nicht richtig ist ... was dann? Wie muss ich das denn richtig initialisieren? Ich hoffe mal das der Fehler darauf beruht, aber wenn ich eine Klasse genauso aufrufe die nicht SDL verwendet dann geht das trotzdem.

Hallo an alle, diesmal hab ich ein kleineres Problem. Ich will meine Header und Cpp Dateien, die ich öfters brauche, in den Includeordner meiner Entwicklungsumgebung packen. So weit, so gut. Mein Problem ist nur, dass wenn ich den Header eintrage und die Funktion aufrufen will, er mir diese als kleine Syntax-Vorschau anzeigt, doch dann rummeckert: "undefined reference to ...." Gut das Problem ist auch schnell gelöst indem ich in Code::Blocks bei "Project->Add Files" die Dateien zu meinen aktuellen Projekt hinzufüge. Nur das wird doch sehr nervig, umso mehr Dateien es werden. Was mir auch auffällt ist, dass in dem Include Ordner von C::B nur Headerdateien sind. Woher bzw. wie wissen die Header wo ihre Cpp Dateien liegen? Also mein Problem ist, dass ich meine eigenen Header genauso einfach einbinden möchte wie man es z.B. mit der math oder iostream machen kann. Einmal mit include eingebunden und man kann alle Funktionen nutzen. Ich will dafür nicht extra in jedem Projekt wo ich die Dateien brauche "Project->Add Files" aufrufen und jede Header und Cpp Datei manuell hinzufügen. Danke schonmal für eure Hilfe. Mr. Miyagi

Ich hab nun ein kleines Beispiel geschrieben in dem das Problem auftritt. Ich habe erst versucht eine normale Klasse zu erstellen, doch die lief einwandfrei. Der Fehler tritt also nur auf wenn ich OpenGL und SDL verwende und dann im Publicteil die Variablen deklariere und versuche diese zu benutzen. Ich hänge einfach mal das Projekt von Code::Blocks an. Dort wird nur ein Vierreck mit einer einfachen Textur gerendert. Hab jeglichen Zusatz weggelassen um es so übersichtlich wie möglich zu halten. Wichtig ist noch zu sagen, dass man auf jedenfall die SDL Bibliotheken braucht um das Projekt überhaupt compilieren zu können. Einmal das normale SDL Developement Paket und SDL Image. Die beiden Pakete sind aber in der Zip enthalten. In Code::Blocks muss man dann im Linker noch folgende Bibliotheken angeben: -lmingw32 -lSDLMain -lSDL -lopengl32 -lglu32 -lSDL_image Hoffe ihr könnt mir helfen. Beispiel.zip

Danke, hab das Problem schon genauso gelöst. ^^ Nun hab ich aber ein anderes Problem. Ich kann meine Zeiger und Variablen nur Global deklarieren. Wenn ich sie im privaten Teil der Klasse deklariere, kennt meine Cpp Datei dazu zwar die Variablen und schreibt auch die richtigen Werte in diese, nur kann ich diese dann nicht verwenden. Immer wenn ich es versuche, dann blitzt kurz mein Fenster auf und ist auch gleich wieder weg. einfaches Beispiel if (done==FALSE) { ... } Dann wird das Programm einfach beendet obwohl done eine boolischer Variable ist und ich vorher in einer anderen Prozedur done den Wert false zugewiesen habe. Deklariere ich done nun global in der Cpp Datei funktioniert alles super. So gesehen funktioniert also alles. Mein schlaues Buch sagt mir aber, dass man globale Variablen möglichst vermeiden sollte und daran will ich mich auch halten.

Da ich mal annehme das die Instanz einer Klasse sich genauso verhällt wie eine lokale Variable. Sprich nur für den Anweisungsblock in dem sie deklariert ist auch gültig ist, werde ich da keine weiteren Probleme haben. (hoffe ich zumindest ^^) Falls meine Annahme nicht richtig ist, berichtigt mich bitte. Es könnte ja auch sein, dass die Instanz erst ihre Gültigkeit verliert in dem man explizit den Destructor aufruft. Ansonsten sag ich schon mal Danke.

Danke für deine Information. Ich kenne mich zwar überhaupt nicht aus mit std::vector, aber ich versuche mal etwas im Internet dazu zu finden. Ist Vector, wenn ich Daten hinein schreibe dann im Heap abgelegt ? Mir geht es ja darum, dass ich ich die Klasse in der das Array erstellt wird von "außen" aufrufe, es erstelle, mit Daten fülle, zum Hauptprogramm zurück kehre und dann durch eine Endlosschleife nur wieder die Daten abfrage. Oder sind die Daten nach Aufruf der Funktion aus der Klasse und Rückkehr zum Hauptprogramm durch den Destructor wieder gelöscht ?

Da niemand antwortet, habe ich mich bestimmt nur umständlich ausgedrückt. Was ich machen will: Ich will in einer Klasse ein Array erstellen. Man übergibt Werte durch eine Funktion, die dann zur Größenbestimmung des Arrays dienen (nicht das Problem). Danach wird das Array einmalig(!) mit Daten gefüllt. Nun ruft eine andere Funktion (in einer Endlosschleife) immer wieder die Daten aus dem Speicher ab. Die Schleife wird erst durch Tastendruck beendet. Meine Lösungsidee: Ich erstelle das Array im Heap und die Funktion die, die Daten braucht bekommt sie über Zeiger auf die Werte. Mein Problem: Wie würde der Syntax dazu aussehen und vorallem, warum ?! Ich habe zwar C++ in 21 Tagen, aber das behandelt Zeiger und Arrays seperat und damit kenne ich keine Kombination aus beiden.

Hallo, wieder ein weiteres Problem das mich in meiner anfänglichen Zeit überfordert. Ich habe folgende Struktur: Hauptprogramm -> externe Klasse (Header u. Rumpf seperat) -> einmalige(!) Berechnungen der Konstruktionsdaten im Array speichern -> Arraydaten sollen nach dem einmaligen Aufruf des If Blocks weiter verwendet werden zum zeichnen eines Objekts -> Rückkehr zum Hauptprogramm ... Buffer leeren und auf Bildschirm ausgeben. (und wieder von vorne) Mein Problem sind nun die Daten in dem Array. In Delphi hab ich globale, dynamische Arrays angegeben dessen Größe und Werte nur einmal zur Laufzeit per if(done == false) ... ...Berechnungen... ... Ende des Blocks ... (done = true) berechnet werden und danach griff die Zeichenroutine immer wieder auf die Werte im Array zurück. Das Problem ist ja das die Variablen in C++ die in einen Anweisungsblock deklariert wurden ja nur für diesen gelten. Hab da was mit Zeigern gelesen und die Werte im Heap speichern, aber da blick ich noch nicht so ganz durch und ich wollte es vermeiden ein Array vorher im Hauptprogramm zu deklarieren. Wie gehe ich nun am besten ran an mein Problem? Noch was: Wenn ich eine kleine Testroutine in die Klasse schreibe die mir nur ein Viereck zurückgeben soll muss ich auch einen Pointer auf die Klasse angeben da mir das Programm, wenn ich eine Variable verwende, nur einen Grafikfehler ausgibt. Wie ist das zu erklären? Danke schonmal für eure Hilfe.

Hab nun alles hinbekommen. Mein Problem war, dass meine Datei "Dateiname.cpp.c" (das letzte C fügte das Programm hinzu) hieß, da ich die Endung aus Gewohnheit immer hingeschrieben habe. Nur der von Code::Blocks mitgelieferte Compiler erkennt ja anhand der Dateiendung ob es sich um C oder C++ handeln soll. Mein Betriebssystem habe ich gerade mal neu installiert und vorher war "Dateiendungen einblenden" aktiviert, was nun nicht der Fall war und ich dadurch nicht das letzte C gesehen habe. Mir hätte es zwar schon merkwürdig vorkommen müssen, dass generell nirgens Dateiendungen angezeigt werden außer bei den "gefälschten" cpp Datein aber naja ... dummer Fehler, aber man sieht ja bekanntlich nur das was man sehen will. Danke für die Hilfe.

Ja ich hab mich jetzt mal weiter informiert. Es hieß zwar GNU GCC, aber das hat nichts geändert. Es scheint ein C-Compiler zu sein. In den Dateieigenschaften steht auch, dass ihr relativer Pfad D:\...\Dateiname.c ist obwohl sie als .cpp abgespeichert sind. Soviel also dazu. Danke für die Informationen. So hab ich wenigstens darauf geachtet. Werde mich erstmal auf die Suche machen nach C++ Compiler für Code::Blocks.

Danke ... ... nur meine Frage ist dann: " Wo stelle ich das in Code::Blocks ein? " Ich verwende den GNU CC Compiler der mit dabei ist und wollte diesen auch behalten. Ich linke zur Zeit in einem kleinen Template zur Initialisierung von OpenGL und SDL: -lmingw32 -lSDLMain -lSDL -lopengl32 -lglu32 Liegt hier vielleicht schon der Fehler oder kann man irgendwas in den Optionen von Code::Blocks einstellen? Bin halt erst seit ein paar Tagen richtig dabei und begreife das mit dem linken und einstellen noch nicht so. Kann es sein das lmingw32 eine C Bibliothek ist ?