Почему C и C ++ поддерживают присваивание для каждого элемента массивов внутри структур, но не в целом?

Вот мое мнение по этому поводу:

The Development of the C Language предлагает некоторое понимание эволюции типа массива в C:

• http://cm.bell-labs.com/cm/cs/who/dmr/chist.html

Попробую изложить суть массива:

Предшественники C - B и BCPL - не имели четкого типа массива, объявление типа:

auto V[10] (B)
or 
let V = vec 10 (BCPL)

объявляло бы V как (нетипизированный) указатель, который инициализируется, чтобы указывать на неиспользуемую область в 10 "слов" памяти. B уже использовал * для разыменования указателей и имел [] короткую ручную нотацию, *(V+i) означало V[i], как и в C/C++ сегодня. Однако V не является массивом, это все еще указатель, который должен указывать на некоторую память. Это вызвало проблемы, когда Деннис Ричи попытался расширить B типами struct. Он хотел, чтобы массивы были частью структур, как в современном Си:

struct {
    int inumber;
    char name[14];
};

Но с концепцией B,BCPL о массивах как указателях, это потребовало бы, чтобы поле name содержало указатель, который должен был инициализироваться во время выполнения на область памяти в 14 байт внутри struct. Проблема инициализации/размещения была в конечном итоге решена путем предоставления массивам особого режима: Компилятор отслеживал расположение массивов в структурах, на стеке и т.д., не требуя материализации указателя на данные, за исключением выражений, в которых задействованы массивы. Такое обращение позволяло почти всему коду B продолжать работать и является источником правила "массивы преобразуются в указатели, если на них посмотреть". Это хак совместимости, который оказался очень удобным, потому что позволял использовать массивы открытого размера и т.д.

И вот моя догадка, почему массив не может быть присвоен: Поскольку в B массивы были указателями, вы могли просто написать:

auto V[10];
V=V+5;

чтобы перебазировать "массив". Теперь это было бессмысленно, потому что база переменной массива больше не была l-значением. Так что это назначение было запрещено, что помогло отловить те немногие программы, которые делали этот rebasing на объявленных массивах. А потом это понятие прижилось: Поскольку массивы никогда не были предназначены для того, чтобы стать первоклассным объектом системы типов языка Си, к ним стали относиться как к особым зверям, которые становятся указателями, если вы их используете. И с определенной точки зрения (которая не учитывает, что массивы в Си - это неудачный хак), запрет на присваивание массивов все еще имеет некоторый смысл: Открытый массив или параметр функции массива рассматривается как указатель без информации о размере. У компилятора нет информации, чтобы сгенерировать для них присвоение массива, а присвоение указателя было необходимо по соображениям совместимости. Внедрение присваивания массива для объявленных массивов привело бы к ошибкам, включая ложные присваивания (является ли a=b присваиванием указателя или поэлементным копированием?) и другие проблемы (как передать массив по значению?), не решив проблему - просто сделайте все явным с помощью memcpy!

/* Example how array assignment void make things even weirder in C/C++, 
   if we don't want to break existing code.
   It's actually better to leave things as they are...
*/
typedef int vec[3];

void f(vec a, vec b) 
{
    vec x,y; 
    a=b; // pointer assignment
    x=y; // NEW! element-wise assignment
    a=x; // pointer assignment
    x=a; // NEW! element-wise assignment
}

Это не изменилось, когда в ревизии C в 1978 году было добавлено присвоение структур ( http://cm.bell-labs.com/cm/cs/who/dmr/cchanges.pdf ). Хотя записи были отдельными типами в Си, в раннем K&R Си их нельзя было присваивать. Их нужно было копировать по членам с помощью memcpy, а в качестве параметров функции можно было передавать только указатели на них. Присвоение (и передача параметров) теперь определялось просто как memcpy сырой памяти структуры, и поскольку это не могло нарушить существующий код, оно было легко внедрено. Как непреднамеренный побочный эффект, это неявно вводило некое присваивание массивов, но это происходило где-то внутри структуры, так что это не могло создать проблем с использованием массивов.