Как memset массив символов с завершающим нулевым символом?

Варианты один и два просто неверны. Первый использует размер указателя вместо размера массива, поэтому он, вероятно, не будет записывать весь массив. Второй использует sizeof(char*) вместо sizeof(char), поэтому он будет писать за конец массива. Вариант 3 подходит. Вы также можете использовать это

memset( buffer, '\0', sizeof(char)*ARRAY_LENGTH );

но sizeof(char) гарантированно равно 1.

Идиоматический способ - это инициализация массива значением:

char* buffer = new char [ARRAY_LENGTH]();

Вариант 1 устанавливает только первые sizeof(char*) байта в 0 или приводит к неопределенному поведению, если ARRAY_LENGTH < sizeof(char*). Это связано с использованием размера указателя вместо размера типа.

Вариант 2 приводит к неопределенному поведению, поскольку вы пытаетесь установить более ARRAY_LENGTH байт. sizeof(char*) почти наверняка больше 1.

Поскольку это C++ (нет new в C), я предлагаю вместо этого использовать std::string.

Для C (при условии, что malloc вместо new[]) вы можете использовать

memset( buffer, 0, ARRAY_LENGTH );

Поскольку вопрос постоянно меняется, я определяю:

1: memset( buffer, '\0', sizeof(buffer) );

2a: memset( buffer, '\0', sizeof(char*) * ARRAY_LENGTH );

2b: memset( buffer, '\0', sizeof(char) * ARRAY_LENGTH );

3: memset( buffer, '\0', ARRAY_LENGTH );

Если вопрос состоит просто в том, «как правильно вызвать memset», а не в том, «как лучше всего обнулить этот массив», то правильным будет либо 2b, либо 3. 1 и 2а неверны.

У вас может быть война стилей из-за 2b против 3: включать ли sizeof(char) или нет - некоторые люди опускают его, потому что он избыточен (я обычно так делаю), другие люди вставляют его, чтобы создать своего рода согласованность с той же настройкой кода. массив int. То есть они всегда умножают размер на количество элементов, даже если знают, что размер равен 1. Один из возможных выводов состоит в том, что «самый безопасный» способ memset для массива, на который указывает buffer, это:

std::memset(buffer, 0, sizeof(*buffer) * ARRAY_LENGTH);

Этот код остается правильным, если изменяется тип буфера, при условии, конечно, что он по-прежнему содержит ARRAY_LENGTH элементов любого типа и при условии, что все биты-ноль остаются правильным начальным значением.

Другой вариант, любимый программистами "C++ не C", это:

/* never mind how buffer is allocated */
std::fill(buffer, buffer + ARRAY_LENGTH, 0);

Если вам не все равно, вы можете сами проверить, оптимизирует ли ваш компилятор это для того же кода, для которого он оптимизирует эквивалентный вызов std::memset.

char *buffer = new char [ARRAY_LENGTH](); изящно, но на практике почти бесполезно в C++, потому что вы почти никогда не выделяете массив с new в первую очередь.

std::string buffer(ARRAY_LENGTH, 0); представляет особый способ управления буфером, который может быть или не быть тем, что вам нужно, но часто так и есть. В некоторых случаях можно многое сказать о char buffer[ARRAY_LENGTH] = {0};.

• Имеет ли какой-либо из них значительное преимущество перед другими?
• С какими проблемами я могу столкнуться при использовании 1, 2 или 3?

1-е неверно, потому что sizeof(buffer) == sizeof(char*).

2-й и 3-й в порядке.

• Как лучше всего обработать этот запрос?

Почему бы просто не:

buffer[0] = '\0';

Если это массив char, зачем возиться с остальными символами? С первым байтом, установленным в ноль, у вас есть эквивалент "" в вашем buffer.

Конечно, если вы действительно настаиваете на обнулении всех buffer, используйте ответ с std::fill - это правильный путь. Я имею в виду std::fill(buffer, buffer + ARRAY_LENGTH, 0);.

Если вам абсолютно необходимо использовать необработанный массив в C++ (это очень плохая идея), сделайте это так:

char* buffer = new char [ARRAY_LENGTH]();

Для C++ memset обычно является последним прибежищем некомпетентных, хотя за последние несколько месяцев я узнал, что для приемлемой производительности с текущими инструментами необходимо опускаться до этого уровня, когда реализуется собственный строковый класс.

Вместо этих необработанных массивов и т. д., которые могут потребовать memset, используйте, например. std::string (для приведенного выше случая), std::vector, std::array и т. д.

Начиная с С++ 11, я бы выбрал:

#include <array>

std::array<char, ARRAY_LENGTH> buffer{ '\0' };

buffer.fill('\0');

Option 3: memset( buffer, '\0', ARRAY_LENGTH ): даст вам только длину массива, но на самом деле этот параметр определяет количество байтов памяти.

Option 1: memset( buffer, '\0', sizeof(buffer) ): даст вам неверный ответ, потому что buffer это char*. sizeof(buffer) не даст вам размер всего массива, а только размер переменной-указателя.

Вариант 2 правильный.

Ну лично мне нравится вариант 3:

memset( buffer, '\0', ARRAY_LENGTH )

ARRAY_LENGTH это именно то, что я хотел бы заполнить в памяти.