ich habe 2 klassen:
zb.:

class s1
{
  public:
          void fahren();
};

class s2
{
  public:
          void hinzufügen()
          { 
            s1 x; // instanz der klasse s1 erstellen
            // will das zurückgeben in private dieser klasse.....damit die  
            // methode ausführen diese instanz verwenden kann...

          }

          void ausführen()
          {

          }

};

also ich habe 2 klassen...in klasse 2 erstelle ich in einer methode eine instanz der klasse 1...nun wird aber immer die instanz der klasse 1 wieder gelöscht wenn die methode hinzufügen fertig ist...will das objekt irgendwie zurückgeben damit ich es in methode ausführen verwenden kann...wie geht das?

cu

Das nennt sich Hat-Beziehung, ein gutes Stichwort zu googlen.
Du kannst auch noch im Konstruktor das Objekt gleich mit richtigen Werten initialisieren.

cu

Oh sorry, habe dich falsch verstanden
Benutze std::vector in der Klasse s2, somit kannst du das realisieren

class s2 
{ 
  private:
          typedef std::vector <s1*>	       CVector;
          typedef std::vector <s1*>::iterator   CVector_it;
          CVector s1Vector;

  public: 
          void Instanz_hinzufügen() 
          { 
            s1 x;
            s1Vector.push_back(&x); 
          } 

          void Instanz_() 
          { 
            CVector_it it;

            // alle elemente des vector durchgehen 
            for (it = s1Vector.begin(); i != s1Vector.end(); ++i) 
            {
              // will eine methode der klasse s1 aufrufen
              ((*it)->s1).methode();

            }  
          }  

};

müsste so klappen, ich weiß nicht genau ob das klappt mit dem aufruf einer methode der klasse s1? cu

Du hast im vector ein Zeiger auf s1. in hinzufuegen() erstellst du ein Objekt der Klasse.
Nun fügst du das Objekt dem vector hinzu, sodass der vector einen Zeiger auf dieses Objekt hat.
Die Methode wird verlassen und dein Objekt wird zersört.
Was passiert aber nun mit dem Zeiger, er zeigt ja auf was, dass es gar net mehr gibt.

einfach dann ohne zeiger auf vector:

typedef std::vector <s1>           CVector; 
          typedef std::vector <s1>::iterator   CVector_it;

dann so die methode der klasse s1 aurufen?

(it).methode();

danke
cu

Du hast im vector ein Zeiger auf s1. in hinzufuegen() erstellst du ein Objekt der Klasse.
Nun fügst du das Objekt dem vector hinzu, sodass der vector einen Zeiger auf dieses Objekt hat.
Die Methode wird verlassen und dein Objekt wird zersört.
Was passiert aber nun mit dem Zeiger, er zeigt ja auf was, dass es gar net mehr gibt.

einfach dann ohne zeiger auf vector:

typedef std::vector <s1>           CVector; 
          typedef std::vector <s1>::iterator   CVector_it;

dann so die methode der klasse s1 aurufen?

(it).methode();

danke
cu

So müsste es gehen. Du hast halt ein extra Aufruf des Copy-Konstruktor.
Du könntes das auch z.b. mit boost::shared_ptr lösen, da dieser sich um das Aufräumen keiner Daten auf den Heap kümmert.

ich schau mir das mit boost mal an...
wie schaut das dann mit boost::shared_ptr aus? auf dem heap wird ja wieder alles selber gelöscht nach prog ende? oder meinst du was anderes?

cu

So müsste es gehen. Du hast halt ein extra Aufruf des Copy-Konstruktor.
Du könntes das auch z.b. mit boost::shared_ptr lösen, da dieser sich um das Aufräumen keiner Daten auf den Heap kümmert.

ich schau mir das mit boost mal an...
wie schaut das dann mit boost::shared_ptr aus? auf dem heap wird ja wieder alles selber gelöscht nach prog ende? oder meinst du was anderes?

cu

Nein, die Daten werde auf dem Heap nach Programmende nicht gelöscht.
Du löscht die Daten mit delete.
Es sieht ungefähr so aus: std::vector<boost::shared_ptr<s1> > vec;
und eintragen mit vec.push_back(boost::shared_ptr<s1>());
Das Forum war grade down, konnt net früher schreiben.

seit wann muss ich das das objekt das ich statisch anlege mit delete löschen? sorry aber klingt irgendwie unlogisch...

cu

Nein, muss du nicht.
Ich meine was anderes, habe schon weitergedacht
boost::shared_ptr legt ein Objekt auf dem Heap ab. Es kümmert sich komplett um die Speicherverwaltung, d.h. du musst kein Objekt erzeugen und auch dieses nicht löschen mittels delete.
Du arbeites also mit deinem Objekt über diesen shared_ptr.
Du musst ja das Objekt auf dem Heap anlegen, da es, wenn es auf dem Stack liegt, nach dem Gültigskeitbereich einer lokalen Variable gelöscht wird. (wie ich schon mal geschrieben habe)
Ein Smart Pointer ist praktisch, du müsstest nämlich sonst immer vor Programmende die ganzen deletes aufrufen, damit der Speicher wieder frei wird.

ok ich leite mal weiter ab....ich muss das objekt auf dem heap anlegen:
zb so:

c1 *x = new c1();

da is einfach ein pointer auf das object...welches auf dem heap angelegt wurde....
ja dann ich ja klar das man das auch wieder mit delete löschen muss!

wenn ich das objekt auf dem stack anlege dann wird es wenn die methode Instanz_hinzufügen() ausgeführt wurde wieder gelöscht...dann sind ja smartpointer richtig nette sachen;-)

kann sowas nicht funktionieren:

void c1& getInstance() { 
            c1 x; // objekt der klasse c1 erzeugen
            return x; // und dieses zurückgeben... 
        }

cu

kann sowas nicht funktionieren:

void c1& getInstance() { 
            c1 x; // objekt der klasse c1 erzeugen
            return x; // und dieses zurückgeben... 
        }

cu

nein, erstmal gehört das void bestimmt weg
du hast nun das selbe Problem wie bei den Zeigern:
Du hekommst eine ungültige Refernz, da das lokale Objekt zerstört wird.
Du könntest aber eine Kopie zurückgeben, ich finde den Weg über Smart-Pointer aber besser.

nun so ok?
also das boost::shared_ptr<s1>() macht sowas wie c1 *x = new c1(); ?
die methode der klasse s1 ruf ich jetzt auch richtig auf?
muss mal erklären wie so smart pointer funktionieren;-) smart pointer scheinen nett zu sein

cu

auf meinen letzten post:
-----------------------
nun so ok?
also das boost::shared_ptr<s1>() macht sowas wie c1 *x = new c1(); ?
die methode der klasse s1 ruf ich jetzt auch richtig auf?
muss mal erklären wie so smart pointer funktionieren;-)

cu

leichte edit problems *g*

auf meinen letzten post:
-----------------------
nun so ok?
also das boost::shared_ptr<s1>() macht sowas wie c1 *x = new c1(); ?
die methode der klasse s1 ruf ich jetzt auch richtig auf?
muss mal erklären wie so smart pointer funktionieren;-)

cu

http://ootips.org/yonat/4dev/smart-pointers.html
Lesde das durch, das soll deine Fragen beantworten.
Und ja, die Methode wird aufgerufen.
Ich verweise nochmal auf meinem Beitrag, dass dies in einem C++-Code zeigt.
Edit: Besonders die Sektion "Why: STL containers" ist gut für dich, da sie das gleiche Problem beschreibt.

class Sock
{
private:
typestf std::vector<Connection> CVector;
typedef std::vector<Connection>iterator CVector_it;

CVector m_Connection;
unsigned int connectionObjectcount;
public:
void Connection_Instanz_hinzufügen()
{
// meine accept methode in klasse Socket gibt mir:
// auto_ptr<Socket> zurück...
std::auto_ptr<Socket> spSocket = m_serverSocket.accept();
Connection client(spSocket);
m_Connection.push_back(client);
connectionObjectcount++;
}

void setConnectionNickname()
{
CVector_it it = m_Connection.begin() + ConnectionObjectcount;

(it).Nickname = "User1";
}
};

ich weiß nicht weiter;-( .... bitte um denkanstoß!

cu

#include <iostream>
#include <vector>
#include <boost/shared_ptr.hpp>

class X
{
public:
    void method();
};

void X::method()
{
    std::cout << "method()" << std::endl;
}

class Y
{
    typedef std::vector<boost::shared_ptr<X> > vector;
    vector vec;
public:
    void add();
    void printall();
};

void Y::add()
{
    vec.push_back(boost::shared_ptr<X>(new X));
}

void Y::printall()
{
    vector::iterator it = vec.begin();
    while(it != vec.end())
    {
        (*it)->method();
        ++it;
    }
}

int main()
{
    Y obj;
    obj.add();
    obj.add();
    obj.printall();
}

Den Rest machsts aber nun selber..

class X
{
private:
	boost::shared_ptr<Socket> spSocket_;
         std::string nickname; 
public:
	Connection(std::auto_ptr<Socket>& spSocket)
		: spSocket_(spSocket)
	{
	}
};

will dann sp_Socket in den vector geben...u dann nickname setzten mit iterator....

cu