Comment lire de manière asynchrone à std :: string en utilisant Boost :: asio?

Le Coup De Pouce.Asio états de documentation:

Un tampon objet représente une région contiguë de la mémoire comme une 2-tuple composé d'un pointeur et la taille en octets. Un n-uplet de la forme {void*, size_t} spécifie une mutable (modifiable) région de la mémoire.

Cela signifie que, pour un appel à async_read pour écrire des données dans une mémoire tampon, il doit être (dans le sous-jacentes de la mémoire tampon de l'objet) d'un bloc contigu de mémoire. En outre, le tampon de l'objet doit être en mesure d'écrire à ce bloc de mémoire.

std::string ne permet pas arbitraire écrit dans son mémoire tampon, de sorte async_read ne peut pas écrire des blocs de mémoire dans une chaîne de caractères du tampon (à noter que std::string ne permet à l'appelant d'un accès en lecture seule au fond de la mémoire tampon via le data() méthode, qui garantit que le pointeur retourné sera valide jusqu'à ce que le prochain appel à un non-const fonction membre. Pour cette raison, Asio permet de créer facilement un const_buffer l'enchaînement d'un std::stringet vous pouvez l'utiliser avec async_write).

L'Asio de la documentation a un exemple de code pour un simple "chat" du programme (voir http://www.boost.org/doc/libs/1_43_0/doc/html/boost_asio/examples.html#boost_asio.examples.chat) qui a une bonne méthode pour surmonter ce problème. Fondamentalement, vous devez avoir le TCP émetteur envoie le long de la taille d'un message d'abord, dans un "en-tête" de toutes sortes, et de lire votre gestionnaire doit interpréter l'en-tête d'allouer un tampon de taille fixe adapté pour la lecture des données réelles.

Autant que le besoin de l'aide de shared_from_this() dans async_read et async_writela raison est qu'il garantit que la méthode encapsulée par boost::bind va toujours se référer à un objet live. Imaginons la situation suivante:

1. Votre handle_accept les appels de méthode async_read et envoie un gestionnaire "dans le réacteur" - en gros, vous avez demandé la io_service d'invoquer Connection::handle_user_read quand il a fini de lire les données à partir de la douille. Le io_service magasins de ce foncteur et continue sa boucle d'attente pour l'opération de lecture asynchrone complète.
2. Suite à votre appel à async_readle Connection objet est libéré pour une raison quelconque (fin de programme, une condition d'erreur, etc.)
3. Supposons que le io_service détermine maintenant que la lecture asynchrone est terminée, après la Connection objet a été libéré, mais avant la io_service est détruit (ce qui peut se produire, par exemple, si io_service::run s'exécute dans un thread séparé, comme c'est typique). Maintenant, la io_service tente d'invoquer le gestionnaire, et il a une référence non valide pour un Connection objet.

La solution est de répartir Connection via un shared_ptr et l'utilisation shared_from_this() au lieu de this lors de l'envoi d'un gestionnaire "dans le réacteur" - ce qui permet à io_service pour stocker une référence partagée à l'objet, et shared_ptr garantit qu'il ne sera pas libéré jusqu'à ce que la dernière référence expire.

Donc, votre code doit probablement ressembler à quelque chose comme:

class Connection : public boost::enable_shared_from_this<Connection>
{
public:

    Connection(tcp::acceptor &acceptor) :
        acceptor_(acceptor), 
        socket_(acceptor.get_io_service(), tcp::v4())
    { }

    void start()
    {
        acceptor_.get_io_service().post(
            boost::bind(&Connection::start_accept, shared_from_this()));
    }

private:

    void start_accept()
    {
        acceptor_.async_accept(socket_, 
            boost::bind(&Connection::handle_accept, shared_from_this(), 
            placeholders::error));
    }

    void handle_accept(const boost::system::error_code& err)
    {
        if (err)
        {
            disconnect();
        }
        else
        {
            async_read(socket_, boost::asio::buffer(user_),
                boost::bind(&Connection::handle_user_read, shared_from_this(),
                placeholders::error, placeholders::bytes_transferred));
        }
    }
    //...
};

Note que, maintenant, vous devez vous assurer que chaque Connection objet est alloué par l'intermédiaire d'un shared_ptrpar exemple:

boost::shared_ptr<Connection> new_conn(new Connection(...));

Espérons que cette aide!

Vous pouvez utiliser un std:string avec async\_read() comme ceci:

async_read(socket_, boost::asio::buffer(&user_[0], user_.size()),
           boost::bind(&Connection::handle_user_read, this,
           placeholders::error, placeholders::bytes_transferred));

Cependant, vous feriez mieux de assurez-vous que le std::string est assez grand pour accepter le paquet que vous attendez et des zéros avant d'appeler async\_read().

Et que pour expliquer pourquoi vous devriez JAMAIS lier un membre de la fonction de rappel pour un this pointeur si l'objet peut être supprimé, une description plus complète et la plus solide, la méthode peut être trouvé ici: Boost async_* les fonctions et les shared_ptr est.