Come si invia uno std :: vector <char> usando Boost :: Asio?

Question

Ho cercato di ottenerlo per buona parte della giornata, sinceramente avrei apprezzato qualsiasi aiuto. Entrambe le mie app, il client e il server hanno iniziato a lanciare eccezioni "vector subscript out of range".

Come si fa questa cosa correttamente?

---

Ancora cercando di capirlo, qualcuno?

Per quanto mi undestand dovrei creare un

boost::asio::basic_stream_socket stream; e quindi chiamare:

stream.send(boost::asio::buffer(data));?

Suppongo che sia perfettamente possibile farlo in modo asincrono? Quali sono le differenze tra: basic_stream_socket::send() rispetto a basic_stream_socket::write_some() rispetto a basic_stream_socket::async_write_some()?

basic_stream_socket::receive() vs. baic_stream_socket::read_some() vs. basic_stream_socket::async_read_some()?

sto supponendo che send() & sono metodi che posso chiamare quando voglio fare in modo che il 100% dei dati vengono inviati/ricevuti - a spese di bloccare la presa di corrente?

sto supponendo che write_some() & read_some() sono metodi che posso chiamare quando io non sono sicuro se il 100% dei dati viene inviato/ricevuto - pur continuando a bloccare la presa?

Suppongo che async_read_some() & async_write_some() siano metodi che non bloccano il socket e leggono/scrivono tutto ciò che possono?

Answer 1

Dando per scontato che ha creato un flusso e stanno cercando di inviare i dati di vector<char>:

stream.send(boost::asio::buffer(data)); 

Vedi boost:asio::buffer.

Answer 2

Sono abbastanza nuovo per incrementare ASIO troppo ma qui sono le mie risposte:

Le funzioni con nomi di funzione che iniziano con async_ prende, tra gli altri, una funzione di callback come argomento che sarà chiamata quando l'operazione termina. Cioè, la funzione async_write_some() non blocca ma restituisce immediatamente e al termine dell'operazione, viene richiamata la funzione di callback.

Le tue ipotesi sono corrette, per quanto ho capito. Tuttavia, con le funzioni async_write_some ecc. Hai una funzione di callback che prende il numero di byte trasferiti come argomento.

Per esempio, qui ho una funzione che legge da una presa di corrente:

boost::asio::async_read(
    *socket_, 
    boost::asio::buffer(read_msg_.body(), read_msg_.body_length()), 
    boost::bind(
     &sender::handle_read_content, 
     this, 
     boost::asio::placeholders::error, 
     boost::asio::placeholders::bytes_transferred 
    ) 
); 

La funzione di callback in c'è handle_read_content, e sembra che questo:

void sender::handle_read_content(
    const boost::system::error_code& err, 
    std::size_t bytes_transferred 
) 

All'inizio ho leggi questo tutorial che è stato molto buono: Boost Asio