C++ output di array di char terminato non nullo

Question

Stavo cercando di emettere un array di caratteri terminato non nullo in un file.

La cosa reale è che sto ricevendo pacchetti e poi stampo i loro campi.

Ora come questi campi non sono terminati con null, ad esempio, un segmento di dati che ha una dimensione di 512 ma può o non può essere completamente occupato.

Quando scrivo questi dati su un file sto usando la semplice funzione sovraccaricata < < che non sa nulla dei dati reali e cerca solo la conclusione del segmento di dati.

Quindi, come posso dire alla funzione di output di scrivere solo questo numero specifico di byte?

Invece di usare qualcosa di simile, che è costoso di chiamare ogni volta:

enter code here 

bytescopied = strncpy(dest, src, maxbytes); 

if (bytescopied < 0) { // indicates no bytes copied, parameter error 

    throw(fit);   // error handler stuff here 

} else if (bytescopied == maxbytes) { 

    dest[maxbytes-1] = '\0'; // force null terminator 

} 

Answer 1

Se si vuole mettere esattamente maxbytes byte, utilizzare il metodo write

stream.write(buffer, maxbytes); 

Se si può avere meno byte nel buffer, come fai a sapere quanti di loro buffer contiene? Se '\0' marchi tampone fine, si può scrivere:

stream.write(buffer, std::find(buffer, buffer+maxbytes, '\0') - buffer); 

Answer 2

Una soluzione economica sarebbe quella di avere un buffer che ha spazio per un carattere aggiuntivo nullo e appena messo un carattere null al puntare quando si conosce la dimensione effettiva e quindi inviare il buffer con terminazione null come si fa già. Veloce e affidabile.

Answer 3

Questo funziona, ma non è sicuro contro chiamando accidentalmente la versione standard di char*operator<<:

#include <iostream> 

template <unsigned N> 
std::ostream& operator<< (std::ostream& out, const char (& data) [N]) 
{ 
    out.write (data, N); 
    // or out.write (data, strnlen (data, N)); 
    // if you want to stop at a '\0' in the data 
    return out; 
} 


struct Foo { 
    char one[5]; 
    char two[1]; 
    char three[5]; 
}; 

int main (void) 
{ 
    using namespace std; 

    Foo foo = { 
     { 'h', 'e', 'l', 'l', 'o' }, 
     { ' ' }, 
     {'w', 'o', 'r', 'l', 'd'} }; 

    cout << foo.one; 
    cout << foo.two; 
    cout << foo.three; 
    cout << endl; 
} 

Questo è più sicuro, utilizzando un tipo maxw che limita la lunghezza del prossimo char* uscita:

struct maxw { 
    unsigned n; 
    maxw (unsigned n) : n (n) { } 
}; 

struct maxw_stream { 
    std::ostream& stream; 
    unsigned n; 
    maxw_stream (std::ostream& stream, unsigned n) : 
      stream (stream), 
      n (n) { 
    } 
}; 

maxw_stream operator<< (std::ostream& out, const maxw& m) 
{ 
    return maxw_stream (out, m.n); 
} 

std::ostream& operator<< (const maxw_stream& out, const char* data) 
{ 
    out.stream.write (data, strnlen (data, out.n)); 
    return out.stream; 
} 

// eg: 
cout << maxw(4) << "Hello World!" << endl; 
// Hell\n 
cout << maxw(100) << "Hello World!" << endl; 
// Hello World!\n 

Answer 4

vedo principalmente due soluti ons.

In caso di dati ASCII:

memset(dest,0,destlength); 
bytescopied = strncpy(dest, src, maxbytes); 

quindi avrete sempre chiaro stringa null-terminata in buffor.

Seconda in caso di dati ASCII:

std::string yourASCII(src,maxbytes); 
yourASCII.c_str() // would be null terminated. 

Answer 5

Se non si preoccupano l'ultimo byte, si può solo

buffer[buffersize-1] = 0; 

e poi nutrire tampone a qualsiasi funzione di stringa che si desidera. Se è più breve, tutto verrà eseguito sul terminatore nullo già esistente e, se non ci fosse un terminatore, verrà eseguito su quello appena creato.

Ed è veloce :)