// socket.cpp
#include <cstdlib>
#include <winsock.h>
#include <io.h>
#include <iostream>
#include "socket.h"
using namespace std;

// Konstruktor
Socket::Socket() : m_sock(0) {
   // Winsock.DLL Initialisieren
   WORD wVersionRequested;
   WSADATA wsaData;
   wVersionRequested = MAKEWORD (1, 1);
   if (WSAStartup (wVersionRequested, &wsaData) != 0) {
      cout << "Fehler beim Initialisieren von Winsock" 
           << endl;
      exit(1);
   }
}

// Destruktor
Socket::~Socket() {
   if ( is_valid() )
      ::closesocket ( m_sock );
}

// Erzeugt das Socket  - TCP
bool Socket::create() {
   m_sock = ::socket(AF_INET,SOCK_STREAM,0);
   if (m_sock < 0) {
      cout << "Fehler beim Anlegen eines Socket" << endl;
      exit(1);
   }
   return true;
}

// Erzeugt das Socket  - UDP
bool Socket::UDP_create() {
   m_sock = ::socket(AF_INET,SOCK_DGRAM,0);
   if (m_sock < 0) {
      cout << "Fehler beim Anlegen eines Socket" << endl;
      exit(1);
   }
}

// Erzeugt die Bindung an die Serveradresse
// - genauer an einen bestimmten Port
bool Socket::bind( const int port ) {
   if ( ! is_valid() ) {
      return false;
   }
   m_addr.sin_family = AF_INET;
   m_addr.sin_addr.s_addr = INADDR_ANY;
   m_addr.sin_port = htons ( port );

   int bind_return = ::bind ( m_sock,
      ( struct sockaddr * ) &m_addr, sizeof ( m_addr ) );
   if ( bind_return == -1 ) {
      return false;
   }
   return true;     
}

// Teile dem Socket mit, dass Verbindungswünsche
// von Clients entgegengenommen werden
bool Socket::listen() const {
   if ( ! is_valid() ) {
      return false;
   }
   int listen_return = ::listen ( m_sock, MAXCONNECTIONS );
   if ( listen_return == -1 ) {
      return false;
   }
  return true;
}

// Bearbeite die Verbindungswünsche von Clients
// Der Aufruf von accept() blockiert solange,
// bis ein Client Verbindung aufnimmt
bool Socket::accept ( Socket& new_socket ) const {
   int addr_length = sizeof ( m_addr );
   new_socket.m_sock = ::accept( m_sock,
      ( sockaddr * ) &m_addr, ( int * ) &addr_length );
   if ( new_socket.m_sock <= 0 )
      return false;
   else
      return true;
}

// Baut die Verbindung zum Server auf
bool Socket::connect( const string host, const int port ) {
   if ( ! is_valid() )
      return false;      
   struct hostent *host_info;
   unsigned long addr;
   memset( &m_addr, 0, sizeof (m_addr));
   if ((addr = inet_addr( host.c_str() )) != INADDR_NONE) {
       /* argv[1] ist eine numerische IP-Adresse */
       memcpy( (char *)&m_addr.sin_addr,
               &addr, sizeof(addr));
   }
   else {
       /* Für den Fall der Fälle: Wandle den Servernamen  *
        * bspw. "localhost" in eine IP-Adresse um         */
       host_info = gethostbyname( host.c_str() );
       if (NULL == host_info) {
          cout << "Unbekannter Server" << endl;
          exit(1);
       }
       memcpy( (char *)&m_addr.sin_addr, host_info->h_addr,
                host_info->h_length);
   }
   m_addr.sin_family = AF_INET;
   m_addr.sin_port = htons( port );      

   int status = ::connect ( m_sock,
      ( sockaddr * ) &m_addr, sizeof ( m_addr ) );

  if ( status == 0 )
    return true;
  else
    return false;
}

// Daten versenden via TCP
bool Socket::send( const string s ) const {
   int status = ::send ( m_sock, s.c_str(), s.size(),  0 );
   if ( status == -1 ) {
      return false;
   }
   else {
      return true;
   }
}

// Daten empfangen via TCP
int Socket::recv ( string& s ) const {
  char buf [ MAXRECV + 1 ];
  s = "";
  memset ( buf, 0, MAXRECV + 1 );

  int status = ::recv ( m_sock, buf, MAXRECV, 0 );
  if ( status > 0 || status != SOCKET_ERROR ) {
     s = buf;
     return status;
  }
  else {
     cout << "Fehler in Socket::recv" << endl;
     exit(1);
     return 0;
  } 
}

// Daten versenden via UDP
bool Socket::UDP_send( const string addr, const string s, const int port ) const {
   struct sockaddr_in addr_sento;
   struct hostent *h;
   int rc;

   h = gethostbyname(addr.c_str());
   if (h == NULL) {
      cout << "Unbekannter Host?" << endl;
      exit(1);
   }
   addr_sento.sin_family = h->h_addrtype;
   memcpy ( (char *) &addr_sento.sin_addr.s_addr,
            h->h_addr_list[0], h->h_length);
   addr_sento.sin_port = htons (port);
   rc = sendto( m_sock, s.c_str(), s.size(), 0,
                 (struct sockaddr *) &addr_sento,
                  sizeof (addr_sento));
   if (rc == SOCKET_ERROR) {
      cout << "Konnte Daten nicht senden - sendto()" 
           << endl;
      exit(1);
   }        
   return true;
}

// Daten empfangen vie UDP
int Socket::UDP_recv( string& s ) const {
   struct sockaddr_in addr_recvfrom;
   int len, n;
   char buf [ MAXRECV + 1 ];
   s = "";
   memset ( buf, 0, MAXRECV + 1 );
   len = sizeof (addr_recvfrom);
   n = recvfrom ( m_sock, buf, MAXRECV, 0,
                  (struct sockaddr *) &addr_recvfrom, &len );
   if (n == SOCKET_ERROR){
      cout << "Fehler bei recvfrom()" << endl;
      exit(1);
      return 0;
   }
   else {
      s = buf;
      return n;
   } 
}

// Winsock.dll freigeben
void Socket::cleanup() const {
   /* Cleanup Winsock */
   WSACleanup();
}

// Socket schließen und Winsock.dll freigeben
bool Socket::close() const {
   closesocket(m_sock);
   cleanup();
   return true;
}

/* socket.h für MS-Windows */
#ifndef SOCKET_H_
#define SOCKET_H_
#include <string>
#include <winsock.h>
#include <io.h>
using namespace std;

// Max. Anzahl Verbindungen
const int MAXCONNECTIONS = 5;
// Max. Anzahl an Daten die aufeinmal empfangen werden
const int MAXRECV = 1024;

// Die Klasse Socket
class Socket {
   private:
   // Socketnummer (Socket-Deskriptor)           
   int m_sock; 
   // Struktur sockaddr_in
   sockaddr_in m_addr;

   public:
   // Konstruktor
   Socket();
   // virtueller Destruktor
   virtual ~Socket();

   // Socket erstellen - TCP
   bool create();
   // Socket erstellen - UDP
   bool UDP_create();
   bool bind( const int port );
   bool listen() const;
   bool accept( Socket& ) const;
   bool connect ( const string host, const int port );
   // Datenübertragung - TCP
   bool send ( const string ) const;
   int recv ( string& ) const;
   // Datenübertragung - UDP
   bool UDP_send( const string, const string,
                  const int port ) const;
   int UDP_recv( string& ) const;
   // Socket schließen
   bool close() const;
   // WSAcleanup()
   void cleanup() const;
   bool is_valid() const { return m_sock != -1; }
};
#endif

// echo_client.cpp
#include "socket.h"
#include "socket.cpp"
#include <string>
#include <iostream>
using namespace std;

int main (int argc, char *argv[]) {
   if( argc < 2 ){
      cout << "Usage: " << *argv << " ServerAdresse\n";
      exit(1);
   }
   Socket sock;
   sock.create();
   // Adresse des Servers
   string argv_1 = argv[1];
   // Mit dem Server auf Port 15000 verbinden
   sock.connect( argv_1, 15000 );
   cout << "Nachricht an den Server: ";
   string s;
   getline(cin, s, '\n' );
   sock.send( s );
   sock.close();
   return 0;
}

// echo_server.cpp
#include "socket.h"
#include <string>
#include <iostream>
using namespace std;

int main (void) {
   Socket sock1;
   sock1.create();
   // Wir verwenden Port 15000
   sock1.bind(15000);
   sock1.listen();
   while (true) {
      Socket sock2;
      sock1.accept( sock2 ); 
      string s;
      sock2.recv (s);
      cout << "Nachricht von Client erhalten: ";
      cout << s << endl;
      sock2.close();
   }
  sock1.close();
  return 0;
}

Bitte hoffentlich kann mir einer Helfen. Ich weiß das das hier abschreckt, aber ich hoffe denoch!

zahlen an sich kann man zwar auch schicken, aber das wird sich kaum lohnen, weil der standard relativ wenig über zahlen vorschreibt, kannst du dich nicht drauf verlassen, dass das ergebnis dann auch richtig interpretiert wird...

bb

// echo_client.cpp
#include "socket.h"
#include "socket.cpp"
#include <string>
#include <iostream>
using namespace std;

int main (int argc, char *argv[]) {
   if( argc < 2 ){
      cout << "Usage: " << *argv << " ServerAdresse\n";
      exit(1);
   }

   char text[]="Hallo";

   Socket sock;
   sock.create();
   // Adresse des Servers
   string argv_1 = argv[1];
   // Mit dem Server auf Port 15000 verbinden
   sock.connect( argv_1, 15000 );
   cout << "Nachricht an den Server: ";
   string s;
   getline(cin, s, '\n' );
   sock.send(text);                             //text anstatt s
   sock.close();
   return 0;
}

dann gibt das Severprogamm nichts aus.
Woran liegt das?