char buf[256];

int ret = recv(socket, buf , sizeof(buf) , 0);
buf[ret] = '\0';  // buf Nullterminieren

cout<< buf << endl;

Ansonsten setzt halt erst den Nullterminator wenn alle Daten empfangen wurden.

std::string szSendData = "GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n\0";
int bytesSent = 0;
do
{
	int result = send(ConnectSocket, szSendData.c_str() + bytesSent, szSendData.size() - bytesSent, 0);
	bytesSent += result;
} while(bytesSent < szSendData.size());

char buf[256];
while(1)
{
	int ret = recv(ConnectSocket, buf, sizeof(buf) - 1, 0);
	if(ret == -1)
	{
		buf[ret] = '\0';
		break;
	}
}
cout << buf << endl;

Müsste eigentlich heißen:

if(ret == -1)
    break;

buf[ret] = 0; // statt '\0' geht auch einfach 0

Und das cout muss in die Schleife.

std::string szSendData = "GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n\0";
	int bytesSent = 0;
	do
	{
		int result = send(ConnectSocket, szSendData.c_str() + bytesSent, szSendData.size() - bytesSent, 0);
		bytesSent += result;
	} while(bytesSent < szSendData.size());

	char buf[256];
	while(1)
	{
		int ret = recv(ConnectSocket, buf, sizeof(buf) - 1, 0);
		if(ret == -1)
			break;

		buf[ret] = 0;
		cout << buf << endl;
	}

	system("PAUSE");

So sieht es bis jetzt aus, doch zur Pause komm ich einfach nicht.

Könnte klappen...

Edit:
Lerneffekt: Browserfenster nach 1h ruhig mal aktualisieren, um zwischenzeitliche Postings zu lesen

std::string szSendData = "GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n\0"; 
while(1)	
{
	int bytesSent = 0;
	do
	{
		int result = send(ConnectSocket, szSendData.c_str() + bytesSent, szSendData.size() - bytesSent, 0);
		bytesSent += result;
	}while(bytesSent < (signed)szSendData.size());

	std::stringstream EndBuf;
	char buf[256];
	while(1)
	{
		int ret = recv(ConnectSocket, szBuf, sizeof(szBuf) - 1, 0);
		if(ret == 0)
			break;

		buf[ret] = 0;
		EndBuf << buf;
	}
	std::string Data = EndBuf.str();
	cout << Data << endl;

	Data.clear();
	EndBuf.clear();
	buf[0] = 0;
	Sleep(6000);
}

Du solltest dir vielleicht mal boost::asio anschauen. Ich fande es auch erst erschreckend, sobald man das Prinzip einmal im Kopf hat ist es aber easy.

Ansonsten kannst du nach jedem erfolgreichen recv-Aufruf schauen, ob das angekommene Paket soweit fertig ist. Das erkennst du an einem vorkommenden "\r\n\r\n" im Text. Wenn die Antwort von Google also vollständig ist, wäre das evtl auch ein "guter" Punkt, die Schleife zu verlassen.

Übrigens ist das \0 am Ende vom zu sendenden String Unsinn, die wird laut Protokoll nicht mitgeschickt (abgesehen davon, dass sie eh schon am String hintendran hängt, bei .size() aber nicht berücksichtigt wird).

Und die Rückgabewerte von send und recv sollten immer noch auf -1 getestet werden.

std::string szSendData = "GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n";
while(1)   
{
    int bytesSent = 0;
    do
    {
        int result = send(ConnectSocket, szSendData.c_str() + bytesSent, szSendData.size() - bytesSent, 0);
        bytesSent += result;
    }while(bytesSent < (signed)szSendData.size());

    std::stringstream EndBuf;
    char buf[256];
    while(1)
    {
        int ret = recv(ConnectSocket, Buf, sizeof(Buf) - 1, 0);
        if(ret == 0)
            break;

        buf[ret] = 0;
        EndBuf << buf;
    }
    std::string Data = EndBuf.str();
    cout << Data << endl;

    const char *close = "Connection: close\r\n\r\n";
    send(ConnectSocket, close, sizeof(close), 0);

    Data.clear();
    EndBuf.clear();
    buf[0] = 0;
    Sleep(6000);
}

Das ganze HTTP Zeugs scheint mir sehr komplex, damit hatte ich nicht gerechnet. :p

Dämlicher Workaround? Das ist 100 mal besser als irgendwelchen komplizierten Code zu schreiben, den niemand lesen kann.

Sorry, ich war ein wenig harsch. Kann schon eine gute Lösung sein, allerdings muss der TO dann noch jedesmal neu verbinden.

@PlanloserCoder:
Variante 1, mit Connection: close:

std::string szSendData = "GET / HTTP/1.1\r\nHost: www.google.com\r\nConnection: close\r\n\r\n";
while(1)
{
    // Senden
    int bytesSent = 0;
    do
    {
        int result = send(ConnectSocket, szSendData.c_str() + bytesSent, szSendData.size() - bytesSent, 0);
        bytesSent += result;
    }while(bytesSent < (signed)szSendData.size());

    // Empfangen
    std::stringstream EndBuf;
    while(1)
    {
        char buf[256];
        int ret = recv(ConnectSocket, Buf, sizeof(Buf) - 1, 0);
        if(ret == 0)
            break;

        buf[ret] = 0;
        EndBuf << buf;
    }
    cout << EndBuf.str() << endl;

    Sleep(6000);

    // TODO: Hier neu verbinden, ist ja geschlossen worden
}

Variante B, mit Paket-Ende herausfinden:

std::string szSendData = "GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n";
while(1)
{
    // Senden
    int bytesSent = 0;
    do
    {
        int result = send(ConnectSocket, szSendData.c_str() + bytesSent, szSendData.size() - bytesSent, 0);
        bytesSent += result;
    }while(bytesSent < (signed)szSendData.size());

    // Empfangen
    std::stringstream EndBuf;
    while(1)
    {
        char buf[256];
        int ret = recv(ConnectSocket, Buf, sizeof(Buf) - 1, 0);
        if(ret == 0)
            break;

        buf[ret] = 0;
        EndBuf << buf;

        // Paket fertig?
        if ( EndBuf.str().find("\r\n\r\n") != std::string::npos )
            break;
    }
    cout << EndBuf.str() << endl;

    Sleep(6000);
}