instanz zurückgeben...

ChrissiB schrieb:

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

ChrissiB

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.

class s2 
{ 
  private: 
          typedef std::vector<boost::shared_ptr<s1> > vec;
          typedef std::vector<boost::shared_ptr<s1> >::iterator   vec_it; 
          vec s1Vector; 

  public: 
          void Instanz_hinzufügen() 
          { 
            // c1 *x = new c1();
            s1Vector.push_back(boost::shared_ptr<s1>());  
          } 

          void methode_der_Klasse_s1_aufrufen() 
          { 
            vec_it it; 

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

            }   
          }   

};

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

ChrissiB

Edit: Mist, der hat alle genommen..

ChrissiB

Edt: weg..

ChrissiB

Edit: gelöscht

ChrissiB

Edit: boah, 4 mal

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

ChrissiB

killer schrieb:

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 Connection
{
public:
Connection(std::auto_ptr<Socket>& spSocket)
: spSocket_(spSocket)
{
}
private:
boost::shared_ptr<Socket> spSocket_;
std::string Nickname;
};

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

ChrissiB

AH.. Ich merke gerade, dass ich zuviel editiert habe und nicht einen Beitrag übrig gelassen habe.
So sieht es aus:

#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..

was ist wenn die klasse X so ausschaut?

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

natürlich soll das objekt X in den vector...meinte nur ich wollte auf spSocket_ ne instanz zuweisen u halt nickname setzten wenn das X im vector ist...

hmmm
cu

ChrissiB

hmm schrieb:

natürlich soll das objekt X in den vector...meinte nur ich wollte auf spSocket_ ne instanz zuweisen u halt nickname setzten wenn das X im vector ist...

hmmm
cu

Du machst es doch schon richtig, der Kontruktor ist doch dafür gut geeignet.
Oder du erstellst setter-Methoden mit denen du andere Werte zuweisen kannst.
Falls du über den Iterator dann den Nickname haben willst, erstellst du getter-Methoden().

class Server
{
private: // Variablen
	   // Standard- und Copykonstruktor sind private. 
           // Nur Methoden dieser Klasse können auf sie zugreifen. 
	       Server() : m_serverSocket(port), clientcount(0) {};
		   Server( const Server& ); 

		   ///ServerSocket m_serverSocket; ?????

		   typedef std::vector<Connection> vector;
		   vector m_clients;
		   unsigned int clientcount;          

private: // Funktionen 
	       //void getIPAdress();
	       std::string getNickname();
		   void setNickname();

public: // Methoden
	   // Diese statische Methode erzeugt die einzige Instanz. 
           // Nur über diese Methode erhalten Anwender den Zugriff auf 
           // die Instanz. 
           static Server& getInstance(); 

		   void Server::AddClient(std::auto_ptr<Socket>& spSocket);
		   void SendMessageToAllClients(std::string message);
		   void SendMessageToClient(std::string nick, std::string message);
		   void receiveMessage();
};

main.cpp
-----------------

void main()
{
ServerSocket serverSocket(port);
std::auto_ptr<Socket> socket = serverSocket.accept();
Server::getInstance(serverSocket????????).AddClient(socket);

Server::getInstance().SendMessageToAllClients("Welcome to Server");

will von der main aus der klasse Server die instanz serverSocket
übergeben...weil ich die dort fürs receive brauche:

void Server::receiveMessage()
{
	char buffer[1024];

	serverSocket.receive(buffer, sizeof(buffer));

	std::cout << buffer << std::endl;
}

wie übergebe ich das am besten? hmmm irgendwie will das net recht so:
Server::getInstance(serverSocket).AddClient(socket);

hm?

cu

werd das bissal anders machen....serverSocket serversock; als instanz in Server klasse verwenden...

cu