void TCPSyncServer::ListenForSynchronisations()
{
	IsConnected = false;

	m_pSocket = new boost::asio::ip::tcp::socket(m_IOService);

	m_pAcceptor->accept(*m_pSocket);

	if(m_pSocket->is_open())
	{
		IsConnected = true;
		++ClientCnt;

		m_ptrlSocket.push_back(m_pSocket);

		std::cout<<"Synchronisated successfully with Client!"<<std::endl;

		for(;;)
		{
			m_MsgRecBuffer = GetMessageFromAllClients();

			m_tReceiver::iterator it
			(
				m_MsgRecBuffer.begin()
			);

			for(; it != m_MsgRecBuffer.end(); ++it)
			{
				if(it->get<0>() > 0)
				{
					std::cout<<"Message from Client["<< it->get<2>() <<"]: ";

					std::vector<char>::size_type loop(0);

					for(; loop != it->get<0>(); ++loop)
					{
						if(loop == it->get<0>())
							std::cout<< it->get<1>()[loop] <<std::endl;
						else
							std::cout<< it->get<1>()[loop] <<std::endl;
					}
				}
				else if(it->get<0>() < 0)
					std::cout<<"[Error] Failed to handle message from client"<<std::endl;
			}
		}
	}
}

Wie mache ich es nun, dass jederzeit ein Client connecten kann? Ich bin jetzt einfach mal so dreist und poste den kompletten Code, vielleicht hat ja noch einer Verbesserungsvorschläge, denn mir gefällt die Klasse langsam nicht mehr:

#ifndef TCPSYNCSERVER_HEADER
#define TCPSYNCSERVER_HEADER

#include "StdIncludes.h"

namespace TCP
{

typedef std::vector<boost::tuple<std::size_t, 
								 std::vector<char>, 
								 unsigned int>> m_tReceiver;

class TCPSyncServer
{
	private:
		unsigned int									  ClientCnt;
		boost::asio::io_service                           m_IOService;
		boost::scoped_ptr<boost::asio::ip::tcp::acceptor> m_pAcceptor;
		boost::asio::ip::tcp::socket					  *m_pSocket;
		TCPSyncServer::m_tReceiver						  m_MsgRecBuffer; // For output
		boost::ptr_vector<boost::asio::ip::tcp::socket>   m_ptrlSocket;
		TCPSyncServer::m_tReceiver                        m_RecMsgVector; // For input

	public:
		TCPSyncServer(const unsigned int Port = 1337);

		void ListenForSynchronisations();

		void WriteToAllClients(const std::string &Message);

		m_tReceiver GetMessageFromAllClients();

		bool IsConnected;
};

} // Namespace TCP

#endif TCPSYNCSERVER_HEADER
#include "TCPSyncServer.h"

namespace TCP
{

TCPSyncServer::TCPSyncServer(const unsigned int Port) :
	IsConnected(false),
	ClientCnt(0)
{
	m_pAcceptor.reset
	(
		new boost::asio::ip::tcp::acceptor
		(
			m_IOService, 
		    boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), Port)
		)
	);

	m_pSocket = new boost::asio::ip::tcp::socket(m_IOService);
} 

void TCPSyncServer::ListenForSynchronisations()
{
	IsConnected = false;

	m_pSocket = new boost::asio::ip::tcp::socket(m_IOService);

	m_pAcceptor->accept(*m_pSocket);

	if(m_pSocket->is_open())
	{
		IsConnected = true;
		++ClientCnt;

		m_ptrlSocket.push_back(m_pSocket);

		std::cout<<"Synchronisated successfully with Client!"<<std::endl;

		for(;;)
		{
			m_MsgRecBuffer = GetMessageFromAllClients();

			m_tReceiver::iterator it
			(
				m_MsgRecBuffer.begin()
			);

			for(; it != m_MsgRecBuffer.end(); ++it)
			{
				if(it->get<0>() > 0)
				{
					std::cout<<"Message from Client["<< it->get<2>() <<"]: ";

					std::vector<char>::size_type loop(0);

					for(; loop != it->get<0>(); ++loop)
					{
						if(loop == it->get<0>())
							std::cout<< it->get<1>()[loop] <<std::endl;
						else
							std::cout<< it->get<1>()[loop] <<std::endl;
					}
				}
				else if(it->get<0>() < 0)
					std::cout<<"[Error] Failed to handle message from client"<<std::endl;
			}
		}
	}
}

/// Send the message to all clients
void TCPSyncServer::WriteToAllClients(const std::string &Message)
{
	boost::ptr_vector<boost::asio::ip::tcp::socket>::iterator it
	(
		m_ptrlSocket.begin()
	);

	for(; it != m_ptrlSocket.end(); ++it)
	{
		boost::asio::write((*it),
						   boost::asio::buffer(Message),
						   boost::asio::transfer_all());
	}
}

m_tReceiver TCPSyncServer::GetMessageFromAllClients()
{
	std::vector<char> Message(1500); // 1,5KB Default size of segment
	boost::system::error_code ignored_error;

	boost::ptr_vector<boost::asio::ip::tcp::socket>::iterator it
	(
		m_ptrlSocket.begin()
	);

	for(; it != m_ptrlSocket.end(); ++it)
	{
		m_RecMsgVector.clear();

		const std::size_t length = it->read_some(boost::asio::buffer(Message),
												 ignored_error);

		m_RecMsgVector.push_back(boost::make_tuple(length, Message, ClientCnt));
	}

	if(ignored_error)
		throw boost::system::system_error(ignored_error);

	return m_RecMsgVector;
}

} // Namespace TCP

Vielleicht hilft mir ja nochmal mein Schnucki Dravere. Ansonsten danke an Alle im Voraus!

Danke im Vorrraus (HA! Ausgetricks0rt )

Das ist als netter Hinweis für zukünftige Posts gedacht, also nicht persönlich nehmen.

EDIT:
Oh... du fühlst dich vernachlässigt oder? Du darfst auch mein tlayner sein wenn du willst *Kopf treichel*

Nein ernsthaft, die Fragen waren ernst gemeint. Danke für Antworten!

Zum Thema:
Wenn Du mit einer Endlosschleife in einem extra Thread arbeitest, dann ist das quasi eine schlechte Nachbildung der asynchronen Mechanismen von asio.

Besser ist es, gleich alles asynchron zu machen.

Die asynchronen Funktionen haben vor allem den großen Vorteil, dass man sie jederzeit sicher abbrechen kann. Bei den synchronen Funktionen ist das meist gar nicht oder nur mit sehr viel Aufwand möglich.

Wie man einen asynchronen Server aufbaut, der auch mehrere Clients gleichzeitig verkraften kann, wird z.B. in den HTTP-Server-Beispielen gezeigt.

Es wäre schon net, wenn Du etwas weniger Kot von Dir geben würdest.

Hättet ihr wohl gerne^^

Tachyon schrieb:

Wenn Du mit einer Endlosschleife in einem extra Thread arbeitest, dann ist das quasi eine schlechte Nachbildung der asynchronen Mechanismen von asio.

Hm okay, dachte ich mir schon.

Tachyon schrieb:

Die asynchronen Funktionen haben vor allem den großen Vorteil, dass man sie jederzeit sicher abbrechen kann.

Inwiefern abbrechen?

Tachyon schrieb:

Wie man einen asynchronen Server aufbaut, der auch mehrere Clients gleichzeitig verkraften kann, wird z.B. in den HTTP-Server-Beispielen gezeigt.

Öhmöhmöhm... warum denn HTTP? Über TCP können doch auch mehrere connecten

Danke soweit erstmal meine kleinen Puffelhäschen

Tachyon schrieb:

Wie man einen asynchronen Server aufbaut, der auch mehrere Clients gleichzeitig verkraften kann, wird z.B. in den HTTP-Server-Beispielen gezeigt.

Öhmöhmöhm... warum denn HTTP? Über TCP können doch auch mehrere connecten

Lies dir nochmal GENAU durch was er geschrieben hat!
Da steht nicht du sollst jetzt was mit HTTP machen, sondern in die HTTP-Server-examples (wahrscheinlich von boost::asio) schauen, da steht drinnen wie man mit mehreren Clients umgehen kann.

Öhmöhmöhm... warum denn HTTP? Über TCP können doch auch mehrere connecten

Weil das eine in der Anwendungsschicht liegt, und das andere in der Transportschicht. Deshalb ist das auch kein Widerspruch zueinander.