Reading stdin in c ++ without using getline

Question

I'm trying to convert a program (it's a bridge between vscode and a debug) This program is written in C#.

It was based on the o vscode-mono-debug

(https://github.com/Microsoft/vscode-mono-debug/blob/master/src/Protocol.cs)

Well, In C # I can read the standard input as a stream:

 byte[] buffer = new byte[BUFFER_SIZE];
Stream inputStream = Console.OpenStandardInput();
    _rawData = new ByteBuffer();

        while (!_stopRequested) {
            var read = await inputStream.ReadAsync(buffer, 0, buffer.Length);

            if (read == 0) {
                // end of stream
                break;
            }

            if (read > 0) {
                _rawData.Append(buffer, read);
                ProcessData();
            }
        }

I try this :

#define _WIN32_WINNT 0x05017
#define BUFFER_SIZE 4096
#include<iostream>
#include<thread>
#include <sstream>

using namespace std;
class ProtocolServer
{

    private:
        bool _stopRequested;
        ostringstream _rawData;
    public:
        void Start()
        {

            char buffer[BUFFER_SIZE];

            while (!cin.eof())
            {

                cin.getline(buffer,BUFFER_SIZE);

                if (cin.fail())
                {
                    //error
                    break;
                }
                else
                {
                    _rawData << buffer;
                }

            }
        }

};

int main()
{
    ProtocolServer *server = new ProtocolServer();
    server->Start();
    return 0;

}

Input:

Content-Length: 261\r\n\r\n{\"command\":\"initialize\",\"arguments\":{\"clientID\":\"vscode\",\"adapterID\":\"advpl\",\"pathFormat\":\"path\",\"linesStartAt1\":true,\"columnsStartAt1\":true,\"supportsVariableType\":true,\"supportsVariablePaging\":true,\"supportsRunInTerminalRequest\":true},\"type\":\"request\",\"seq\":1}

This reads the first 2 lines correctly. Since the protocol does not put \n at the end, it gets stuck in cin.getline in the 3 interaction.

Switching to read() causes it to stay stopped at cin.read (), and does not read anything at all.

I found some similar questions: StackOverFlow Question

And examples: Posix_chat_client

But I do not need it to be necessarily asynchronous, but it works on windows and linux.

I'm sorry for my English

Thanks!

Answer 1

What you want is known as unformatted input operations.

Here's a 1:1 translation using just std::iostream. The only "trick" is using and honouring gcount():

std::vector<char> buffer(BUFFER_SIZE);
auto& inputStream = std::cin;
_rawData = std::string {}; // or _rawData.clear(), e.g.

while (!_stopRequested) {
    inputStream.read(buffer.data(), buffer.size());
    auto read = inputStream.gcount();

    if (read == 0) {
        // end of stream
        break;
    }

    if (read > 0) {
        _rawData.append(buffer.begin(), buffer.begin() + read);
        ProcessData();
    }
}

I'd personally suggest dropping that read == 0 check in favour of the more accurate:

if (inputStream.eof()) { break; }   // end of stream
if (!inputStream.good()) { break; } // failure

Note that !good() also catches eof(), so you can

if (!inputStream.good()) { break; } // failure or end of stream

Live Demo

Live On Coliru

#include <iostream>
#include <vector>
#include <atomic>

struct Foo {

    void bar() {
        std::vector<char> buffer(BUFFER_SIZE);
        auto& inputStream = std::cin;
        _rawData = std::string {};

        while (!_stopRequested) {
            inputStream.read(buffer.data(), buffer.size());
            auto read = inputStream.gcount();

            if (read > 0) {
                _rawData.append(buffer.begin(), buffer.begin() + read);
                ProcessData();
            }

            if (!inputStream.good()) { break; } // failure or end of stream
        }
    }
  protected:
    void ProcessData() {
        //std::cout << "got " << _rawData.size() << " bytes: \n-----\n" << _rawData << "\n-----\n";
        std::cout << "got " << _rawData.size() << " bytes\n";
        _rawData.clear();
    }

    static constexpr size_t BUFFER_SIZE = 128;
    std::atomic_bool _stopRequested { false };
    std::string _rawData;
};

int main() {
    Foo foo;
    foo.bar();
}

Prints (e.g. when reading its own source file):

got 128 bytes
got 128 bytes
got 128 bytes
got 128 bytes
got 128 bytes
got 128 bytes
got 128 bytes
got 92 bytes