Ich schreibe grade an einem Chat.
Verbindung wird hergestellt...
Jedoch wenn ich dann "aus versehen" '\n' bzw. nichts eingebe. Kackt mein Client ab.
Eine Abfrage wollte ich machen, aber dann meckert der Compiler rum, dass ich:

if( str == '\n' )
    //...

nicht verwenden darf.
Gibt es eine Funktion mit der ich, dass verhindern kann (Damit der Client nicht abstürzt)

Ich verwende zum Einlesen das hier:

std::string s;
			std::cout << "Nachricht an den Server: ";
			while ( /* don´t know */ )
				std::getline ( std::cin, s, '\n' );

Ich bedanke mich mal im voraus!

lG

bb

mich wundert´s auch
Es funktioniert noch immer nicht...
Ich bin echt am verzweifeln.
Er macht keine Fehlermeldung, sondern blockiert den nächsten Durchgang.

Was mir so spontan einfällt ist, dass noch was im Puffer liegt...

Liege ich damit richtig?

btw:
dir ist bewusst, dass der letzte parameter unnötig ist:
std::getline ( std::cin, s, '\n' );
->
std::getline(std::cin, s);

s ist auch nicht gerade nen schöner variablenname...

bb

Hier ist die Funktion für das
EMPFANGEN - SERVER:

int Socket::TCP_recv(std::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
	{
		throw SockExcept( "Fehler in Socket::recv" );
		return 0;
	}
}

Um das Problem nochmal klarzustellen:

Client: "Hallo"
Server: "Hallo" empfangen
Client: "..."
Server: "..." empfangen
Client: \n
STOP, Client sendet nichts an den Server sondern Client bleibt hängen und blockiert die nächste Eingabe:

SENDEN - CLIENT

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

Danke für deine Hilfe!

€dit: Grade noch einen kleinen Test gemacht:

int main( )
{
	std::string ip;
	std::cout << "Gib die IP-Adresse ein: ";
	std::getline ( std::cin, ip, '\n' );
	while ( true ) 
	{
		try
		{
			ClientSock client_socket (ip, 12345 );
			std::string s;
			std::cout << "Nachricht an den Server: ";
			std::getline ( std::cin, s );
			std::cout << "Bin durch" << std::endl;
			try
			{
				client_socket << s;   //send 
				client_socket >> s;   //recv
				std::cout << s << std::endl;
			}
			catch ( SockExcept& ) {}
			client_socket.close();
		}
		catch ( SockExcept& e ) 
		{
			std::cout << "Ein Exception wurde abgefangen: " << e.get_SockExcept() << std::endl;
		}
	}
	return 0;
}

Wenn ich:

**```
Client: "Test"
Bin durch
Server: "Test" empfangen
Client "Nocheiner"
Bin durch
Server: "Nocheiner" empfangen
Client: \n
Bin durch
[ SERVER BEKOMMT NICHTS ]

Und beim inneren Try-Block bleibt er hängen.**  

lG

int Socket::TCP_recv(std::string& s) const
{
	char buf[MAXRECV];
	int status = ::recv(m_sock, buf, MAXRECV, 0);
	if(status != SOCKET_ERROR)
	{
		s = std::string(buf, buf+status);
		return status;
	} 
	else 
	{ 
		throw SockExcept( "Fehler in Socket::recv" ); 
		return 0; //unreachable code
	}
}

->

std::string Socket::TCP_recv()
{
	char buf[MAXRECV];
	int status = ::recv(m_sock, buf, MAXRECV, 0);

	if(status == SOCKET_ERROR)
		throw SockExcept( "Fehler in Socket::recv" ); 

	return std::string(buf, buf+status);
}

/* Anwendung:
std::string rcv = socket_instanz.TCP_recv();
*/

das const hab ich auch mit absicht weggemacht - eine methode sollte nur const sein, wenn sie beliebig oft ausführen kann und sich der status des objekts dadurch nicht ändert...

das Senden:

void Socket::TCP_send(std::string &s)
{
	int status = ::send(m_sock, s.c_str(), s.size(), 0);
	if(status == SOCKET_ERROR)
		throw SockExcept("Fehler in Socket::send");

	s.erase(s.begin(), s.begin()+status);
}
/* Anwendung:
std::string to_send = "asdasd";

while(! to_send.empty())
{
  socket_instanz.TCP_send(to_send);
};
*/

bb

PS: Zum eigtl Problem:
std::getline
kopiert alle zeichen vom anfang bis zum ersten zeilenumbruch(oder anderem angegebenem Zeichen) in den output_string. Das angegebene Zeichen ist das erste, was _nicht_ mehr mitkopiert wird aber das letzte, was aus dem stream entfernt(als gelesen markierte) wurde...

es gibt also auch nichts zu senden - der Aufruf wird so in etwa aussehen:

send(socket, nullptr, 0, 0);

sieht mir nach implementation-defined Verhalten aus - je nach dem, wie send implementiert ist entweder undefined oder send kehrt direkt wieder zurück, ohne was gemacht zu haben - gab ja auch nichts zu senden...

also implementieren wir das senden an sich einfach so:

const char the_endl_char='\n';

std::string to_send;
std::getline(std::cin, to_send, the_endl_char);
to_send.push_back(the_endl_char);

//to_send senden

hier ists güt möglich, dass es nen schöneren/besseren weg gibt
vll mit unget und get oder so - kann ich nicht beurteilen - ich würds aber mit der konstante machen^^

bb