Wie kann ein Listener beliebieg viele Verbindungsanfragen entgegennehmen
und auf Daten von aufgebauten Verbindungen hören?

Falls der Code auf einem UNIXoiden System laufen soll, würde ich mir mal poll(2) bzw select(2) anschauen, damit kannst du ein ganzes array aus file descriptoren (unter UNIX sind sockets ja nichts anderes) auf aktivität abfragen. Kannst also einen eventloop machen und eben in jeder iterationen die sockets mit wartenden daten abarbeiten.

Beliebig viele ist schon mal schlecht, da es je nach Betriebssystem und Speicher eine Grenze für offene Sockets gibt.

Mein Ansatz wäre einfach für jede Verbindungsanfrage einen neuen Socket aufmachen und wieder schließen wenn er nicht mehr gebraucht wird.

Also etwa so:

// Listener initialisieren

while (true) {
   ServerSocket sock;
   Listener.accept(sock);
   try {
      while (true) {
         // Nachricht aus socket holen
         socket >> nachricht;
         if (x) {  // x = Abbruchbedingung / Timeout -> Socket wieder schließen
            sock.disconnect();    // SEHR WICHTIG !!!
         } else {
            // Irgendeine Reaktion durch den Socket schieben
            socket << Nachricht;
         }
      }
   } catch ( SocketException& ) {}
}

ich hoffe das hilft dir etwas weiter.

Möchtest Du die Nachrichten aus den verschiedenen Sockets untereinander synchronisieren, dann empfehle ich die nutzung von stacks -> http://www.cppreference.com/wiki/stl/stack/start

Ein anderen Ansatz ist nachdem

accept()

erfolgreich aufgerufen worden ist einen neuen Thread zu starten um den Client zu dienen (Peer Thread). Der Listener Thread kann dann weiterhin auf eine neue Verbindung warten. Der Listener Thread fungiert als Dispatcher.

Jede Peer Thread dient ein Client und ist einfacher hand zu haben: Jeder Peer Thread hat seine getrennte Anfrage/Antwort Schleife. Am Ende des Threads wird das Socket freigegeben. Die Leistung leidet aber ein wenig darunter und es ist performanter poll() oder select() zu verwenden wie von psychoschlumpf vorgeschlagen. Ich finde die Lösung mit Threads aber eleganter und Strukturierter.

Im anderen Fall muss man "states" verwalten und die mit sockets verbinden was eigentlich ja auch ein Merhaufwand bedeutet. In C++ ist es alles schön in z.B. eine PeerSocket Klasse gepackt.