Ich möchte einen tcp::iostream aus boost verwenden, allerdings weiß ich nicht, wie ich den so "umbiegen" kann, dass alle Daten richtig gesendet werden. Hat jemand eine Idee?

tcp::iostream stream;
stream << some_int; // 4 Byte, Big endian werden geschrieben
stream << some_short; // 2 Byte, Big endian
stream << some_std_string; // utf8 string
stream << some_std_wstring; // utf16 string

Und so weiter.

Es gibt für verschiedene Aufgaben verschiedene Werkzeuge, die am besten geeignet sind. Stream-Operatoren schreiben in Textform, also baust du entweder die Gegenseite so um, daß sie Text-Eingaben akzeptieren oder du verwendest etwas, das binäre Daten schreiben kann.

(Alternativ baust du dir eine Hilfsklasse Java-Number, die die Stream-Operatoren so überlädt, daß sie binär schreibt)

Aber da du soviel Wert auf die Stream-Operatoren legst:

class JavaNumber
{
  int val;
public:
  JavaNumber(int v) : val(v) {}
  operator int() {return val;}
};

ostream& operator<<(ostream& s,const JavaNumber& v)
{
  s.write((char*)&v,sizeof(v));
  return s;
}

istream& operator>>(istream& s,JavaNumber& v)
{
  s.read((char*)&v,sizeof(v));
  return s;
}

class BinaryOStream
{
public:
	virtual void write(const void* mem, std::streamsize size)=0;
	virtual bool is_open()=0;
	virtual void close()=0;
	virtual bool fail()=0;

	BinaryOStream& operator<<(char v)
	{
		write(&v, sizeof(v));
		return *this;
	}
	BinaryOStream& operator<<(short v)
	{
        // Vertauschen der beiden Bytes hier
		write(&v, sizeof(v));
		return *this;
	}
... // für alle in Frage kommenden Typen operator << definieren
};

class BinaryOFStream : public BinaryOStream
{
private:
	std::ofstream m_stream; // oder eben ein anderer Stream

public:
	BinaryOFStream([s]const std::string&[/s]const char* name)
	{
		m_stream.open(name[s].c_str()[/s],std::ios::out|std::ios::binary);
	}

	void write(const void* mem, std::streamsize size)
	{
		m_stream.write(reinterpret_cast<const char*>(mem), size);
	}

	bool is_open()
	{
		return m_stream.is_open();
	}

	void close()
	{
		m_stream.close();
	}

	bool fail()
	{
		return m_stream.fail();
	}

};

So mehr oder weniger übernommen aus dem C++ Codebook.

Allerdings habe ich ein Problem, eine geeignete Funktion zum lesen zu basteln.
So sieht meine Funktion im Moment aus:

std::vector<char> binary_socket::read(int maxlength)
    {
        int received;
        std::vector<char> buffer(maxlength);

        if((received = recv(sockfd, buffer.data(), maxlength, 0)) == -1)
            throw socket_error("disconnected from host");

        buffer.erase(buffer.begin() + received, buffer.end());
        return buffer;
    }

Das Problem ist, dass hier auch weniger Daten ankommen können, als ich haben möchte. Ich möchte allerdings exakt so viel (Schließlich ist die Größe von Datentypen konstant), außerdem wäre ein Timeout nicht schlecht. Ich habe von der Funktion select() gelesen, mir der man sowas machen kann, allerdings ist mir deren Verwendung nicht klar. Jemand hier, der sich auskennt?

aber andererseits auch kritik: es muss nicht alles genau so gemacht werden wie du meinst. viele wege führen nach rom, gute und nicht so gute. und das muss nicht an jeder stelle, wie du es machst, kritisieren und darauf hinweisen. (denk an die RAII [von mir immer liebevoll R A 2 genannt xD] diskussion)

aber mach was deine fachliche kompetenz angeht weiter so

Danke, Skym0sh0. Allerdings bin ich extrem pingelig, was RAII angeht (Yay, was für eine Neuigkeit.), und es macht einem nur mehr Arbeit, es nicht zu verwenden. Ich sehe auch keinen Grund, nicht RAII zu verwenden.