Du schreibts dir eine Funktion die den Zeiger zutück gibt.
So wie des es allerding ejtzt gemacht hast wird es auch schlecht funktionieren.

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

class Einlesen{ private:      Punkte* punkte;      // ...................... public:      Einlesen();      ~Einlesen();            Punkte* get_Puntke();      // ................... };     //in der cpp datei   void Einlesen::speichern(){      punkte = new Punkte;      punkte->setYA(zeile[0]);      punkte->setXA(zeile[1]);      punkte->setYE(zeile[2]);      punkte->setXE(zeile[3]); }   Punkte* Einlesen::get_Puntke(){        return  punkte; }       // und dann bei klasse B deine berechnungs funktion     void B::berechene(){     Punkte* punkte;     punkte = obj_Einlesen.get_Puntke();   // und nun kannst du ganz normal weiterarbeiten   //............ }

Ach und bitte benutze CODE Tags
also ["CODE"] ["/CODE"] oder ["CPP"] ["/CPP"]
ohne " "

Supi, so ähnlich hat ichs schon versucht, wusste nur nicht das man vor Funktionen auch Zeiger schreiben kann. Werd das direkt mal versuchen.

Zitat von 3Cyb3r

Ach und bitte benutze CODE Tags
also ["CODE"] ["/CODE"] oder ["CPP"] ["/CPP"]
ohne " "

Wie meinst du das ? Mach ich das nicht seit dem ersten Post ?

Zitat von 3Cyb3r

war das jetzt ironisch gemeint oder willst du mich aufn arm nehmen?

Ich vermute einfach, dass du es nicht weißt.

Gruß

Code :

1 2 3

void B::berechene(){     Punkte* punkte;     punkte = obj_Einlesen.get_Puntke();

Muss ich, um in Klasse B eine Funktion in Klasse Einlesen aufrufen zu können, nicht erst wieder ein Objekt der Klasse Einlesen erzeugen ?
Anders komm ich an die getPunkte() Funktion doch gar nicht ran, oder ?

Ja brauchst du.
Dafür habe ich "obj_Einlesen" geschreiben dies wird bei dir ja irgendwo vorhanden sein oder?
Achso und das mit den Code Tags hattest du einmal vergessen und ich hatte nur den in erinnerung und nicht die davor -.-

@ deepthroat da liegst du wohl falsch

Okay, danke, jetzt hab ichs endlich hinbekommen und es funktioniert

Zum Abschluß hät ich noch die Frage ob jmd ein gutes Internettutorial oder aber auch ein gutes Buch empfehlen kann, was das ganze Thema mit Objekten und Zeigern und so behandelt. Weil ich fürchte das es nicht das letzte Mal war das ich sowas machen muss und nächstes Mal will ich schlauer sein

Zitat von 3Cyb3r

@ deepthroat da liegst du wohl falsch

Tja, das kann sein. Aber wenn du es wissen würdest wäre ein Leichtes gewesen die Frage zu beantworten... ?! Entweder bist du dir dann doch nicht so sicher, oder du bist dir sicher, machst es aber nicht richtig, oder die Frage ist so unter deinem Niveau das du einfach nicht darauf antworten willst

Gruß

Code :

1 2 3 4 5 6 7

void Einlesen::speichern(){      punkte = new Punkte;      punkte->setYA(zeile[0]);      punkte->setXA(zeile[1]);      punkte->setYE(zeile[2]);      punkte->setXE(zeile[3]); }

Dieser Abschnitt ist nicht wirklich gut gelöst! Dir ist ja sicher bewusst: Zu jedem new gehört ein delete!

Stell dir mal vor, der Benutzer dieser Klasse kennt sich nicht so gut aus und verwendet halt speichern zweimal. Der alte Speicher von punkte kann nicht mehr erreicht werden, ausser der User hat irgendwo noch getPunkte verwendet und der Zeiger darauf ist noch in Reichweite.

Wesentlich schöner wäre es, wenn man im Konstruktor punkte auf 0 stellt und dann speichern entsprechend erweitert:

Code :

1 2 3 4 5 6 7 8 9 10

void Einlesen::speichern() {      if(punkte)             delete punkte;      punkte = new Punkte;      punkte->setYA(zeile[0]);      punkte->setXA(zeile[1]);      punkte->setYE(zeile[2]);      punkte->setXE(zeile[3]); }

Grundsätzlich sollte man bei Funktionen wie dieser, welche auf dem Heap Speicher alloziert ohne direkte Verwendung und ohne sich selbst um das Aufräumen kümmert den Speicher direkt zurückgeben und nicht erst über eine andere Methode, da so sehr oft wunderschöne Speicherlecks entstehen.

Grundsätzlich gibt es wesentlich einfachere Mittel um flexible und schnelle Datenverarbeitung zu ermöglichen. C++ und die STL bieten uns mit den Ein- und Ausgabestreams genau solche Mittel an. Sie erlauben uns durch die geschickt gewählten Vererbungen äusserst flexible Klassen zu schreiben. So auch bei diesem Problem.

Eine sehr einfache Möglichkeit bietet uns das Serialisieren. Wir schreiben die nötigen Daten einfach binär in die Datei, sozusagen ein Speicherabbild. Entsprechend lesen wir sie auch wieder ein. Hier mal ein kleines Beispiel dazu mit einer möglichen Implementierung:

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83

#include <iostream> #include <fstream>   class Serializer { private:     std::ostream& m_log;   public:     Serializer(std::ostream& log) : m_log(log)     {     }       void WriteToStream(const void* data, size_t len, std::ostream& strm);     void ReadFromStream(const void* dest, size_t destsize, std::istream& strm); };   void Serializer::WriteToStream(const void* data, size_t len, std::ostream& strm) {     char* binpointer = (char*)data;     try     {         for(size_t i = 0; i < len; ++i)             strm << *(binpointer + i);     }     catch(std::exception& ex)     {         m_log << ex.what() << std::endl;     } }   void Serializer::ReadFromStream(const void* dest, size_t destsize, std::istream& strm) {     char* binpointer = (char*)dest;     try     {         for(size_t i = 0; i < destsize; ++i)             strm >> *(binpointer + i);     }     catch(std::exception& ex)     {         m_log << ex.what() << std::endl;     } }     //  Beispiel   #pragma pack(1)   struct Circle {     float x, y, z, radius; };   #pragma pack()   int main(int argc, const char* argv[]) {     std::ofstream errorlog("Errors.txt", std::ios::out);     Serializer seri(errorlog);       std::ofstream ofstr("output.bin", std::ios::binary);     Circle ci;     ci.x = 1.0f;     ci.y = 2.0f;     ci.z = 3.5f;     ci.radius = 22.5f;       seri.WriteToStream(&ci, sizeof(ci), ofstr);     ofstr.close();       Circle in;     std::ifstream istr("output.bin", std::ios::binary);     seri.ReadFromStream(&in, sizeof(in), istr);       std::cout << in.x << " " << in.y << " " << in.z << " " << in.radius;       errorlog.close();     istr.close();       return 0; }

Zitat von deepthroat

Tja, das kann sein. Aber wenn du es wissen würdest wäre ein Leichtes gewesen die Frage zu beantworten... ?! Entweder bist du dir dann doch nicht so sicher, oder du bist dir sicher, machst es aber nicht richtig, oder die Frage ist so unter deinem Niveau das du einfach nicht darauf antworten willst

Ich habe darauf keine Antwort geschrieben, weil ich weiß wenn ich dies getan hätte, dann wäre irgendein Spruch von irgendwem gekommen blabla nachgucken kann ich das auch oder so.

Um das hier zu beenden: Ich war mir auch nicht mehr ganz sicher, also hab ich nachgeschaut:

float printf=%f
float scanf=%f
double printf=%f
double scanf=%lf