如何将带有Unicode字符的Java字符串发送到C++；通过套接字，没有奇怪的字符？

我正在为我的android手机开发一个应用程序，这样我就可以导入短信、阅读短信和回复短信。当我对服务器和客户端进行编程时，一切都按照我的计划进行。如果我有任何问题，谷歌搜索给了我解决方案，但这一次，这是我有生以来的第一次，我请求你的帮助

问题：

问题是，当客户端（java）发送包含Unicode字符的SMS内容，如<强>“，”，“”/强>，C++无法读取它们。 我的程序的工作原理是，它首先发送数据包大小，让另一个知道数据包有多大。例如，Java计算出数据包为121字节，并将其发送到服务器。但是如果包中包含了几个非ANSI字符，C++将不接收121字节，但123字节，非ANSI字符将变得奇怪。 我在谷歌上搜索了一整天都没有答案。我已经尝试了C++中的W查尔格，我尝试用java语言设置所有的东西，用UTF-8发送，我已经调试了几个小时来重新创建问题，尝试不同的东西，但是没有成功。p> 这是怎么回事？如何从java到C++的文本中的正确大小和表示方式，比如java？没有Unicode字符的数据包可以正常工作

谢谢你们！ 有点累了，希望我没错过什么。代码可能有点混乱，它只是一个原型

p:S，这是TCP协议

<强>服务器C++的ReV函数-< /强>

bool Receive( std::string& msg)
{
    zReadMutex.lock();

    try
    {
        int errCode;
        unsigned int packetSize = 0;
        char packetSizeBuffer[4];

        //Get packet size
        errCode = recv(zSocket, packetSizeBuffer, sizeof(packetSizeBuffer), 0);

        if ( errCode == SOCKET_ERROR || errCode == 0)
        {
            throw NetworkException("Failed Receiving Packet Size!", WSAGetLastError());
        }

        //Convert
        packetSize = CharArrayToUnsignedInt(packetSizeBuffer);

        if (packetSize == 0)
        {
            throw NetworkException("Connection Closed!");
        }

        //Calculate chunks

        //Total bits received
        unsigned int totalBits = 0;
        //Calculate number of chunks that will arrive
        int chunks = CaculateChunks(packetSize);
        //Counter for the chunk loop
        int count = 0;
        //Add to message for every chunk received
        std::string message = "";

        //Just a temp check
        if (chunks > 15)
        {
            throw NetworkException("Connection Closed!");
        }

        //Get Chunks
        while (count < chunks)
        {
            char* buffer = new char[zMaxChunkSize];

            if ((errCode = recv(zSocket, buffer, zMaxChunkSize, 0)) <= 0)
            {
                if (errCode < 0)
                {
                    delete [] buffer;
                    throw NetworkException("Failed Receiving Packet Data!", WSAGetLastError());
                }
                else
                {
                    delete [] buffer;
                    throw NetworkException("Connection Closed!");
                }

            }

            totalBits += errCode;
            count++;
            message += buffer;

            delete [] buffer;

        }

        if (packetSize != totalBits)
        {
            throw NetworkException("Message is not expected size!");
        }

        message.resize(totalBits);
        msg = std::string(message);

    }
    catch(...)
    {
        zReadMutex.unlock();
        throw;
    }

    zReadMutex.unlock();
    return true;
}

public boolean InitSender()
{
    if(mSocket == null)
        return false;

    try {
        //Auto flush is false, but it auto flush anyways
        out = new PrintStream(mSocket.getOutputStream(), false, "UTF-8");

    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }

    return true;
}

public synchronized void SendMessage(final String a)
{
    int size = 0;
    size = a.length();

    //Send size
    out.print(size);

    //Chunk it
    int chunks = CalculateChunks(a);
    String[] data = SplitToChunks(a, chunks);

    for (String message : data)
    {
        //Send data
        out.print(message);
    }
}

public NetworkSender(Socket s)
{
    mSocket = s;
    mEnc = Charset.forName("ISO-8859-1").newEncoder();
}

public boolean InitSender(){
    if(mSocket == null)
        return false;

    try {
        out = new DataOutputStream(mSocket.getOutputStream());

    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }

    return true;
}

public synchronized boolean SendMessage(final String a) {

    String str_msg = a;
    str_msg = START_PACKET_INDICATION + a + END_PACKET_INDICATION;

    byte[] msg = StringEncodeCString(str_msg, false);

    try {
        out.write(msg);
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    }

    return true;
}

private byte[] StringEncodeCString(String msg, boolean zeroTeminate)
{
    int zero = 0;

    if(zeroTeminate)
        zero = 1;

    int len = msg.length();
    byte b[] = new byte[len + zero];
    ByteBuffer bbuf = ByteBuffer.wrap(b);
    mEnc.encode(CharBuffer.wrap(msg), bbuf, true);

    if(zeroTeminate)
        b[len] = 0;

    return b;
}

bool NetworkChannel::Receive( std::string& msg)
{
    zReadMutex.lock();

    try
    {
        int errCode;
        char *buffer = new char [zMaxChunkSize];
        std::size_t start_pos;
        std::size_t end_pos;
        std::string startEnd;

        //Check buffer
        if (zSaveBufferString != "")
        {

            startEnd = GetStartEndIndicatorSubstr(zSaveBufferString, start_pos, end_pos);

            if (startEnd == "")
            {
                //Nothing inside buffer, continue
            }

            else if (!EraseStartEnd(startEnd))
            {
                zReadMutex.unlock();
                throw NetworkException("Failed to concat message!");
            }
            else
            {
                zSaveBufferString.erase(start_pos, end_pos + start_pos);
                msg = startEnd;
                zReadMutex.unlock();
                return true;
            }

        }

        errCode = recv(zSocket, buffer, zMaxChunkSize, 0);

        if (errCode == SOCKET_ERROR || errCode == 0)
        {
            zReadMutex.unlock();
            throw NetworkException("Failed Receiving Packet Size!", WSAGetLastError());
        }

        std::string temp(buffer);
        temp.resize(errCode);

        zSaveBufferString += temp;

        //Find a Start and end subStr to translate messages
        startEnd = GetStartEndIndicatorSubstr(zSaveBufferString, start_pos, end_pos);

        if (startEnd == "")
        {
            delete[]buffer;

            zReadMutex.unlock();
            return false;
        }

        if( !EraseStartEnd(startEnd) )
        {
            delete[]buffer;

            zReadMutex.unlock();
            throw NetworkException("Failed to erase startEnd!");
        }

        zSaveBufferString.erase(start_pos, end_pos + start_pos);

        msg = startEnd;

        delete [] buffer;

    }
    catch(...)
    {
        zReadMutex.unlock();
        throw;
    }

    zReadMutex.unlock();
    return true;
}

例如，Java计算出数据包为121字节，并将其发送到服务器

size = a.length();
//Send size
out.print(size);

该代码与描述不匹配.length（）不计算字节数。您正在发送字符串中Java

char

元素的数量。Java

char

是两个字节

消息

是一个Java

字符串

。您需要了解该

字符串

如何转换为字节，以便通过网络连接发送。无法保证此转换创建的字节数与字符串中的Java

char

s相同。特别是，如果字符串转换为UTF-8，则一些单独的Java

char

值将转换为两个或三个字节

您需要在发送数据之前进行转换，以便计算实际发送的字节数

---

<>在C++方面，<>代码> STD::String 是一个C++ +代码> char < /C>元素的序列，它与java <代码> char < /C> >不相同。C++ <代码> char < /C> >是一个字节。在您的代码中，

std:：string

将包含您从网络上读取的相同数据；如果客户端发送UTF-8数据，则

std:：string

保存UTF-8数据。要显示字符串，您需要使用一个API来处理或转换该编码。否则它会看起来有些字符是“奇怪的”

---

以下是学习您需要了解的一些事情的合理起点：

例如，Java计算出数据包为121字节，并将其发送到服务器

size = a.length();
//Send size
out.print(size);

该代码与描述不匹配.length（）不计算字节数。您正在发送字符串中Java

char

元素的数量。Java

char

是两个字节

消息

是一个Java

字符串

。您需要了解该

字符串

如何转换为字节，以便通过网络连接发送。无法保证此转换创建的字节数与字符串中的Java

char

s相同。特别是，如果字符串转换为UTF-8，则一些单独的Java

char

值将转换为两个或三个字节

您需要在发送数据之前进行转换，以便计算实际发送的字节数

---

<>在C++方面，<>代码> STD::String 是一个C++ +代码> char < /C>元素的序列，它与java <代码> char < /C> >不相同。C++ <代码> char < /C> >是一个字节。在您的代码中，

std:：string

将包含您从网络上读取的相同数据；如果客户端发送UTF-8数据，则

std:：string

保存UTF-8数据。要显示字符串，您需要使用一个API来处理或转换该编码。否则它会看起来有些字符是“奇怪的”

---

以下是学习您需要了解的一些事情的合理起点：

例如，Java计算出数据包为121字节，并将其发送到服务器

size = a.length();
//Send size
out.print(size);

该代码与描述不匹配.length（）不计算字节数。您正在发送字符串中Java

char

元素的数量。Java

char

是两个字节

消息

是一个Java

字符串

。您需要了解该

字符串

如何转换为字节，以便通过网络连接发送。无法保证此转换创建的字节数与字符串中的Java

char

s相同。特别是，如果字符串转换为UTF-8，则一些单独的Java

char

值将转换为两个或三个字节

您需要在发送数据之前进行转换，以便计算实际发送的字节数

---

<>在C++方面，<>代码> STD::String 是一个C++ +代码> char < /C>元素的序列，它与java <代码> char < /C> >不相同。C++ <代码> char < /C> >是一个字节。在您的代码中，

std:：string

将包含您从网络上读取的相同数据；如果客户端发送UTF-8数据，则

std:：string

保存UTF-8数据。要显示字符串，您需要使用一个API来处理任何编码，或者转换i