c++ cin >> style function for socket

Question

I'm currently working on a socket program.

Is it possible to use the stream insertion operator as in the use case below ?

__sin >> var; // similar to cin >> var;

where the body of the function is something like

var = remoteConsole.getline();

so i can use the function in place of cin when im working with my remote console, in a remote location I know i can use something like

cin.getLine() or var= remoteConsole.cin()

but im trying to avoid that.

Im starting to think that what im trying to do is impossible though it seems easy, i may have to dump the idea. I've had a good look around but everything i try is littered with compile errors. any help would be appreciated. Thank you

EDIT

for those who were unclear as to what i was talking about (which i tryed to clearly explain) i was trying to make a function with the same syntax as cin but instead of getting the input from a console, getting it from somewhere else, ie a socket. i was having trouble creating a function that took << or >> instead of ( and ). i wanted the syntax to be the same as cin >> and cout <<. my question should have been, where do i start on the road to doing this?.

Ive found out a way to do it, but im not shure how safe it will be. I created two struct's and overloaded the << in one and >> in the other

struct out_t {
    template<typename T>
    out_t& operator << (T&& x)  {
        // Send x to the socket
        // Use console for now
        cout << x;
    return *this;
    }
};

out_t socout;

struct in_t {
    template<typename T>
    in_t& operator >> (T&& x)  {
        // get x from the socket and wait untill done so;
        // Use console for now
        cin >> x;
        return *this;
    }
};

in_t socin;

so now i can use

socout << "Some message"; // which i can now send to an external console
socin >> strValue;//  i can request the data needed from external program/computer

sorry if i didn't explain this well to start with. there may be room for improvements but im quite happy with this. if this is not the way to go, could somebody please please advise me of the proper way.

Thanks all;

Answer 1

If all you want to do is to create an std::istream& which reads from a socket instead of one of the predefined stream, you can create a custom std::streambuf: the std::istream doesn't really do any of the reading of characters. That is the job of the stream buffer. All std::istream does is provide an interface to overload input operations, hold formatting flags, error indicators, and a stream buffer.

To create a custom stream buffer for inputting character, you'd override underflow() to read characters into a buffer, e.g., something like this (using the typical UNIX API for sockets; on a different system just the code for accessing the socket really differs):

class socketbuf: public std::streambuf {
    typedef std::streambuf::traits_type traits_type;
    int  d_fd;
    char d_buffer[2000];
    int underflow() {
        if (this->gptr() == this->egptr()) {
            std::streamsize size = ::read(this->d_fd, this->d_buffer, sizeof(this->d_buffer));
            this->setg(this->d_buffer, this->d_buffer, this->d_buffer + size);
        }
        return this->gptr() == this->egptr()
            ? traits_type::eof()
            : traits_type::to_int_type(*this->gptr());
    }
public:
    socketbuf(int fd): d_fd(fd) {}
};

Once you have stream buffer like this, you can just initialize an std::istream with a pointer to this stream buffer. If you are planning to use this set up multiple times, you may want to create a custom isocketstream class which creates the stream buffer and sets up an std::istream with the result. Here is just the unpackage use:

int fd = get_and_setup_socket(); // get a file descriptor for the socket somehow
socketbuf    sbuf(fd);
std::istream sin(&sbuf);

std::istream& in(use_local? std::cin: sin);
if (in >> whatever) {
    std::cout << "received '" << whatever << "'\n";
}

You might want to complement the input operations with output operations. To this end you'd also override the functions overflow() which is called whenever the set up buffer overflows and sync() which is called when the stream if getting flushed.

Answer 2

Basic C++. Overload the operator >> so it does what you expect it to do.

MySocketClass& MySocketClass::operator>>(std::string&);