Mit meinem Chat geht es schon ganz schön voran! Doch hier und da zeigen sich noch die Probleme und die Fragen!

Hier mein Code:

Server.cpp

//Server.cpp

#include <windows.h>
#include <winsock.h>
#include <iostream>

using namespace std;

int WinSockStart();
void thread_send();
void thread_receive();

long handle;
SOCKET sock_main, sock_specified;

int main()
{
  SOCKADDR_IN server;
  memset(&server, 0, sizeof(SOCKADDR_IN));
  server.sin_family = AF_INET;
  server.sin_port = htons(12345);
  server.sin_addr.s_addr = ADDR_ANY;

  handle = WinSockStart();
  if(handle == SOCKET_ERROR)
    cout << "Fehler! WinSock konnte nicht gestartet werden!\n";
  else
    cout << "WinSock gestartet!\n";

  sock_main = socket(AF_INET, SOCK_STREAM, 0);
  if(sock_main == INVALID_SOCKET)
    cout << "Fehler! Socket konnte nicht erstellt werden!\n";
  else
    cout << "Socket erstellt!\n";

  handle = bind(sock_main, (SOCKADDR*)&server, sizeof(SOCKADDR));
  if(handle == SOCKET_ERROR)
    cout << "Fehler! Socket konnte nicht an den Server gebunden werden!\n";
  else
    cout << "Socket wurde an den Server gebunden!\n";

  handle = listen(sock_main, 10);
  if(handle == SOCKET_ERROR)
    cout << "Fehler! Aktion 'listen' konnte nicht ausgeführt werden!\n";
  else
    cout << "Server lauscht...\n";

  sock_specified = accept(sock_main, NULL, NULL);
  if(sock_specified == INVALID_SOCKET)
    cout << "Fehler! Verbindung zu neuem Socket fehlgeschlagen!\n";
  else
    cout << "Neue Verbindung akzeptiert!\n";

  HANDLE handle1 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)thread_send, 0,0,0);
  HANDLE handle2 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)thread_receive, 0,0,0);
  WaitForSingleObject(handle1, INFINITE);
  WaitForSingleObject(handle2, INFINITE);
  closesocket(sock_main); 
  closesocket(sock_specified); 
  WSACleanup(); 
}

int WinSockStart()
{
  WSADATA wsa;
 return WSAStartup(MAKEWORD(2,2), &wsa);
}

void thread_send()
{
  char data_send[256];

  while(handle != SOCKET_ERROR)
  {
    gets(data_send);
    handle = send(sock_specified, data_send, strlen(data_send), 0);
    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Senden von Datenpaketen!\n";
     break;
    }
  }

}

void thread_receive()
{
  char data_received[256];

  while(handle != SOCKET_ERROR)
  {
    handle = recv(sock_specified, data_received, 256, 0);
    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Empfangen von Datenpaketen!\n";
     break;
    }
    else
    {
      data_received[handle] = '\0';
      cout << "-> " << data_received << '\n';
    }
  }
}

Client.cpp

//Client.cpp

#include <windows.h>
#include <winsock.h>
#include <iostream>

using namespace std;

int WinSockStart();
void thread_send();
void thread_receive();

long handle;
SOCKET sock;

int main()
{
  SOCKADDR_IN server;
  memset(&server, 0, sizeof(SOCKADDR_IN));
  server.sin_family = AF_INET;
  server.sin_port = htons(12345);
  server.sin_addr.s_addr = inet_addr("127.0.0.1");  

  handle = WinSockStart();
  if(handle == SOCKET_ERROR)
    cout << "Fehler! WinSock konnte nicht gestartet werden!\n";
  else
    cout << "WinSock gestartet!\n";

  sock = socket(AF_INET, SOCK_STREAM, 0);
  if(sock == INVALID_SOCKET)
    cout << "Fehler! Socket konnte nicht erstellt werden!\n";
  else
    cout << "Socket erstellt!\n";

  handle = connect(sock, (SOCKADDR*)&server, sizeof(SOCKADDR));
  if(handle == SOCKET_ERROR)
    cout << "Fehler! Verbindung zum Server fehlgeschlagen!\n";
  else
    cout << "Socket wurde mit Server verbunden!\n";

  HANDLE handle1 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)thread_send, 0,0,0);
  HANDLE handle2 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)thread_receive, 0,0,0);
  WaitForSingleObject(handle1, INFINITE);
  WaitForSingleObject(handle2, INFINITE);
  closesocket(sock);
  WSACleanup(); 
}

int WinSockStart()
{
  WSADATA wsa;
 return WSAStartup(MAKEWORD(2,2), &wsa);
}

void thread_send()
{
  char data_send[256];

  while(handle != SOCKET_ERROR)
  {
    gets(data_send);
    handle = send(sock, data_send, strlen(data_send), 0);
    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Senden von Datenpaketen!\n";
     break;
    }
  }

}

void thread_receive()
{
  char data_received[256];

  while(handle != SOCKET_ERROR)
  {
    handle = recv(sock, data_received, 256, 0);
    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Empfangen von Datenpaketen!\n";
     break;
    }
    else
    {
      data_received[handle] = '\0';
      cout << "-> " << data_received << '\n';  }
    }
}

Meine 7 Fragen:

1. Ist diese Methode die übliche Methode, um einen Chat zu programmieren??

2. Nutzt ICQ beispielsweise auch diese Methode? Wenn ja, nutzt ICQ dann den Port 80 oder auch einen willkürlichen? Denn beim Öffnen meines Chats kommt erst mal ne Firewallwarnung, bei ICQ hingegen nicht...

3. Wenn ich beispielsweise Hallo an den Clienten schicke, und dieses Hallo dann im Chararray data_received steckt, wie kann ich ein solches Array dann vergleichen? Angenommen ich möchte wissen, ob der Server "Hallo" schrieb, dann funktioniert ja folgender Code nicht:

if(data_received == "Hallo")

4. Wenn ich ein Chararray deklariere, und ihm nachher einen neuen Wert zuweise, und diesen dann wieder überschreiben will, dann geht das nicht mehr, aber wieso nicht:
[code]char data[] = "Hallo";
data[] = "Tschüs"; //funktioniert nicht
char data[] = "Tschüs"; //funktioniert![quote]

5. Gibt es einen Unterschied zwischen char data = "Hallo" und char data[] = "Hallo"??

6. In meinem Chat gibt es noch ein Problem, und zwar wenn man gerade einen längeren Text schreibt, und der Partner sendet seinen Text, so wird der längere Text unterbrochen und das vom Partner gesendete wird angezeigt. Wie kann ich das in Einklang bringen, sodass ich nicht mit einer Nachricht beim Schreiben meiner Nachricht unterbrochen werde??

7. Ist es denn iwi möglich, ein Konsolenprogramm im Hintergrund zu öffnen, also so dass die Konsole versteckt bleibt??

Ich hoffe ich habe mich verständlich ausgedrückt

Viele Grüße
Gapa

sock_specified = accept(sock_main, NULL, NULL);

Sowas ist echt grottig und entspricht nicht den korrekten Argumenten der accept-Funktion.

Zu deinen Fragen:

4. Das Wort "Hallo" besitzt 5 Zeichen. Also die Array-Elemente 0 bis 4. "Tschüß" hingegen, was ja auch noch Werte der "extended ASCII table" nutzt, besitzt 6 zeichen. Die zugehörigen Array-Elemente sind also 0 bis 5. Da du aber mit

char data[] = "Hallo";

nur ein ARray mit der größe für 5 Elemente anlegst, ist es doch klar, dass "Tschüs" da nicht reinpasst....was dann wieder auf meine erste Frage schließt und sie damit indirekt beantwortet...nichts für ungut.

Trotzdem Danke für die Erläuterung auf Frage 4!
Ich gestehe, dass ich mich mit C-Arrays gar nicht so gut auskenne, doch das ist noch kein Grund für eine solche Schlussfolgerung!

Und wenn du etwas an meiner accept-Funktion auszusetzen hast, dann könntest du ja auch wenigstens einen besseren Vorschlag bringen, oder?
Kann ja gut sein, dass diese Funktion nicht ordnungsgemäß aufgerufen wird, und ich bin für Verbesserungsvorschläge gern zu haben, doch einfach so drann rumnörgeln hilft mir wirklich nicht weiter...

So far
Gapa

mainsocket = socket(AF_INET, SOCK_STREAM, 0); // tcp
if (mainsocket == -1)
{
    // Fehler
}
sockaddr_in addr;
addr.sin_addr.S_un.S_addr = INADDR_ANY; // jede ip
addr.sin_family = AF_INET;
addr.sin_port = htons(12345);  // der port
int status = bind(mainsocket, (sockaddr*)&addr, sizeof(addr));
if (status == -1)
{
    // da ist ein fehler passiert
}
sockaddr addr;
int lenght = sizeof(addr);
SOCKET newsock = accept(mainsocket, &addr, &lenght);
if (newsocket == -1)...

in der struktur addr bekommst du dann außerdem noch informationen über den client, also ip und sowas

mfg helferlein

Sag mal ist denn sowas zu fassen?
Dieser Code ist zu 100% mein Code!!!!!

Gapa schrieb:

meiner accept-Funktion

Funny boy.

SCNR

Wie gesagt, nimm es mir nicht persönlich, aber ich hab bei der ganzen Sache eben Bauchschmerzen, da es nicht zusammen passt. Zumal ich nicht jedermanns Lebensgeschichte in einem Forum verfolge, um dann auf eine Frage zu Antworten. Ich beziehe mich da immer schlichtweg auf das vorliegende Thema. Abgesehen davon sollte man nicht in Gefillden wie der Netzwerkprogrammierung rumfingern, wenn man nichteinmal mit C-Arrays umgehen kann. Das ist in dem Zusammenhang eine extrem große Sicherheitslücke. Außerdem kannst du ja auch locker die vector-Klasse benutzten.

@Topic

Also, accept() erwartet drei Parameter: 1. die ID des Serversocket selber, 2. den Adresspointer auf die Struktur, in die dann die Informationen des Clients reingeschrieben werden sollen und 3. die Größe der Server-Struktur. Dein Ausdruck müsste also so aussehen

SOCKADDR_IN server, client;
sock_specified = accept(sock_main, (struct sockaddr *) &client, sizeof(sock_main));

void thread_receive() 
{ 
  char data_received[256]; //256 zeichen

  while(handle != SOCKET_ERROR) 
  { 
    handle = recv(sock, data_received, 256, 0); //(bis zu) 256 zeichen empfangen
    if(handle == SOCKET_ERROR) 
    { 
      cout << "Fehler beim Empfangen von Datenpaketen!\n"; 
     break; 
    } 
    else 
    { 
      data_received[handle] = '\0'; //und dann die 0 anfügen...
      cout << "-> " << data_received << '\n';  } 
    } 
}

wenn man das ganze mal mit 2 durchgeht, sieht man (noch viel besser), was ich meine:

char a[2];
=> a[0]; a[1]
int n = recv (X, a, 2, 0);
n==SOCKET_ERROR => fehler (hast du ja)
n==0: disconnect (hast du nicht?!)
n==1: hast du und is iO
n==2: a[2] ?!? gibts nicht... also falsch...

du brauchst also entweder nen um 1 größeren buffer oder sagst dem recv, dass es nen byte weniger bekommt...

außerdem:
1. fällt es mir auch schwer, dir zu glauben, dass du den quelltext selbst zu 100% verstehst...

Code selbst zusammengeflickt

hmm... ist es dein code, wenn du immer nur nen paar zeilen auf einmal abgeschrieben hast?
is ja auch kein problem - und dir würd ja au keiner nen vorwurf machen, aber deine reaktion auf den satz war echt ein wenig... übertrieben (und unehrlich wohl auch)...

2. find ich das auch ... sehr sehr unübersichtlich...
erinnert mich iwie sehr an C - von C++ is es noch nen Stückchen weg ^^

namespace TCP
  {
    class TServerSocket
      {
        private:
          SOCKET socket_nr;
          bool connected;
          unsigned short portnr;
          std::deque <char> Buffer_In;
          std::deque <char> Buffer_Out;
//...
          bool /*fail*/ my_bind (); //etc
static unsigned thread_function (void *_tserversocket)
 {
  TServerSocket *these = static_cast <TServerSocket *> (_tserversocket);
  these->...;
  //usw....
 }
        public:
          Receive ();
          TServerSocket () : connected (false), portnr(0) {};
          void Connect (unsigned short port_nr) throw ()
           {
            if (my_bind ())
             throw /*bla*/;
            //etc
            connected = true;
            _beginthreadex (&thread_function_to_listen, (void*)this, 0, 0, 0); //weiß es gerad nich ausm kopf - google 
           }
          bool IsConnected () const {return connected;}
      };
  }

int main ()
{
TCP::TServerSocket *Server;
Server->Connect (12345);
}

Falls du wirklich verstanden hast, was du gemacht hast, dann wird es dir auch nicht schwer fallen, das alles in ne Klasse zu verpacken und bissl komfortabler zu gestalten... Natürlich sind das paar Zeilen und viel zu überlegen, wie man das mit den Clients macht etc, aber es wird sich lohnen...

Bevor wieder einer kommt von wegen Rad neu erfinden:
Natürlich kann man auch xyz nehmen, was keine bugs hat, toll ist und überhaupt... aber ich find so was immer recht gut zum programmieren lernen... auch wenn es mit win-api ist...

bb

@Berufspenner:
Ja ist schon ok! Aber du kannst mir glauben wenn ich dir sage, dass ich 98 % dieses Codes verstanden habe!
Unter die 2 %, die ich nicht verstanden habe, fallen Dinge wie das Makro "LPTHREAD_START_ROUTINE" oder die Combi aus & bei (SOCKADDR)& - wieso man hier doppelt moppelt^^.

Aber sonst habe ich alles verstanden!

Ich habe jetzt auch (so wie ihr es mir geraten habt) alles etwas besser strukturiert:

Server.cpp

//Server.cpp

#include "Connection.h"
#include "Strings.h"

namespace ProtoTypes
{
  long handle;
  ConnectionS connection;
  void thread_send();
  void thread_receive();
}

int main()
{
  HANDLE handle1 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)ProtoTypes::thread_send, 0,0,0);
  HANDLE handle2 = CreateThread(0,0, (LPTHREAD_START_ROUTINE)ProtoTypes::thread_receive, 0,0,0);
  WaitForSingleObject(handle1, INFINITE);
  WaitForSingleObject(handle2, INFINITE);
}

void ProtoTypes::thread_send()
{
  char data_send[256];

  while(handle != SOCKET_ERROR)
  {
    gets(data_send);
    if(string_spam(data_send))
      handle = send(connection.sock_specified, data_send, strlen(data_send), 0);
    else
      cout << "Spamfilter blockiert die gesendete Nachricht!\n";
    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Senden von Datenpaketen!\nZum Beenden ENTER druecken...";
     break;
    }
  }

}

void ProtoTypes::thread_receive()
{
  char data_received[256];

  while(handle != SOCKET_ERROR)
  {
    handle = recv(connection.sock_specified, data_received, 256, 0);
    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Empfangen von Datenpaketen!\nZum Beenden ENTER druecken...";
     break;
    }
    else if(handle == 0)
    {
      cout << "Gegenseite hat die Verbindung getrennt!\nZum Beenden ENTER druecken...";
     break;
    }
    else
    {
      data_received[handle] = '\0';
      if(!string_pruefe(data_received))
        cout << "-> *****\n";
      else
        cout << "-> " << data_received << '\n';
    }
  }
}

Connection.h

//Connection_Server.h

#include <windows.h>
#include <winsock.h>
#include <iostream>

using namespace std;

class ConnectionS
{
  private:
    WSADATA wsa;
    SOCKADDR_IN server;
    long handle;
  public:
    SOCKET sock_main, sock_specified;
    ConnectionS();
    ~ConnectionS();
};

class ConnectionC
{
  private:
    WSADATA wsa;
    SOCKADDR_IN server;
    long handle;
  public:
    SOCKET sock;
    ConnectionC();
    ~ConnectionC();
};

ConnectionS::ConnectionS()
{
  int port;
  long connections_count;
  char mode[2], ip[30];

  system("Color 9A"); 

  cout << "Port eingeben: ";
  cin >> port;
  cout << '\n';
  cout << "Anzahl erlaubter Verbindungen: ";
  cin >> connections_count;
  cout << '\n';
  if(connections_count > 1)
    char ip[] = "ADDR_ANY";
  else
  {
    cout << "Zugelassene IP eingeben? (J/N)";
    cin >> mode;
    if(mode[0] == 'J')
    {
      cout << "Zugelassene IP: ";
      cin >> ip;
      cout << '\n';
    }
    else
      char ip[] = "ADDR_ANY";
  }
  system("cls");
  memset(&server, 0, sizeof(SOCKADDR_IN));
  server.sin_family = AF_INET;
  server.sin_port = htons(port);
  if(mode[0] == 'J')
    server.sin_addr.s_addr = inet_addr(ip);
  else
    server.sin_addr.s_addr = ADDR_ANY;

  handle = WSAStartup(MAKEWORD(2,2), &wsa);
  if(handle == SOCKET_ERROR)
  {
    cout << "Fehler! WinSock konnte nicht gestartet werden!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "WinSock gestartet!\n"; 

  sock_main = socket(AF_INET, SOCK_STREAM, 0);
  if(sock_main == INVALID_SOCKET)
  {
    cout << "Fehler! Socket konnte nicht erstellt werden!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "Socket erstellt!\n";

  handle = bind(sock_main, (SOCKADDR*)&server, sizeof(SOCKADDR));
  if(handle == SOCKET_ERROR)
  {
    cout << "Fehler! Socket konnte nicht an Server gebunden werden!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "Socket wurde an Server gebunden!\n";

  handle = listen(sock_main, connections_count);
  if(handle == SOCKET_ERROR)
  {
    cout << "Fehler! Funktion 'listen' fehlgeschlagen!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "Server lauscht...\n";

  sock_specified = accept(sock_main, 0, 0);
  if(sock_specified == INVALID_SOCKET)
  {
    cout << "Fehler! Es konnte keine neue Verbindung eingegangen werden!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "Neue Verbindung akzeptiert!\n\n\n\n<<----Chatbereich---->>\n\n";
}

ConnectionC::ConnectionC()
{
  int port;
  char ip[30];

  system("Color 9A"); 

  cout << "Port eingeben: ";
  cin >> port;
  cout << "ServerIP eingeben: ";
  cin >> ip;
  system("cls");
  memset(&server, 0, sizeof(SOCKADDR_IN));
  server.sin_family = AF_INET;
  server.sin_port = htons(port);
  server.sin_addr.s_addr = inet_addr(ip);

  handle = WSAStartup(MAKEWORD(2,2), &wsa);
  if(handle == SOCKET_ERROR)
    {
      cout << "Fehler! WinSock konnte nicht gestartet werden!\nZum Beenden ENTER druecken...";
      system("pause>nul");
    }
  else
    cout << "WinSock gestartet!\n"; 

  sock = socket(AF_INET, SOCK_STREAM, 0);
  if(sock == INVALID_SOCKET)
  {
    cout << "Fehler! Socket konnte nicht erstellt werden!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "Socket erstellt!\n";

  handle = connect(sock, (SOCKADDR*)&server, sizeof(SOCKADDR));
  if(handle == SOCKET_ERROR)
  {
    cout << "Fehler! Verbindung zum Server '" << ip << "' fehlgeschlagen!\nZum Beenden ENTER druecken...";
    system("pause>nul");
  }
  else
    cout << "Socket wurde mit Server verbunden!\n\n\n\n<<----Chatbereich---->>\n\n";
}

ConnectionS::~ConnectionS()
{
  closesocket(sock_main); 
  closesocket(sock_specified); 
  WSACleanup(); 
}

ConnectionC::~ConnectionC()
{
  closesocket(sock);
  WSACleanup();
}

Strings.h

//Strings.h

#include <windows.h>
#include <winsock.h>
#include <iostream>

using namespace std;

bool string_vergleich(char string1[256], char string2[256]);
bool string_spam(char string[256]);
char string_pruefe(char string[256]);

char spam_last[256] = "";
int spam_count = 0;

bool string_vergleich(char string1[256], char string2[256])
{
  if(strlen(string1) != strlen(string2))
   return 0;
  for(int i = 0; i <= strlen(string1); i++)
  {
    if(string1[i] != string2[i])
     return 0;
  }
 return 1;
}

char string_pruefe(char string[256])
{
  class Archiv
  {
    public:
      char w1[256];
      char w2[256];
      char w3[256];
      char w4[256];
      char w5[256];
  };

  Archiv forbidden;

  strncpy(forbidden.w1, "Eine", sizeof("Eine"));
  strncpy(forbidden.w2, "Sammlung", sizeof("Sammlung"));
  strncpy(forbidden.w3, "Von", sizeof("Von"));
  strncpy(forbidden.w4, "Bösen", sizeof("Bösen"));
  strncpy(forbidden.w5, "Wörtern", sizeof("Wörtern"));

  if(string_vergleich(string, forbidden.w1))
   return 0;   
  if(string_vergleich(string, forbidden.w2))
   return 0;
  if(string_vergleich(string, forbidden.w3))
   return 0;
  if(string_vergleich(string, forbidden.w4))
   return 0;
  if(string_vergleich(string, forbidden.w5))
   return 0;
 return 1;
}

bool string_spam(char string[256])
{
  if(string_vergleich(string, ::spam_last))
    ::spam_count++;
  else
  {
    ::spam_count = 0;
    memset(&::spam_last, 0, sizeof(spam_last));
    strncpy(::spam_last,string, strlen(string));
  }
  if(::spam_count >= 5)
   return 0;
  return 1;
}

Ich habe auch noch ein paar Deluxe-funktionen hinzugefügt wie einen kleinen Spamfilter bzw. einen Dedektiv für "Vulgärsprache".

Hierzu noch ein paar Fragen:

1. (zum Detektiv): Ist es denn iwi möglich, diese Abfrage in eine for-Schleife zu packen, bsp so:

for(int i = 0; i <= 5, i++)
{
  if(string_vergleich(string, forbidden.w(i)) // ??? hier irgendwie so??
   return 0;
}

2. Wenn ich, egal ob als Server oder als Client, den Chat schließe, dann kommt nicht die Meldung: "Gegenseite hat die Verbindung getrennt", sondern es kommt die Meldung "Fehler beim Empfangen von Datenpaketen!", aber wieso??

3. Ist es denn irgendwie möglich, den Namensraum "Prototypen" in der main-funktion zu erstellen, oder müssen Namensräume stehts außerhalb deklariert werden??

4. Bitte postet Verbesserungsvorschläge!! Ich bin für jeden Tipp zu haben!!

Viele Grüße
Gapa

ich hab doch extra NUMMERN davor geschrieben und es auch erklärt und ne nur hingeworfen... (also #1 + #2 => cpp-tags + thread_receive)

ConnectionS::ConnectionS()
{
  int port;
  long connections_count;
  char mode[2], ip[30];
/*...*/
}

Wieso ne Klasse zur Verbindung, wo noch nicht mal der Port drin ist sondern nur in irgend nem Scope mal vorkommt (hier CTor)...
Außerdem hast du weiter oben nen Vorschlag für ne Klasse, die evtl (mit Sicherheit) ein wenig (sehr viel) eleganter ist... Ne Klasse sollte niemals auf Console oder GUI beschränkt sein... Sie sollte alle Daten per Parameter empfangen und dann ohne eingaben an sich auskommen... Für Ausgaben übergibt man idR eine Referenz zu nem Stream...

class Archiv
  {
    public:
      char w1[256];
      char w2[256];
      char w3[256];
      char w4[256];
      char w5[256];
  };

wird in C++ zu:

class TArchiv //guck dir vll ma Singletons an - wär hier ne Klasse Geschichte für...
{
 private:
  std::vector <std::string> strings;
/*ODER:*/
  std::vector <std::pair <std::string /*alt*/, std::string /*neu*/> > strings;
 public:
  void add (const std::string &toadd) {strings.push_back (toadd)}
  bool search (const std::string &tosearch) const {/*weiß gerad nich genau, welche std-fkt hier am besten ist...*/}
/*ODER:*/
  void replace (std::string &work) const
    {
      //mit ner schleife den string durchgehen und alles ersetzen...;
    }
};

(SOCKADDR*) &var

=>

(SOCKADDR*)
&
var

also das gleiche, wie:

T1 *pointer_auf_var = &var;
T2 *pointer_wie_ihn_die_fkt_erwartet = (T2*)T1;

namespace ProtoTypes
{
  long handle;
  ConnectionS connection;
/*...*/
}

globale variablen sucken! und wenn du sie schon nimmst (und in 2 Threads gleichzeitig schreiben und lesen willst), dann solltest du darauf achten, dass sie durch einen Mutex o.ä. geschützt sind... Sonst kann es passieren, dass der Thread zum Lesen gerade anfängt mit lesen, wenn der andere Thread gerade schon ein stück der variable geändert hat - und den rest noch nicht...

while (handle != SOCKET_ERROR)
  {
    gets (data_send);
    if (string_spam (data_send))
      handle = send (connection.sock_specified, data_send, strlen(data_send), 0);
    else
      cout << "Spamfilter blockiert die gesendete Nachricht!\n";
/*    if(handle == SOCKET_ERROR)
    {
      cout << "Fehler beim Senden von Datenpaketen!\nZum Beenden ENTER druecken...";
     break;
    } hier nicht...*/
  }
//das stück kannst du auch hier hinschreiben ohne das if...

HEADER-Datei

using namespace std;

Niemals using namespace in headern...

class ConnectionS
{
  private:
    WSADATA wsa;
    SOCKADDR_IN server;
    long handle;
  public:
    SOCKET sock_main, sock_specified;
    ConnectionS();
    ~ConnectionS();
};

class ConnectionC
{
  private:
    WSADATA wsa;
    SOCKADDR_IN server;
    long handle;
  public:
    SOCKET sock;
    ConnectionC();
    ~ConnectionC();
};

1. fällt dir was auf? die sehen fast gleich aus, oder? Vll guckste dir mal das Ableiten an?
2. brauchst du die daten doch hier gar nicht so wirklich... WSADATA reicht doch im CTor einmal - oder guckst du dir das jemals an bzw lässt es ausgeben oä?

struct TSocket
	{
		SOCKET socket_number;

		TSocket (SOCKET _sock = SOCKET_ERROR)
			: socket_number (_sock)														{};

		bool operator == (const TSocket &other) const									{return (socket_number == other.socket_number);};
		bool operator != (const TSocket &other) const									{return (socket_number != other.socket_number);};
		template <typename T>
			friend T& operator << (T &stream, const TSocket &these)						{return (stream << (unsigned int) these.socket_number);};
	};

Ist da vll schon mal nen ganz guter Ansatz... Wenn du was nicht verstehst, dann sag es halt...

Wenn du das alles hast, dann kannste ja noch mal schreiben, wie du es dann hast und so... Aber ich hab jetzt gerad keine Lust mehr, mir noch mehr anzugucken...
Ich meine - wahrscheinlich geht es und du denkst dir eh: "ach - lass ihn quatschen... es geht und was will ich mehr"... aber der stil ist... naja ^^

Aber les wenigstens das, was ich hier schreib, bevor du die nächste Lösung postest...

bb