C++与Java间Socket复用多次收发字符串/字节异常问题求助

Hey there, let’s tackle this socket reuse issue between your C++ client and Java server (or vice versa) — I’ve run into similar sticky points before, so let’s break it down.

The Core Problem: TCP is a Stream Protocol #

First off, remember that TCP doesn’t care about your "messages" — it just sends a continuous stream of bytes. When you send multiple times in a row, the data can get "stuck together" (called packet sticking), or the receiving end might not know where one message ends and the next begins. That’s why single sends/receives work, but multiple ones fail. Also, the char array → null issue usually comes from mismatched data formats between C++ and Java.

Fix 1: Define Clear Message Boundaries #

You need a way for the receiver to know when a full message has arrived. Two reliable approaches:

a. Length-Prefixed Messages (Best for Binary/Text)

Send the length of your message first (as a fixed-size integer, like 4 bytes), then send the actual message content. The receiver reads the length first, then reads exactly that many bytes to get the full message.

C++ Client Sending Code:

#include <iostream>
#include <winsock2.h> // For Windows; use <sys/socket.h> on Linux

#pragma comment(lib, "ws2_32.lib")

int main() {
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    SOCKET clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in serverAddr{};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(12345);
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    connect(clientSocket, (sockaddr*)&serverAddr, sizeof(serverAddr));

    // Send multiple messages
    const char* messages[] = {"First message", "Second message", "Third message"};
    for (const char* msg : messages) {
        int msgLen = strlen(msg);
        // Send length first (convert to network byte order)
        int networkLen = htonl(msgLen);
        send(clientSocket, (char*)&networkLen, sizeof(networkLen), 0);
        // Send message content
        send(clientSocket, msg, msgLen, 0);
    }

    closesocket(clientSocket);
    WSACleanup();
    return 0;
}

Java Server Receiving Code:

import java.io.DataInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket clientSocket = serverSocket.accept();
        DataInputStream dis = new DataInputStream(clientSocket.getInputStream());

        // Receive multiple messages
        for (int i = 0; i < 3; i++) {
            // Read length first (convert back to host byte order)
            int msgLen = dis.readInt();
            byte[] msgBytes = new byte[msgLen];
            // Read exactly msgLen bytes
            dis.readFully(msgBytes);
            String msg = new String(msgBytes);
            System.out.println("Received: " + msg);
        }

        dis.close();
        clientSocket.close();
        serverSocket.close();
    }
}

b. Special Delimiter (Simpler for Text Only)

If you’re only sending text, use a unique delimiter (like \n or ###END###) to mark the end of each message. The receiver reads bytes until it hits the delimiter.

C++ Client Sending:

// For each message, append the delimiter
const char* msgWithDelim = "Hello from C++\n";
send(clientSocket, msgWithDelim, strlen(msgWithDelim), 0);

Java Server Receiving:

BufferedReader br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String line;
while ((line = br.readLine()) != null) { // Reads until \n
    System.out.println("Received: " + line);
}

Fix 2: Solve the Char Array → Java Null Issue #

The null problem usually happens because:

• Your C++ code isn’t sending the full char array (or missing a terminator that Java expects)
• Java is using the wrong method to read the data (e.g., readUTF() requires a specific length prefix that C++ isn’t sending)

If you’re sending a raw char array from C++, don’t rely on Java’s readUTF() — instead, use the length-prefixed method above, or send the exact number of bytes in the array. For example:

C++ Sending Char Array:

char myArray[] = {'H', 'e', 'l', 'l', 'o'};
int arrLen = sizeof(myArray);
int networkLen = htonl(arrLen);
send(clientSocket, (char*)&networkLen, sizeof(networkLen), 0);
send(clientSocket, myArray, arrLen, 0);

Java Receiving:

int arrLen = dis.readInt();
byte[] arrBytes = new byte[arrLen];
dis.readFully(arrBytes);
// Convert byte array to char array if needed
char[] myArray = new char[arrLen];
for (int i = 0; i < arrLen; i++) {
    myArray[i] = (char) arrBytes[i];
}
System.out.println(new String(myArray));

Quick Notes to Avoid Pitfalls #

• Always flush after sending: If you’re using C++ streams (like std::ostream with sockets), make sure to call flush() to push data out of the buffer immediately.
• Handle partial reads: On the receiving end, methods like read() might not get all bytes in one call — use loops or readFully() (Java) to ensure you get the full message.
• Byte order matters: When sending integers (like message lengths), convert to network byte order with htonl()/htons() (C++) and back with readInt() (Java does this automatically).

内容的提问来源于stack exchange，提问作者Hadi