C++ matriz terminada no nula que da como resultado

Question

Estaba tratando de generar una matriz de caracteres terminada no nula en un archivo.

Lo cierto es que recibo paquetes y luego imprimo sus campos.

Ahora, como estos campos no tienen terminación nula, por ejemplo, un segmento de datos que tiene un tamaño de 512 pero que puede o no estar completamente ocupado.

Cuando escribo estos datos en un archivo estoy usando la función sobrecargada < < que no sabe nada de datos reales y solo busca la terminación del segmento de datos.

Entonces, ¿cómo puedo decirle a la función de salida que escriba solo este número número específico de bytes?

En lugar de utilizar algo como esto que es caro llamar cada vez:

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

Si desea poner exactamente maxbytes bytes, utilice write método

stream.write(buffer, maxbytes); 

Si usted puede tener menos bytes en memoria intermedia, ¿cómo se sabe cuántos de ellos su memoria intermedia contiene? Si '\0' marcas tampón final, puede escribir:

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

Answer 2

Una solución barata sería tener un búfer que dispone de espacio para un carácter nulo adicional y sólo hay que poner un carácter nulo en el señale cuando conozca el tamaño real y luego envíe el búfer terminado en nulo como ya lo hace. Rápido y confiable.

Answer 3

Esto funciona, pero no es seguro contra la llama accidentalmente la versión estándar de 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; 
} 

Esto es más seguro, utilizando un tipo maxw lo que limita la longitud de la siguiente char* salida:

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

veo principalmente dos soluti ons.

En caso de datos ASCII:

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

entonces que siempre tenga cadena terminada en cero claro en buffor.

En segundo lugar, en caso de datos ASCII:

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

Answer 5

Si no se preocupan por el último byte, puede simplemente

buffer[buffersize-1] = 0; 

y luego alimentar buffer para cualquier función cadena que desea. Si es más corto, todo se ejecutará con el terminador nulo que ya existe, y si no hubiera terminador, se ejecutará con el que acaba de crear.

Y es rápido :)