Отказ сегментации в strcpy

Существует три типа поведения стандартов, которым необходимо интересоваться.

1/Определенное поведение. Это будет работать над всеми соответствующими реализациями. Используйте это свободно.

2/определенное Реализацией поведение. Как указано, это зависит от реализации, но по крайней мере это все еще определяется. Реализации требуются, чтобы документ, что они делают в этих случаях. Используйте это, если Вы не заботитесь о мобильности.

3/Неопределенное поведение. Что-либо может произойти. И мы имеем в виду что-либо, до и включая Ваш весь компьютер, выходящий из строя в явную особенность и глотающий себя, Вас и значительную долю Ваших коллег. Никогда не используйте это. Когда-либо! Серьезно! Не заставляйте меня приехать туда.

Копирование больше, что 4 символа и нулевой байт к a char[5] неопределенное поведение.

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

Увеличьте размер массива к чему-то более подходящему (char[14] в этом случае с доступной информацией) или использование некоторая другая структура данных, которая может справиться.

Обновление:

Так как Вы кажетесь настолько обеспокоенными обнаружением, почему дополнительные 7, символы не вызывают проблемы, но 8 символов, делают, давайте предусмотрим возможное расположение стека на вводе main(). Я говорю "возможный", так как фактическое расположение зависит от соглашения о вызовах, которое использует Ваш компилятор. Так как C запускают вызовы кода main() с argc и argv, стек в начале main(), после выделения места для a char[5], мог быть похожим на это:

+------------------------------------+
| C start-up code return address (4) |
| argc (4)                           |
| argv (4)                           |
| x = char[5] (5)                    |
+------------------------------------+

Когда Вы пишете байты Hello1234567\0 с:

strcpy (x, "Hello1234567");

кому: x, это перезаписывает argc и argv но, по возврату из main(), это хорошо. Конкретно Hello заполняет x, 1234 заполняет argv и 567\0 заполняет argc. Если Вы на самом деле не пытаетесь использовать argc и/или argv после этого Вы будете хорошо:

+------------------------------------+ Overwrites with:
| C start-up code return address (4) |
| argc (4)                           |   '567<NUL>'
| argv (4)                           |   '1234'
| x = char[5] (5)                    |   'Hello'
+------------------------------------+

Однако, если Вы пишете Hello12345678\0 (отметьте дополнительное "8") к x, это перезаписывает argc и argv и также один байт обратного адреса так, чтобы, когда main() попытки возвратиться к C запускают код, он уходит в волшебную землю вместо этого:

+------------------------------------+ Overwrites with:
| C start-up code return address (4) |   '<NUL>'
| argc (4)                           |   '5678'
| argv (4)                           |   '1234'
| x = char[5] (5)                    |   'Hello'
+------------------------------------+

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

Это - то, под чем они подразумевают неопределенный: Вы не знаете то, что собирается произойти.