c++ boost::asio::buffer and structures - c++

Question

Is there anyway to BASICALLY do the following:
#include <boost/asio.hpp>
struct testStruct{
int x;
int y;
};
int main(){
struct testStruct t;
boost::asio::buffer b;
b = boost::asio::buffer(t);
return 0;
}
Where it seems to fail is passing 't' into the buffer, 'b'.

Answer 1

Use the scatter operation of more than a single buffer:
#include <boost/asio.hpp>
#include <vector>
struct testStruct{
int x;
int y;
};
int
main()
{
struct testStruct t;
t.x = 5;
t.y = 7;
std::vector<boost::asio::const_buffer> buffers;
buffers.push_back( boost::asio::buffer(&t.x, sizeof(t.x) ) );
buffers.push_back( boost::asio::buffer(&t.y, sizeof(t.y) ) );
boost::asio::io_service io_service;
boost::asio::ip::tcp::socket socket( io_service ); // note not connected!
std::size_t length = boost::asio::write( socket, buffers );
return 0;
}
Note you'll need to use a corresponding gather on the receiving side. This gets very tedious with anything more than the contrived example you have presented. Which is why I suggested using a more robust serialization mechanism in your previous question.

Answer 2

Just Use Boost.Serialization
You can get a demo from the http://www.boost.org/doc/libs/1_47_0/doc/html/boost_asio/examples.html
When you want to send an Object, It is better for you to Serialize it First.

Answer 3

There are a few things you need to be careful of.
1. Padding
The layout of your struct is implementation-specific. It's entirely possible for there to be placeholder bytes between the x and y members of your struct on the server, and none on the client.
To work around this, you should serialize your structures member by member into a character buffer, and deserialize them on the client in the same manner.
You could write some utility code to help you with this, here's a starting point:
class packet_writer
{
public:
template <typename iter> void write(iter begin, iter end)
{
buffer_.insert(buffer_.end(), begin, end);
}
template <typename T> void write(T data)
{
int8_t* begin = reinterpret_cast<int8_t*>(&data);
write(begin, begin + sizeof(data));
}
const std::vector<int8_t>& buffer() const
{
return buffer_;
}
private:
std::vector<int8_t> buffer_;
};
2. Endianness
Depending on architecture, or in some cases even depending on the current CPU mode (some POWER CPUs support endianness switching), the bytes of your members may be reversed. You have to detect the endianness of the host architecture, and swap the bytes to a predefined order for use in your protocol.