Pourquoi c++ supporte-t-il l'assignation des tableaux par memberwise dans les structures, mais pas en général?

Voici mon point de vue:

le développement du langage C offre un aperçu de l'évolution du type de tableau en C:

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

je vais essayer de décrire le tableau de chose:

C précurseurs B et BCPL avait pas de distinction de type tableau, une déclaration comme:

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

déclarerait que V est un pointeur (non typé) qui est initialisé pour pointer vers une région inutilisée de 10" mots " de mémoire. B a déjà utilisé * pour le déréférencement de pointeur et a eu la [] courte notation de main, *(V+i) signifie V[i] , tout comme dans C/C++ aujourd'hui. Cependant, V n'est pas un tableau, c'est toujours un pointeur qui a pour point de mémoire. Cela a causé des problèmes lorsque Dennis Ritchie a essayé d'étendre B avec les types de struct. Il voulait que les tableaux fassent partie des structures, comme en C aujourd'hui:

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

mais avec le concept B,BCPL de tableaux comme pointeurs, cela aurait exigé le champ name pour contenir un pointeur qui devait être initialisé à l'exécution à une région de mémoire de 14 octets dans la structure. Le problème d'initialisation/mise en page a finalement été résolu en donnant aux tableaux un traitement spécial: le compilateur traquerait l'emplacement des tableaux dans les structures, sur la pile, etc. sans réellement exigeant le pointeur vers les données de matérialiser, sauf dans les expressions qui impliquent les tableaux. Ce traitement a permis à presque tout le code B de fonctionner encore et est la source de la "tableaux convertir en pointeur si vous les regardez" règle. C'est un hack de compatibilité, qui s'est avéré être très pratique, parce qu'il permettait des tableaux de taille ouverte etc.

et voici ma conjecture pourquoi tableau ne peut pas être assigné: depuis tableaux ont été pointeurs en B, vous pouvez simplement écrire:

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

pour reformuler un"tableau". Cela n'avait plus de sens, car la base d'une variable de tableau n'était plus une valeur de l. Cette affectation a donc été rejetée, ce qui a aidé à attraper les quelques programmes qui ont fait ce rebasement sur les tableaux déclarés . Et puis cette notion est restée: comme les tableaux n'ont jamais été conçus pour être des citoyens de première classe du système de type C, ils ont été le plus souvent traités comme des bêtes spéciales qui devenir pointeur si vous les utilisez. Et d'un certain point de vue (qui ignore que les c-arrays sont un hack bâclé), le fait de ne pas accepter l'assignation de tableau a encore un certain sens: un tableau ouvert ou un paramètre de fonction de tableau est traité comme un pointeur sans information de taille. Le compilateur n'a pas l'information pour générer une assignation de tableau pour eux et l'assignation de pointeur était nécessaire pour des raisons de compatibilité. L'introduction de l'assignation des tableaux pour les tableaux déclarés aurait introduit des bogues bien que les affectations fictives (est-ce que a=b est une affectation de pointeur ou une copie élémentaire?) et d'autres problèmes (Comment passer un tableau par valeur?) sans réellement résoudre un problème - il suffit de tout rendre explicite avec 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
}

cela n'a pas changé quand une révision de C en 1978 a ajouté une assignation de structure ( http://cm.bell-labs.com/cm/cs/who/dmr/cchanges.pdf ). Même si les enregistrements étaient des types distincts en C, ils étaient il N'était pas possible de les attribuer au début de K&R C. Vous deviez les copier par le membre avec memcpy et vous ne pouviez leur passer que des pointeurs comme paramètres de fonction. L'affectation (et le passage de paramètre) était Maintenant simplement défini comme la mémoire de la mémoire brute de la structure et comme cela ne pouvait pas briser le code exsisting, il était immédiatement affiché. Comme un effet secondaire non intentionnel, cela a implicitement introduit une sorte de tâche de tableau, mais cela s'est produit quelque part à l'intérieur d'une structure, donc cela ne pourrait pas vraiment introduire problèmes avec la façon dont les tableaux ont été utilisés.