Ausschnitt des Programmes:

string lol("Ich bin ein über sinnloser Text der vieleicht versendet wird");
int irc = -1;

irc = send(sende_socket,lol.c_str(),lol.size(),0);

if(irc < lol.size()){
cout << "Nicht genug Zeichen gesendet" << endl;
}if(irc == -1){
cout << "Konnte Zeichen nicht senden" << endl;
return ;
}

Soo und nun meine Frage:
Was ist wenn

irc < lol.size()

ist (das bedeutet das weniger Zeichen gesendet wurden als lol.size() is klar)
aber welche Zeichen wurden jetzt gesendet?

Vieleicht ist es so:

//gesendete Zeichen:
string gesendeteZeichen = lol.substr(0,irc);

ist es so?
wenn ja könnte man dieses Problem ja ziemlich einfach lösen
wenn nicht dann müßte mein Server das Packet verwerfen und auf eins mit einer richtigen Größe warten....

Danke im voraus

cout << "mfg" << endl;
cout << "pf" << endl;

Was ist wenn

irc < lol.size()

ist (das bedeutet das weniger Zeichen gesendet wurden als lol.size() is klar)
aber welche Zeichen wurden jetzt gesendet?

Vieleicht ist es so:

//gesendete Zeichen:
string gesendeteZeichen = lol.substr(0,irc);

ist es so?

Ja, das heißt dann, dass nur die ersten irc Bytes gesendet werden konnten

Gegenfrage: Warum schreibst du eigentlich nicht gleich int irc = send(... , sondern verteilst es auf 2 Zeilen?

ne also steht der Returnwert für die ERSTEN gesendeten Zeichen?

wenn ja dann danke

//by pfUrz @ www.c-plusplus.net
    string msg("Ich bin ún String der mit der string klasse erstellt wurde ....");
    string substring("");
    int irc = 0;

    irc = send(sock,msg.c_str(),msg.size(),0);
    if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
    if(irc < msg.size()){
        while(irc < msg.size()){
            substring = msg.substr(irc,msg.size());
            msg = substring;
            irc = send(sock,msg.c_str(),msg.size(),0);
            if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
        }
    }
    cout << "Alles wurde erfolgreich gesendet! :D" << endl;

So gehts auch, fällt das wiederholte substr weg

edit: So sollte es auch gehen, ist ungetestet!

schönen Abend noch

mit freundlichen Grüßen pfUrz.

//by pfUrz @ www.c-plusplus.net
    string msg("Ich bin ún String der mit der string klasse erstellt wurde ....");
    string substring("");
    int irc = 0;

    irc = send(sock,msg.c_str(),msg.size(),0);
    if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
    if(irc < msg.size()){
        while(irc < msg.size()){
            substring = msg.substr(irc,msg.size()-irc); // -irc vergessen :-)
            msg = substring;
            irc = send(sock,msg.c_str(),msg.size(),0);
            if(irc == -1){cout << "error send() returned -1" << endl;return 0;}
        }
    }
    cout << "Alles wurde erfolgreich gesendet! :D" << endl;

so würde ich das schreiben. (ungetestet)

danke @ all

schön NachMittag noch

mfg ich

bool mysend(int socket, char const *str, std::size_t size, int flags = 0) {
  assert(str);
  std::size_t offset = 0;
  while(offset < size) {
    ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)
      return false; // oder exception werfen
    offset += ret;
  }
  return true;
}

bool mysend(int socket, std::string const &str, int flags = 0) {
  return mysend(socket, str.c_str(), str.size(), flags);
}

// ...
if(mysend(sock, str))
  std::cout << "alles in Ordnung\n";
else
  std::cerr << "upsi. Fehler\n";

so würde ich das schreiben. (ungetestet)

Ich nicht, da size_t als unsigned int definiert ist und somit nie < 0 werden kann, wirst du bei einem socket error ruckzuck ein problem bekommen.

int offset = 0;
int bytes_to_send = (int) strlen( str );
while( bytes_to_send > 0 )
{
	int bytes_sent = send( sock, str+offset, bytes_to_send, 0 );
	if( bytes_sent == -1 )
		return( false );
	else
	{
		bytes_to_send -= bytes_sent;
		offset += bytes_sent;
	}
	return( true );
}

ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)

sollte ja wohl size_t ret heissen?

int ist die falsche Wahl, wenn nur int erlaubt ist?
Deklaration von send:
int send( SOCKET s, const char* buf, int len, int flags );

Was macht dein code wenn beim ersten Versuch -1 (unsigned 0xFFFFFFFF) zurückgegeben wird?
Er addiert ret (0xFFFFFFFF) zum string und bekommt eine Zugriffsverletzung...

ssize_t send(int s, const void *msg, size_t len, int flags);

Siehe POSIX Standard.

while(offset < size) {
    ssize_t ret = ::send(socket, str + offset, size - offset, flags);
    if(ret < 0)
      return false; // oder exception werfen
    offset += ret;

Was macht dein code wenn beim ersten Versuch -1 (unsigned 0xFFFFFFFF) zurückgegeben wird?
Er addiert ret (0xFFFFFFFF) zum string und bekommt eine Zugriffsverletzung...

Wenn -1 zurück gegeben wird, dann gibt er false zurück. Selbst wenn es einen Overflow gäben könnte, dann würde vorher offset < size geprüft werden