instanz zurückgeben...

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