Вывод массива символов в C++ с ненулевым символом

Question

Я пытался вывести в файл массив недействительных символов.

Фактически, я получаю пакеты и затем печатаю их поля.

Теперь, когда эти поля не заканчиваются нулем, например, сегмент данных, который имеет размер 512, но может или не может быть полностью занят.

Когда я записываю эти данные в файл, я использую простую перегруженную функцию <<, которая ничего не знает о реальных данных и ищет только завершение сегмента данных.

Итак, как я могу сказать выходной функции писать только это очень определенное количество байтов?

Вместо того, чтобы использовать что-то подобное, звонить каждый раз дорого:

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

Если хочешь поставить точно maxbytes байт, использовать write метод

stream.write(buffer, maxbytes);

Если вы можете иметь меньше байтов в буфере, как узнать, сколько из них содержится в вашем буфере? Если '\0' отмечает конец буфера, вы можете написать:

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

Answer 2

Дешевым решением было бы иметь буфер, в котором есть место для дополнительного нулевого символа, и просто поместить нулевой символ в точку, когда вы знаете фактический размер, а затем вывести буфер с нулевым символом в конце, как вы уже это делаете. Быстро и надежно.

Answer 3

Это работает, но не безопасно от случайного вызова стандарта 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;
}

Это безопаснее, используя maxw тип, который ограничивает длину следующего char* выход:

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

Я вижу в основном два решения.

В случае данных ASCII:

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

тогда у вас всегда будет чистая строка с нулевым символом в конце на буфоре.

Второе в случае данных ASCII:

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

Answer 5

Если вам не важен последний байт, вы можете просто

buffer[buffersize-1] = 0;

а затем передать буфер в любую строковую функцию, которую вы хотите. Если он короче, все будет работать с нулевым терминатором, который уже существует, и если не было терминатора, он будет работать с тем, который вы только что создали.

И это быстро:)