Почему числовые массивы заканчиваются символом '\ 0' или нулем?

Ответ 1

Заданный вопрос содержит скрытое предположение, что все массивы char заканчиваются нулевым символом. На самом деле это не всегда так: массивы char, которые должны заканчиваться нулевым символом, - это те, которые предназначены для использования в качестве строк, которые действительно требуют завершения.

В вашем примере массив char заканчивается нулевым символом, потому что вы сделали это так. Единственное место, где компилятор будет вводить нулевой символ для вас, - это объявление массива char из строкового литерала, например:

char name[] = "VIJAY";

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

Массивы указателей иногда заканчиваются указателем NULL, что имеет смысл, потому что указатель NULL нельзя путать с действительным указателем. Массив строк argv, полученный main(), является примером такого массива.

Ответ 2

Строка заканчивается терминатором 0, но строка - это не то же самое, что и массив. Мы используем массивы для хранения строк, но мы также используем массивы для хранения вещей, которые не являются строками. Вот почему в массивах вообще нет автоматически добавленного к ним файла.

Кроме того, в любом общем массиве int 0 может быть допустимым (несердечным) значением.

Ответ 3

Вы можете сделать конец массива int с помощью 0, если хотите:

int iarray[] = {1, 2, 3, 0};

Так как '\0' и 0 точно совпадают, вы даже можете заменить 0 выше на '\0'.

Ваше замешательство может быть связано с автоматической вставкой '\0' в объявление, например:

char s[] = "hello";

В приведенном выше определении s эквивалентно char s[] = {'h', 'e', 'l', 'l', 'o', '\0'};. Подумайте, что это удобный ярлык, предоставляемый стандартом C. Если вы хотите, вы можете принудительно создать ненулевой завершенный массив char, указав его размер:

char s[5] = "hello";

В приведенном выше примере s не будет NUL завершен.

Также обратите внимание, что символьные литералы в C имеют тип int, поэтому '\0' на самом деле является int. (Кроме того, char является интегральным типом.)

Ответ 4

Массив может завершиться чем-либо, что является допустимым значением типа элемента массива. Но только \0 завершенный массив char называется строкой.

Например

char name[]={'V','I','J','A','Y'};

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

Чтобы пояснить комментарий OP ниже, по стандарту C, любые символьные литералы, такие как 'a', '1 и т.д., включая '\0', являются типом int. И вы можете поместить '\0' в конец массива int следующим образом:

int arr[] = {20, 22, 23, '\0'};

Но люди обычно этого не делают, потому что обычно '\0' используется только для прерванных строк. Вышеприведенный код эквивалентен

int arr[] = {20, 22, 23, 0};

Ответ 5

Вам не нужно иметь '\0' char в конце массива символов! Это неправильное предположение. Нет правила, которое говорит, что вы это делаете. Символы (char type) точно подобны любым другим данным.

Вам нужно иметь нулевой конец char, если вы хотите печатать массив с помощью стандартных printf -семейных функций. Но только потому, что эти функции зависят от окончания массива символов - '\0' char.

Функции часто имеют правила, касающиеся ожидаемых данных. Функции String (char[]) не являются исключением. Но это не требование языка, это API, который вы используете, который имеет эти требования.

Ответ 6

Вам нужно завершить строки C с помощью '\0', так как библиотека знает, где заканчивается строка.
NUL -терминация - это то, что отличает массив char от строки (a NUL -terminated char -array). Большинство функций управления строкой полагаются на NUL, чтобы знать, когда строка завершена (и ее работа выполнена), и не будет работать с простым char -array (например, они будут продолжать работать за пределами границ массив, и продолжайте, пока он не найдет NUL где-то в памяти - часто повреждает память, когда она идет).

Ответ 7

Char массив заканчивается специальным char '\0', поэтому его можно рассматривать как строку. И когда вы манипулируете строкой, должен быть какой-то способ указать длину (границу) этой строки.

Посмотрите на прототип функции strcpy

char * strcpy ( char * destination, const char * source );

Как известно, чтобы скопировать количество символов из источника в пункт назначения? Ответ заключается в том, чтобы посмотреть на позицию '\0 '.

'\0' char заметен при работе со строкой как char *. Без '\0' в качестве конечного маркера вы не смогли бы обрабатывать char * как строку.

Ответ 8

Массив char не обязательно заканчивается на \0.

Это соглашение C, что строки заканчиваются на \0.
Это полезно, чтобы найти конец строки.

Но если вас интересует только сохранение данных типа char, вы можете иметь \0 в конце или нет.

Если ваш массив из char предназначен для использования в качестве строки, вы должны добавить \0 в конце.

EDIT. То, что заканчивается на \0, это строковые литералы, а не массив char.
Вопрос плохо сформулирован.

Ответ 9

Массивы сами по себе не должны быть 0\ завершены, это использование массивов символов определенным образом, чтобы они были \0 завершены. Стандартные функции библиотеки, которые действуют на массивы символов, будут использовать \0 для обнаружения конца массива и, следовательно, рассматривать его как строку, это означает, что пользователи этих функций должны будут следовать условию завершения \0. Если использование вашего символьного массива не использует такую ​​функциональность, ему не нужен терминатор \0.

Ответ 10

Пример, чтобы понять, как \0 запутается, если взять его в целочисленном массиве: -

int marks[]={20,22,23,0,93,'\0'};
                      ^  

Итак, теперь ваш массив будет считать, что 0 (помечено) является концом массива, который не является истинным.

\0 обычно используется для завершения строки. В строке \0 рассматривается как конец строки.

В вашем примере вам не нужно завершать его с помощью '\ 0'

Нашел очень интересный wiki пост: -

В то время, когда C (и языки, из которых он был получен),, память была чрезвычайно ограниченной, поэтому, используя только один байт накладные расходы для хранения длины строки были привлекательными. Единственный популярной альтернативой в то время, обычно называемой "строкой Паскаля", (хотя также использовались ранними версиями BASIC), использовали ведущий байт для сохраните длину строки. Это позволяет содержать строку NUL и для того, чтобы найти длину, требуется только один доступ к памяти (O (1) (постоянное) время). Однако дизайнер C Деннис Ритчи решил следовать соглашение о NUL-завершении, уже установленное в BCPL, избегайте ограничения на длину строки, вызванной счет в 8- или 9-битном слоте, а отчасти потому, что сохранение счета казалось, по нашему опыту, менее удобно, чем использование терминатора.

Также проверьте связанный пост: - nul, завершающий массив int

Ответ 11

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

• Соблюдайте длину и передайте ее вместе с указателем.

  Так обычно работают массивы. Он не требует специального форматирования и делает представление субматрицы тривиальным для представления. (Добавьте к указателю, вычтите из длины, и там ya go.)

  Любая функция в стандартной библиотеке, которая работает с нестроковыми массивами, ожидает этого уже. И даже некоторые функции, которые возились со строками (например, strncat или fgets), делают это ради безопасности.

• Завершить массив с некоторым значением "дозорного".

  Вот как работают строки C. Поскольку почти каждый существующий набор символов/кодирование определяет '\0' как непечатаемый, "ничего не делать" управляющий символ, он, таким образом, не является типичной частью текста, поэтому использование его для прекращения строки имеет смысл.

  Обратите внимание, что при использовании char[] в качестве массива байтов вам все равно нужно указать длину. Это потому, что байты не являются символами. Когда вы имеете дело с байтами, а не с символами, 0 теряет смысл в качестве контрольного значения и возвращается к простым старым данным.

  Большая проблема заключается в том, что с большинством фундаментальных типов каждая возможная компоновка байтов sizeof(type) может представлять действительное полезное значение. Для интегральных значений особенно часто встречается нуль; это, вероятно, один из самых используемых и наиболее полезных номеров во всех вычислениях. Я полностью ожидаю, что смогу добавить 0 в массив целых чисел, не потеряв половину моих данных.

  Итак, возникает вопрос, что было бы хорошим дозорным значением? Какой другой законный номер должен быть объявлен вне закона в массивах? И этот вопрос не имеет хорошего, универсального ответа; это полностью зависит от ваших данных. Поэтому, если вы хотите что-то сделать, вы сами.

  Помимо отсутствия достойного дозорного значения, этот подход падает с несимвольными типами по другой причине: сложнее представлять подмножества массива. Чтобы рекурсивная функция передавала часть массива самому себе, она должна была бы вставить значение дозорности, вызвать себя, а затем восстановить старое значение. Либо это, либо он может передать указатель на начало диапазона и длину диапазона. Но подождите... это не то, чего вы пытаетесь избежать?: P

Для полноты два других метода:

• Создать структуру, которая может хранить длину массива вместе с указателем на данные.

  Это более объектно-ориентированный подход, и как массивы работают почти на каждом современном языке (и как работают векторы на С++). Он работает нормально в C, если у вас есть API для управления такими структурами, и если вы используете этот API религиозно. (Объектно-ориентированные языки обеспечивают способ привязки API к самому объекту. C не делает этого, поэтому вам следует придерживаться API.) Но любая функция, которая не была разработана для работы с вашими структурами, должна будет передается указатель (и, возможно, длина) с использованием одного из двух указанных выше методов.

• Пропустите два указателя.

  Это распространенный способ передать "диапазон" в С++. Вы передаете указатель на начало массива, а указатель - только за конец. Однако он менее распространен в C, потому что с необработанными указателями (start,length) и (start,end) представляют одни и те же данные - и C не имеет итераторов и шаблонов, которые делают это гораздо более полезным.

Ответ 12

В c, несмотря на другой язык, у вас нет массива Char, или может быть сказано, что у него нет строкового типа данных. \0 укажите конец строкового типа или массив char.

Ответ 13

У нас есть соглашение: специальный символ '0' с цифровым кодом 0, отмечает конец строки.

Но если вы хотите пометить конец массива int, как вы узнаете, что 0 является допустимым членом массива или знаком конца массива? Таким образом, в целом невозможно иметь такую ​​отметку.

Другими словами:

Символ '\0' (но не символ '0', код 48) не имеет никакого смысла в контексте текстовой строки (по соглашению, это специальный символ, который заканчивается), поэтому может использоваться как маркер конца массива:

Целое число 0 или \0 (то же самое), являются действительными целыми числами. Он может иметь смысл, поэтому он не может использоваться как маркер конца массива:

int votesInThisThread[] = { 0, -1, 5, 0, 2, 0 }; // Zeroes here is a valid numbers of upvotes

Если вы попытаетесь обнаружить конец этого массива примеров, выполнив поиск 0, вы получите размер 0.

Вот о чем вопрос?